Ich möchte eine Klasse virtuell machen, damit ich von ihr ableiten kann.
Wie geht das, wenn ich keine abstarkte Funktionen haben?

Danke im Vorraus

PS: Zeig uns mal was du amchen wills, sprich den code

Willst du deine Klasse abstrakt machen, aber keine geeignete Funktion hast, die du rein-virtuell machen könntest, dann mach den Destruktor rein-virtuell (du musst ihn dennoch definieren!).

Ich möchte eine Klasse virtuell machen, damit ich von ihr ableiten kann.
Wie geht das, wenn ich keine abstarkte Funktionen haben?

Wie wär's mit dem Destruktor, der sollte ohne hin virtuell sein. Oder meinst du "abstrakt" im Sinne von nicht instanziierbar? Dann mach einfach den/die Konstruktoren protected.

so ähnlich

so macht man den d'tor virtuell.

Warum soll er den Destruktor rein-virtuell machen? Das ist ein wiederspruch in sich. Um Instanzen von einer abgeleiteten Klassse zu machen, müssen alle rein-virtuellen Fkt. überschrieben werden.

Falsch, sie müssen von der abgeleiteten Klasse definiert werden.

Man soll den Destruktor als virtual deklarieren, damit bei gegebener Speicherverwaltung z.B. mit Zeigern der richtige Destruktor aufgerufen wird.

Dafür macht man ihn virtuell. Rein-virtuell macht man ihn allerdings aus von mir oben genanntem Grund, nämlich um die Klasse abstrakt zu machen.

1310-Logik: Nein, der Destruktor muss definiert werden, also so:

virtual ~object() = 0
{
    // ...
}

@Michael
C/C++ Code:
virtual ~object() = 0
{
// ...ist diese leere Zeile nötig?
}

1310-Logik: Nein, der Destruktor muss definiert werden, also so:

virtual ~object() = 0
{
    // ...
}

huch ach ja, wieder was vergessen. copy paste ist verfänglich..
thx

virtual ~object() = 0 {}

So gehts doch auch oder?
Dann brauch ich keine Implementation in der *.cpp Datei, oder nicht?

@Michael
C/C++ Code:
virtual ~object() = 0
{
// ...ist diese leere Zeile nötig?
}

Nö, is ne Kommentarzeile, da kommt halt der Inhalt des Destruktors rein, sofern du überhaupt was reinschreiben willst.

1310-Logik: Türlich geht das auch. Kannst du auch in der Header-Datei stehen lassen.

Virtuelle Methoden sind nicht zu verwechseln mit rein-virtuellen Methoden. Die Deklaration als virtual besagt nur, dass wenn die Methode von einer abgeleiteten Klasse überschrieben wird bei dem gebrauch von Basisklassenzeigern die richtige Methode aufgerufen wird.

Für rein-virtuelle Methoden gilt das gleiche. Nur kommt ein sehr entscheidender Punkt hinzu: Die Deklaration als rein-virtuell (virtual /* ... */ =0; ) besagt, dass noch keine Implementierung zu dem jetzigen Zeitpunk möglich ist. Man kann die Funktion nicht definieren!! Dieses Konzept dient allein dem Gebrauch in gemeinsamen Schnittstellen. Die Methode wird in den abgeleiteten Klassen implementiert. Geschieht dies nicht handelt es sich bei der abgeleiteten Klasse automatisch um eine rein-virtuelle / abstrakte Klasse.

Michael E: Ich glaube du hat mich nicht verstanden. Vlt verwechselst du virtuelle Methoden mit rein-virtuellen Methoden (ein himmelweiter Unterschied). Wenn man den Destruktor als rein-virtuell deklariert, dann darf es in der Klasse keine Implementierung geben, diese müsste in der abgeleiteten Klasse vorkommen. Destruktoren lassen sich aber nicht überschreiben. Das ist ein Wiederspruch!

Wenn ich meinen Compiler zitieren darf.

class Test
{
  public:
    Test() {}
    virtual ~Test() =0 {}
};

int main()
{
}

Das quitiert der Compiler mit folgenden Fehlermeldungen
main.cpp:5: error: Fehler beim Parsen before {' token main.cpp:5: error: missing ';' before right brace main.cpp:6: error: Fehler beim Parsen before}' token

class Test
{
  public:
    Test() {}
    virtual ~Test() =0; // {}
};

class T2 : Test
{
  public:
    T2() {}
    virtual ~Test()
    {
    }

int main()
{
}

main.cpp:14: error: destructor `Test' must match class name `T2'
main.cpp:19: error: Fehler beim Parsen at end of input

Glaubt ihr es mir jetzt?

lucky_tux schrieb:

Destruktoren lassen sich aber nicht überschreiben. Das ist ein Wiederspruch!

Hier liegst du allerdings falsch. Meyers benutzt z. B. in "Mehr Effektiv C++ Programmieren" Richtlinie 33 einen rein-virtuellen Destruktor.

MECP Richtlinie 33 schrieb:

[...]aber bei seltenen Gelegenheiten sind Sie damit konfrontiert, daß Sie eine Klasse wie AbstractAnimal erzeugen müssen, in der keine der Funktionen natürlicherweise rein virtuell ist. In solchen Fällen ist das übliche Vorgehen, den Destruktor rein virtuell zu machen; [...]

Außerdem sagt der Standard folgendes unter 12.4.7:

A destructor can be declared virtual or pure virtual; if any objects of that class or any derived class are created in the program, the destructor shall be defined. If a class has a base class with a virtual destructor, its destructor (whenever user- or implicitly-declared) is virtual.

Also ist mein Vorgehen, nämlich eine Klasse abstrakt zu machen, indem man den Destruktor rein-virtuell macht, richtig.

Man kann die Funktion nicht definieren!!

Doch und ob man das kann.

ISO Standard 10.4/2 schrieb:

An abstract class is a class that can be used only as a base class of some other class; no objects of an abstract class can be created except as subobjects of a class derived from it. A class is abstract if it has at least one pure virtual function. A virtual function is specified pure by using a purespecifier (9.2) in the function declaration in the class declaration. A pure virtual function need be defined only if explicitly called with the qualifiedid syntax (5.1).

Folgender Code ist absolut korrekt:

class Foo{
public:
  virtual void bar()=0;
};

void Foo::bar(){

}

Bedenkte ich kann Foo::bar immer aufrufen wenn ich Foo::bar und nicht nur bar schreibe.

Da ein Destruktor immer implizit den Destruktor der Basisklasse aufruft muss dieser definiert sein.

Was allerdings nicht geht ist folgendes

class Foo{
public:
  virtual void bar()=0{};
};

Eine pure virtuelle Funktion kann nicht in der Klassendefinition definiert werden.

Wieso er bei deinem zweitem Bespiel meckert sollte offensichtlich sein.

main.cpp: In function int main()': main.cpp:28: error: cannot declare variable \a' to be of type `Abgeleitet'
main.cpp:28: error: because the following virtual functions are abstract:
main.cpp:21: error: virtual Abgeleitet::~Abgeleitet()
main.cpp:21: error: virtual Abgeleitet::~Abgeleitet()

Dass es nicht möglich ist eine Instanz von der Klasse Basis zu erstellen ist klar, da es sich hiebei um eine rein-virtuelle Schnittstelle handelt. Dieses Interface dient der Klasse Abgeleitet als Basisklasse. Wenn es stimmt, was du sagst, muss es möglich sein eine Instanz von der Klasse Abgeleitet zu erstellen, _ohne_ die Deklaration der Klasse Basis zu veränder. Wenn du mir eine Möglichkeit zeigst, eine Instanz von der Klasse Abgeleitet zu erzeugen muss ich eingestehen, dass du Recht hast... Jetzt bin ich gespannt!

class Basis
{
public:
  virtual ~Basis() =0;
};

Basis::~Basis()
{ /* ... */ }

class Abgeleitet : public Basis
{
public:
  virtual ~Abgeleitet();
};

Abgeleitet::~Abgeleitet()
{ /* ... */ }

int main()
{
  // Basis a;
  Abgeleitet a;
}

Du hast abgeleitet (unabsichtlich?) ebenfalls zu ner abstrakten Klasse gemacht.

Das hingegen:

class Basis
{
public:
  virtual ~Basis() =0;
};

Basis::~Basis()
{ /* ... */ }

class Abgeleitet : public Basis
{
public:
  virtual ~Abgeleitet(); // = 0;
};

Abgeleitet::~Abgeleitet()
{ /* ... */ }

int main()
{
  // Basis a;
  Abgeleitet a;
}

geht wunderbar, und ich habe nicht die Deklaration von Basis verändert, ganz wie gewünscht. Destruktor rein-virtuell und mit Definition schliessen sich also nicht aus.

Das ist schon ein wenig verwirrend, die Ähnlichkeit der beiden Begriffe und die doch teils völlig unterschiedliche Anwendung

Aber nun gut ich glaube jetzt hat sich das Thema ausdiskutiert

Klasse A
Klasse B
Klasse C
Klasse D

Die Klassen B und C erben von A und D erbt von B und C
Jetzt enhält D zweimal A(was zu einem kompilerfehler führt).
Das kann man verhindern indem man B und C virtual von A erben läss.

Wenn eine Klasse virtual deklariert wurde dann verhindert das die Klasse ausversehen 2mal geerbt wurde.

Das nennt sich virtuelle Vererbung :p