Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Konstruktor von außerhalb der Klasse aufrufen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
04.11.2011, 13:57 Uhr
banshee



Hallo,

im Rahmen des Singleton-Patterns für C++, habe ich gesehen, dass Konstuktor, Destruktor, Copy-Konstruktor und der Zuweisungsoperator als leere Methoden protected gesetzt wurden.
Dazu zwei Fragen:

1) Wie kann man überhaupt Konstruktoren/Destruktoren außerhalb der Klasse aufrufen?

2) Warum definiert man den Copy-Konstruktur und Zuweisungsoperator überhaupt als leere Methode und lässt sie nicht einfach undefiniert?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
04.11.2011, 15:17 Uhr
ao

(Operator)


Hi,

zu 1: ctor und dtor werden implizit aufgerufen, wenn man die Klasse instanziert bzw. wieder zerstört:


C++:
int main (void)
{
    MyClass cl;  //  Erzeugen von cl und Aufrufen des Default-ctor.

    MyClass * pcl = new MyClass (2); // erzeugen von *pcl und Aufrufen eines parametrierten Konstruktors

    delete pcl; // *pcl zerlegen - Destruktor wird aufgerufen.

}  // Lebensdauer von cl endet - Aufruf des Destruktors.



Zu 2: Zweck der Übung ist, sie von der private- in die protected-Sichtbarkeit zu verlegen, damit Klassen, die von Singleton erben, sie implizit aufrufen können. Man muss also

C++:
protected:
    Singleton();


hinschreiben, und damit sind sie deklariert und müssen auch definiert werden, sonst Linkerfehler.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
15.11.2011, 20:48 Uhr
banshee



Ja, ist klar soweit. Nur wundert es mich, warum folgendes dann fehlerfrei läuft:


C++:
//main.cpp
#include <iostream>
#include "singleton.h"

int run(int argc, char** pp_argv)
{
  Singleton<int>test();//??????????
  return 0;
}

int main(int argc, char** pp_argv) {
  return run(argc, pp_argv);
}




C++:
#ifndef SINGLETON_H
#define SINGLETON_H

template<typename T>
class Singleton
{
protected:
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton& other) {}
    Singleton<T>& operator=(const Singleton<T>& other) {}
    
public:
    static T& inst()
    {
      static T theOneAndOnly;
      return theOneAndOnly;
    }
};

#endif // SINGLETON_H

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
16.11.2011, 08:09 Uhr
ao

(Operator)


Weil das hier:

C++:
int run(int argc, _TCHAR** pp_argv)
{
    Singleton<int>test();
    return 0;
}


nicht, wie du annimmst, ein Objekt vom Typ Singleton mit Namen test anlegt,
sondern eine parameterlose Funktion mit Namen test und Rückgabewert Singleton<int> vereinbart. Es ist ein Prototyp, keine Variablendeklaration.

Du merkst es dann, wenn du in run was mit test machst. Versuch mal, dir test.inst () geben zu lassen.

Das hier:

C++:
int run(int argc, _TCHAR** pp_argv)
{
    Singleton<int>test;  //  ohne Klammern!
    return 0;
}


versucht, ein Objekt zu erzeugen und fällt auch gleich auf die Nase. So, wie die Klasse Singleton gebaut ist, kann sie nicht direkt instanziert werden. Man kann nur von ihr ableiten.

Gern gemachter Fehler

Und der Destruktor sollte public und virtuell sein, damit man ein von Singleton abgeleitetes Objekt über die Basisklasse zerlegen kann:


C++:
class Irgendwas : public Singleton
{
    
};

int main (void)
{
    Singleton * s = new Irgendwas;
    // ....
    delete s;  //  Hier muss ~Singleton() public sein, sonst Protection-Fehler.
               //  Und er muss virtuell sein, sonst wird an dieser Stelle
               //  nur der Singleton zerlegt, aber nicht das Irgendwas.
}


Dieser Post wurde am 16.11.2011 um 08:16 Uhr von ao editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
16.11.2011, 08:13 Uhr
ao

(Operator)


Ähm, noch was: Welchen Sinn hat das hier bei einem Singleton?


C++:
    Singleton(const Singleton& other) {}
    Singleton<T>& operator=(const Singleton<T>& other) {}



Singleton heißt doch gerade, es kann nur einen geben.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
16.11.2011, 13:00 Uhr
banshee



Das wäre dann meine nächste Frage gewesen, denn die Sinnlosigkeit ist mir auch schon aufgefallen. Aber gut, jetzt bin ich ja um einiges schlauer, also schon mal vielen Dank
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: