hier mal etwas code:

#include <iostream>
#include <string>

namespace Private
{
    template<class T, class TMutex>
    struct Proxy
    {
        inline Proxy(TMutex& m, T& v):
        mMutex(m), mVariable(v) { mMutex.lock(); }

        inline ~Proxy() { mMutex.unlock(); }

        inline T* operator->() { return &mVariable; }

        template<class U>
        inline void operator = (const U& val) { mVariable = val; }

    private:
        T&      mVariable;
        TMutex& mMutex;
    };

    template<class T, class TMutex>
    struct Proxy<const T,TMutex>
    {
        inline Proxy(TMutex& m, const T& v):
        mMutex(m), mVariable(v) { mMutex.lock(); }

        inline ~Proxy() { mMutex.unlock(); }

        inline const T* operator->() const { return &mVariable; }

        template<class U>
        inline void operator = (const U& val) const { mVariable = val; }

    private:
        const T& mVariable;
        TMutex&  mMutex;
    };
}

template<class T, class TMutex>
class Protect
{
public:
    template<class ...TArgs>
    Protect(TMutex& m, const TArgs& ...args):
        mMutex(m), mVariable(args...) { }

    inline Private::Proxy<T      ,TMutex> operator->()       { return Private::Proxy<T      ,TMutex>(mMutex, mVariable); }
    inline Private::Proxy<const T,TMutex> operator->() const { return Private::Proxy<const T,TMutex>(mMutex, mVariable); }
    inline Private::Proxy<T      ,TMutex> operator *()       { return Private::Proxy<T      ,TMutex>(mMutex, mVariable); }
    inline Private::Proxy<const T,TMutex> operator *() const { return Private::Proxy<const T,TMutex>(mMutex, mVariable); }

private:
    T       mVariable;
    TMutex& mMutex;
};

struct RecursiveMutexDummy
{
    RecursiveMutexDummy(): counter(0) { }
    void lock  () { std::cout << "lock "   << ++counter << std::endl; }
    void unlock() { std::cout << "unlock " << counter-- << std::endl; }
    int counter;
};

int main(int argc, char* args[])
{
    RecursiveMutexDummy m;
    Protect<std::string,RecursiveMutexDummy> safeString(m, "hello");

    std::cout << "string: '" << safeString->c_str() << "' of size: " << safeString->length() << std::endl;

    *safeString = "world";

    std::cout << "string: '" << safeString->c_str() << "' of size: " << safeString->length() << std::endl;
    return 0;
}

das funktioniert zwar soweit, trotzdem frage ich mich ob das so praktikabel ist (die performance mal außen vor gelassen).
gibt es hier vielleicht irgendwelche schwerwiegenden seiteneffekte, die nicht so offensichtlich sind?

mfg
plassy

hi,
ich versuche eine klasseninstanz mit einem mutex zu verbinden und diesen dann automatisch zu locken, wenn eine memberfunktion der klasseninstanz aufgerufen wird.

...

gibt es hier vielleicht irgendwelche schwerwiegenden seiteneffekte, die nicht so offensichtlich sind?

Deadlocks vlt?

das funktioniert zwar soweit

Nein, tut es nicht.

Nachdem dein Proxy kopierbar ist, und nicht korrekt damit umgeht wenn er kopiert/zugewiesen wird...:

template <class T>
void Kaboom(T t)
{
   T t1 = t;
   T t2 = t;
   T t3 = t;
}

int main(int argc, char* args[])
{
    RecursiveMutexDummy m;
    Protect<std::string,RecursiveMutexDummy> safeString(m, "hello");

    Kaboom(*safeString);
}

Output:

lock 1
unlock 1
unlock 0
unlock -1
unlock -2
unlock -3

Natürlich muss der Proxy zumindest "movable" sein, sonst kann man ihn ja nicht als Returntyp verwenden. Guck dir aber z.B. mal std::auto_ptr an, das ist ein "gutes" Beispiel dafür wie man Klassen auch ohne rvalue Referenzen "movable" machen kann.

Natürlich gibt es auch andere mögliche Lösungen.
Und IMO sollte der Proxy auch "gehalten" werden können, also nicht unbedingt in einem "privaten" Namespace versteckt werden. Grund: wenn man mehrere Zugriffe auf das Objekt machen möchte, ist es vorteilhaft (und manchmal sogar nötig), den Lock über ein paar Statements hinweg zu halten.
Natürlich gibt es in C++0x noch "auto" für solche Fälle, aber C++0x gibt's halt noch nicht (der von mir verwendete Template-Trick ist ja wirklich keine praktikable Lösung).

...

danke für diese brauchbare antwort!
du hast recht. das mit der kopierbarkeit des proxies habe ich nicht bedacht.
allerding soll die proxy-klasse tatsächlich niemand zu gesicht bekommen.
die Protect klasse soll nur die methoden aufrufe von mVariable schützen.

um den lock über mehrere anweisungen zu halten benutze ich eine andere wrapper klasse (ich möchte die funktionalität getrennt halten).

wenn ich den constructor und den copy-constructor des proxies private mache und
die Protect klasse als friend deklariere sollte es eigendlich funktionieren.

ist es aber wirklich garantieret, dass der destructor des proxies aufgerufen wird sobald die anweisung beendet ist?
oder kann es auch sein, dass der destructor erst am ende des blocks aufgerufen wird?
bei letzterem szenario wäre ja die komplette idee hinfällig.

mfg
plassy

hustbaer schrieb:

...

um den lock über mehrere anweisungen zu halten benutze ich eine andere wrapper klasse (ich möchte die funktionalität getrennt halten).

würde mich interessieren warum du das getrennt halten willst.

wenn ich den constructor und den copy-constructor des proxies private mache und
die Protect klasse als friend deklariere sollte es eigendlich funktionieren.

scheint zu gehen. wundert mich jetzt etwas, aber ok.
sogar comeau online frisst das.

ich glaube aber, dass das alleine nicht sicherstellt, dass der copy-ctor nicht aufgerufen wird. compiler die die RVO verwenden werden den copy-ctor nie aufrufen, aber ich würde mich nicht darauf verlassen. zumindest solltest du die entsprechende stelle im standard nachlesen, ob das wirklich garantiert ist.

ist es aber wirklich garantieret, dass der destructor des proxies aufgerufen wird sobald die anweisung beendet ist?
oder kann es auch sein, dass der destructor erst am ende des blocks aufgerufen wird?
bei letzterem szenario wäre ja die komplette idee hinfällig.

vereinfacht kann man IIRC sagen dass return werte (und andere rvalues/temporäre objekte) genau bis zum nächsten ";" leben.

würde mich interessieren warum du das getrennt halten willst.

also mein erstes beispiel war nur schnell zusammengecoded. ich wollte nur das wesentliche rüberbringen... naja...
ich poste mal den code, so wie er aussehen soll um dir mein konzept zu verdeutlichen. der code sollte auch mit jedem compiler funktionieren (hoffe ich... ich bin schon voll in c++0x, sorry)
die Guard klasse ist eigendlich nur ein wapper um einen mutex mit der man die eigendlichen "lock guards" erzeugt

ich hoffe, dass es nicht zu viel ist:

#include <iostream>
#include <list>

namespace Private
{
    template<class T, class TGuard>
    class Proxy
    {
        template<class U, class V> friend class SafeUsage;

        Proxy(TGuard& m, T& v):
            mGuard(m), mVariable(v) { mGuard.lock(); }

        Proxy(const Proxy& p):
            mVariable(p.mVariable), mGuard(p.mGuard) { }

    public:
        ~Proxy() { mGuard.unlock(); }
        T* operator->() { return &mVariable; }

        template<class U>
        void operator = (const U& val) { mVariable = val; }

    private:
        T&      mVariable;
        TGuard& mGuard;
    };

    template<class T, class TGuard>
    class Proxy<const T,TGuard>
    {
        template<class U, class V> friend class SafeUsage;

        Proxy(TGuard& m, const T& v):
            mGuard(m), mVariable(v) { mGuard.lock(); }

        Proxy(const Proxy& p):
            mVariable(p.mVariable), mGuard(p.mGuard) { }

    public:
        ~Proxy() { mGuard.unlock(); }
        const T* operator->() const { return &mVariable; }

        template<class U>
        void operator = (const U& val) const { mVariable = val; }

    private:
        const T& mVariable;
        TGuard&  mGuard;
    };
}

template<class T, class TGuard>
class SafeUsage
{
    template<class U>
    friend class Guard;

    SafeUsage(TGuard& m, T& v):
        mGuard(m), mVariable(v) { }

public:
    Private::Proxy<T      ,TGuard> operator->()       { return Private::Proxy<T      ,TGuard>(mGuard, mVariable); }
    Private::Proxy<const T,TGuard> operator->() const { return Private::Proxy<const T,TGuard>(mGuard, mVariable); }
    Private::Proxy<T      ,TGuard> operator *()       { return Private::Proxy<T      ,TGuard>(mGuard, mVariable); }
    Private::Proxy<const T,TGuard> operator *() const { return Private::Proxy<const T,TGuard>(mGuard, mVariable); }

private:
    T&      mVariable;
    TGuard& mGuard;
};

template<class T, class TGuard>
class SafeScope
{
    template<class U>
    friend class Guard;

    SafeScope(TGuard& m, T& v):
        mGuard(m), mVariable(v) { mGuard.lock(); }

public:
    ~SafeScope() { mGuard.unlock(); }

    T*       operator->()       { return &mVariable; }
    const T* operator->() const { return &mVariable; }
    T&       operator* ()       { return mVariable;  }
    const T& operator* () const { return mVariable;  }

private:
    TGuard& mGuard;
    T&      mVariable;
};

template<class TMutex>
class Guard // ich könnte eigendlich auch gleich von TMutex ableiten... however
{
public:
    void lock  () { mMutex.lock();   }
    void unlock() { mMutex.unlock(); }

    template<class T>
    SafeScope<T,Guard> protectInsideScope(T& var) { return SafeScope<T,Guard>(*this, var); }

    template<class T>
    SafeUsage<T,Guard> protectUsageOf(T& var) { return SafeUsage<T,Guard>(*this, var); }

private:
    TMutex mMutex;
};

struct RecursiveMutexDummy
{
    RecursiveMutexDummy(): counter(0) { }
    void lock  () { std::cout << "lock "   << ++counter << std::endl; }
    void unlock() { std::cout << "unlock " << counter-- << std::endl; }
    int counter;
}; 

int main()
{
    typedef Guard<RecursiveMutexDummy> Guardian;
    typedef std::list<int>             NumberList;

    Guardian   guardian;
    NumberList numbers;

    for(int i=0; i<5; i++)
        numbers.push_back(i);

    // protect whole scope
    {
        SafeScope<NumberList,Guardian> guardedNumbers = guardian.protectInsideScope(numbers);

        for(NumberList::iterator i=guardedNumbers->begin(); i!=guardedNumbers->end(); i++)
            std::cout << *i << std::endl;
    }

    // protect only usage
    {
        SafeUsage<NumberList,Guardian> guardedNumbers = guardian.protectUsageOf(numbers);

        while(guardedNumbers->size())
        {
            std::cout << guardedNumbers->front() << std::endl;
            guardedNumbers->pop_front();
        }
    }

    return 0;
}

bin offen für anregungen

nochmal zu der copy-constructor sache:
der code funktioniert so wie er jetzt ist mit dem g++ auch mit -O0 (keine optimierung).
aber du hast recht, das könnte ein problem werden.
hier müsste noch gekärt werden, wie die richtige vorgehensweise ist.

[edit] ahhh... ok, habs jetzt erst geschnallt . ich könnte die Proxy und SafeScope klassen wie einen auto_ptr implementieren. dann würde immer die richtige anzahl an unlocks aufgrufen[/edit]

mfg
plassy