ich bin leicht am Verzweifeln was meine Programmstruktur angeht (wahrscheinlich ist der ein oder andere jetzt schon am durchdrehen ^^ ich bin Neuling und würde mich über jede Hilfe freuen). Ich versuche es euch möglichst einfach zu beschreiben.

Ich besitze 3 Klassen, welche jeweils Rechenfunktionen einer 4. Klasse nutzen. Das Problem ist folgendes: Die 4. Klasse sollte nur einmal initialisiert werden und diese Parameter von den 3 Klassen bei Nutzung der 4. Klasse genutzt werden. Deshalb übergebe ich an die 3 Klassen dasselbe Objekt an derer Konstruktoren.

Die Nutzung der Funktionen der 4. Klasse gestaltet sich meiner Ansicht nach als sehr kompliziert, deshalb suche ich nach einer Alternative.

Macht hier static einen Sinn? Mir fehlt wahrscheinlich die Erfahrung, aber ich hoffe hierdurch dazulernen zu können

Vielen Dank und Grüße
Thomas

Klasse 2-4 stellen alle anderen Klassen dar, welche die Funktionen in Klasse 1 auf unterschiedliche Arten verwenden.

Klasse 5 ist ein Logger, der ähnlich wie Klasse 1, nur einmal initialisiert und dann von Klasse 1-4 verwendet werden kann. Das habe ich bisher mit static realisiert, bin aber nicht so ganz glücklich darüber.

#ifndef TSINGLETON
#define TSINGLETON

template <class T>
class TSingleton
{
protected:
    static T *m_pSingleton;

public:
    inline static T* Get()
    {
        if (!m_pSingleton)
            m_pSingleton = new T;

        return m_pSingleton;
    }

    void Del()
    {
        if (m_pSingleton)
        {
            delete (m_pSingleton);
            m_pSingleton = NULL;
        }
    }
};
template <class T>
T* TSingleton<T>::m_pSingleton = 0;
#endif

lässt klasse 1 und 5 jeweils von singleton erben

class Logger : public TSingleton<Logger>
{
...
};

void foo()
{
   Logger *pLogger = Logger::Get(); // der erste "Get" aufruft erstellt das object
}

Du darfst nur nicht vergessen, wenn du den kram nicht mehr brauchst, "Del()" aufzurufen.

Ein Vogel zwitscherte mir mal das Singletons das pure böse sind.

Ja, weil es nichts anderes als eine globale Variabel ist. Trotzdem hat auch dieses Design Pattern seine Anwendungsfälle. Nämlich dann, wenn es nur eine Instanz geben kann bzw. soll.

Das trifft auf begrenzt vorhandene Ressourcen und auch auf Logging-Klassen durchaus zu.

Ob man Get und Del natürlich genau so implementiert ist Problemabhängig, aber es geht ja um ein Konzept.

hmm, hört sich für mich nach einer möglichkeit für ein singleton an.

Ne überhaupt nicht!

Außerdem sollte man nie von einem Singleton erben, damit schränkt das Design noch mehr ein.

Zurück zum Ausgangsproblem:

Die Klasse, von der es aus kostengründen nur ein Objekt geben soll, via Constructor an die nutzenden Objekte zu geben ist sinnvoll.
Das nennt sich übrigens dependency injection.

Vermutlich besteht das Problem darin zu entscheiden, welche Funktion in KlasseA gehört und welche in KlasseB, C, D.

Wir kennen deine Anforderungen leider nicht genau genug, aber folgende Mutmaßungen stelle ich jetzt mal an.

Klassen sind im Grunde genommen Stratgien -> siehe Strategie-Pattern, da könnte man für die eine gemeinesame Basis-Klasse schaffen, und die benutzt KlasseA

und/oder

Klassen können ersetzt werden durch Policy-Based Design, d.h.
KlasseB erhält im Constructor den A-Pointer und ihre "Aufgabe", bspw. eine freie Funktion