Zeiger auf eine Instanz einer Klasse

Hallo zusammen

ich habe ein kurze frage.
Ich habe eine Klasse geschrieben von der ich in meinem Programm nur eine
Instanz davon starten will und kann.
Mein Problem ist, dass ich von anderen Klassen auf diese Instanz der besagten Klasse
zugreifen muss.
Gibt es da noch Lösungen außer Singeltons?

Gruß Horst

drakon

Du übergibst bei der Erstellung eines anderen Objektes einen Zeiger oder Referenz auf das erste Objekt.

class foo{
public:
  void f(){}
};

class bar
{
 public:
  bar(foo* f)mf(f){}
  void blubb()
  {
    mf->f();
  }
 private:
  foo* mf;
};

int main()
{
 foo f;
 bar b(&f);
 b.blubb();
}

Danke für die schnelle Antwort, aber das funktioniert nicht.
Der meckert bei
bar(foo* f)mf(f){}
Kannst du dir das nochmal anschauen ?

Gruß

314159265358979

Er hat nen Doppelpunkt vergessen.

bar(foo* f) : mf(f){}

Ok danke,

jetzt funktionierst.

Das ist klar, bar(foo* f), Konstruktor aber was bedeutet dann
: mf(f){} ?

Danke nochmals.

314159265358979

Stichwort: Initialisierungsliste

drakon

Das ist die Initialisierungsliste. Sie ist dafür verantwortlich, dass die Member initialisiert werden. Eine Zuweisung im Konstruktor ist keine Initialisierung.

Danke.

Jetzt nochmal zum Thema Initialisierungsliste.
Was genau macht dieser Teil des Codes ?

mf(f){}

Was genau wird hier Initialisiert ?
Ich dachte eine Initialisierungsliste braucht man
bei Referenzen oder konstanten Membern ?

Gruß Horst

314159265358979

Kann (soll) man auch bei normalen Membern verwenden, wenn man keinen guten Grund dagegen hat.

asc

Horst der Alte schrieb:

Jetzt nochmal zum Thema Initialisierungsliste...
Ich dachte eine Initialisierungsliste braucht man bei Referenzen oder konstanten Membern ?

Grundsätzlich: Initialisierungen sind wo möglich Zuweisungen immer vorzuziehen.

Horst der Alte schrieb:

Was genau macht dieser Teil des Codes ?
mf(f){}
Was genau wird hier Initialisiert ?

In der Initialiserungsliste steht immer links die Membervariable, und rechts in Klammern der Wert, mit der sie initialisiert wird. Dies funktioniert auch bei gleicher Benennung von Membervariablen und Parametern:

class A {
  public:
    A(int a, int b);
  private:
    int a;
    int b;
};

A(int a, int b)
: a(a), // Links: A.a  Rechts: Parameter a
  b(b)  // Links: A.b  Rechts: Parameter b
{ // <-- Hier ist die Initialisierung bereits abgeschlossen.
  //     alles was im Konstruktorrumpf erfolgt ist eine nachträgliche Zuweisung.
}

Zwingend sind Initialisierungslisten nur bei Referenzen und Konstanten, aber allgemein sollte man sie sich bei allen Membervariablen angewöhnen (Und, da die unabhängig von der Reihenfolge in der Initialisierungsliste immer in Reihenfolge der Deklaration im Header erfolgen, sollte man die Reihenfolge identisch halten.

class A {
  public:
    A(int a, int b);
  private:
    int m_a;
    int m_b;
};

A(int a, int b)
: m_b(a + b),  // Fallstrick: Initialisierung läuft in Reihenfolge
  m_a(m_b + 2) // der Deklaration ab (m_a, m_b). Daher ist die Abhängige
               // Zuweisung von m_a undefiniert! Reihenfolgen daher im Header
               // und der Initialisierungsliste möglichst in gleicher
               // Reihenfolge halten.
{
}

314159265358979

asc schrieb:

A(int a, int b)
: m_b(a + b),  // Fallstrick: Initialisierung läuft in Reihenfolge
  m_a(m_b + 2) // der Deklaration ab (m_a, m_b). Daher ist die Abhängige
               // Zuweisung von m_a undefiniert! Reihenfolgen daher im Header
               // und der Initialisierungsliste möglichst in gleicher
               // Reihenfolge halten.
{
}

Wow, wieder was gelernt. Jetzt weiß ich endlich, warum mir der GCC damals bei Qt mit diesen dämlichen Warnings auf den Sack gegangen ist

Danke an alle. Hab's nun verstanden.

Gruß Horst