[C++]Singleton Pattern

[Verwijderd]

Het volgende probleem dient zich aan bij mij.

In onderstaande code probeer ik een Singleton class te bouwen:

BOND.h

C++:

class BOND {

    private:
    vector<int>*    kaarten;
    static BOND*    deBond;
    
    protected:
    BOND();
    BOND(const BOND&);
    BOND& operator=(const BOND&);
    
    public:
    ~BOND();
    BOND*           instance();
    bool            controleerKaart(int nummer);
};

BOND.cc (deels)

C++:

#include "BOND.h"

BOND * BOND::deBond = 0;

BOND::BOND(){
    this->kaarten = new vector<int>;
    //uitTeDelenKaarten vullen met nummers
    for(int i=1; i<1001; i++){
        this->kaarten->push_back(i);
    }
}

BOND*   BOND::instance(){
    if(deBond == 0){
        deBond = new BOND();
    }
    return deBond;
}

Nou roep ik een andere class (waar BOND.h ge-include wordt) aan:

return BOND::instance()->eenMethode();

De error die ik dan krijg bij compilen:

Test.cc: In member function `bool Test::test1()':
Test.cc:28: error: cannot call member function `BOND* BOND::instance()'
without object
make: *** [Dierentuin.o] Error 1

Volgens mij heb ik me netje gehouden aan de regels om een Singleton te implementeren, dus snapnie waarom het niet door de compiler komt.

[whoami]

Jouw 'Instance' method moet een static zijn.

[Verwijderd]

Ik zag het net....gooi maar dicht...

Als je een probleem tegenkomt en je staart er 3 uur naar zie het niet meer. Ik haal net koffie, kijk nogmaals en toen zag ik het....

thx anyway

[Verwijderd]

Waarom maak je voor een Singleton klasse een copy constructer en implementeer je een assignment operator?

[curry684]

Verwijderd schreef op vrijdag 08 april 2005 @ 10:33:
Waarom maak je voor een Singleton klasse een copy constructer en implementeer je een assignment operator?

Omdat dit compileert:

C++:

class MyClass
{
protected:
                    MyClass();
//                    MyClass(const MyClass&);
//  MyClass&          operator=(const MyClass&);
    
public:
                   ~MyClass();
  static MyClass*   instance();
};

int main() 
{
  MyClass*    instance = MyClass::instance();
  MyClass     second = *instance;
  
  second = *instance;
  return 0;
}

[MSalters]

Tsja, een gevalletje wiel opnieuw uitvinden, maar nu met hoekjes.
Ten eerste heb je wel een new Bond, maar geen delete. Ten tweede heb je een zinloze vector<int>* waar je een member vector<int> verwacht. Ten derde enforce je niet dat er maar een Bond object is; een base Bond is ook een object - en protected suggeert dat je uitgaat dat Bond als base class wordt gebruikt. Ten vierde is je instance() niet thread-safe. Kom je toevallig vanuit een Java achtergrond?

De standaard instance() is overigens

C++:

Bond& Bond::instance( ) {
  static Bond oo7;
  return oo7;
}

Elegant, niet waar?

[ Voor 5% gewijzigd door MSalters op 08-04-2005 11:05 ]

[Verwijderd]

curry684 schreef op vrijdag 08 april 2005 @ 10:49:
[...]

Omdat dit compileert:

C++:

class MyClass
{
protected:
                    MyClass();
//                    MyClass(const MyClass&);
//  MyClass&          operator=(const MyClass&);
    
public:
                   ~MyClass();
  static MyClass*   instance();
};

int main() 
{
  MyClass*    instance = MyClass::instance();
  MyClass     second = *instance;
  
  second = *instance;
  return 0;
}

Het ontgaat mij wat je hiermee probeert te zeggen...

[curry684]

Verwijderd schreef op vrijdag 08 april 2005 @ 11:13:
[...]

Het ontgaat mij wat je hiermee probeert te zeggen...

Dat stukje code wat ik daar geef genereert bij gebrek aan expliciete implementaties default copy constructors en assignment operators, die dus een bitwise copy uitvoeren waarmee je alsnog meerdere instances van je class hebt rondslingeren (met memoryleaks galore wsch). Door copy ctr en assignment operator protected te definieren (of liever nog private eigenlijk) voorkom je dit, je hoeft ze niet eens te implementeren.

[.oisyn]

of liever nog private eigenlijk

Dát is wat je wilt, niet protected, dat impliceert dat er wel degelijk meerdere instances kunnen zijn omdat ie gesubclassed kan worden. Je wilt je ctor, copy ctor, dtor en assignment operator dus stuk voor stuk private hebben.

[Verwijderd]

curry684 schreef op vrijdag 08 april 2005 @ 11:18:
Door copy ctr en assignment operator protected te definieren (of liever nog private eigenlijk) voorkom je dit, je hoeft ze niet eens te implementeren.

Vergeef me curry684, maar ik ga toch es muggenziften: niet definieren, maar declareren
Verder heb je natuurlijk volledig gelijk.

snapie: die 'this->' schrijven hoeft trouwens ook niet in C++; spaart je weer wat typwerk