Ich breche mir hier gerade das Gehirn bei dem Versuch, eine SharedMem-Klasse zu implementieren.

Also:
Ich habe ein SharedMem-Klassentemplate, welches
1. die Mutexe für den Zugriff auf den SharedMem verwaltet.
2. beliebige Datentypen als SharedMem aufnehmen kann.

template<class T>
class MutexSharedMem {
private:
	pthread_mutex_t signalMutex;
	pthread_mutex_t memMutex;
	T* data;
public:
	MutexSharedMem();
	MutexSharedMem(T*);
	virtual ~MutexSharedMem();
	T *read();
	void write(T*);
};

Von diesem SharedMem des jeweiligen Typs soll nur ein Objekt existieren. Dies wollte ich mit einer Factory-Klasse erledigen.

template<class T>
class MutexFactory {
private:

protected:
	MutexSharedMem<T> *sharedMem;
public:
	MutexFactory();
	virtual ~MutexFactory();
	MutexSharedMem<T>* create();
};

Als Alternative bietet sich ein Singleton-Muster an, allerdings klappt das alles ganz und gar nicht. Wie kriege ich hin, daß vom SharedMem jeweils nur eine Instanz existiert?

Sobald ich Zeiger auf die Daten verwende, kann ich keine statischen Member-Variablen mehr benutzen.

Ich weiß nicht mehr weiter...

class MutexSharedMemBase
{
protected:
    pthread_mutex_t signalMutex;
    pthread_mutex_t memMutex;
};

template<class T>
class MutexSharedMem : public MutexSharedMemBase {
private:
    T* data;
    MutexSharedMem();
    MutexSharedMem(T*);
public:
    virtual ~MutexSharedMem();
    T *read();
    void write(T*);
    friend class MutexFactory;
};

class MutexFactory {
protected:
    std::map<std::string, MutexSharedMemBase*> sharedMem;
public:
    MutexFactory();
    virtual ~MutexFactory();

    template <class T>
    MutexSharedMemBase* create()
    {
        std::map<std::string, MutexSharedMemBase*>::const_iterator it = sharedMem.find(typeid(T).name());
        if (it != sharedMem.end()) return it->second;
        MutexSharedMemBase* result = new MutexSharedMem<T>();
        sharedMem.insert(std::make_pair(typeid(T).name(), result));
        return result;
    }
};