#include <iostream>
using namespace std;

class Shape
{
    public:
    Shape();
    virtual ~Shape();
    virtual long GetArea() const {return -1;}
    virtual long GetPerim() const {return -1;}
    virtual void Draw() const {};
};

Shape::Shape()
{

}

Shape::~Shape()
{

}

class Circle : public Shape
{
    public:
    Circle(int radius);
    ~Circle();
    long GetArea() const {return 3 * itsRadius * itsRadius;}
    long GetPerim() const {return 6 * itsRadius;}
    void Draw() const;

    private:
    int itsRadius;
    int itsCircumreference;
};

Circle::Circle(int radius)
:itsRadius(radius)
{

}

Circle::~Circle()
{

}

void Circle::Draw() const
{
    cout << "Routine zum Zeichnen eins Kreises\n";
}

class Rectangle
{
    public:
    Rectangle(int len,int width);
    virtual ~Rectangle();
    long GetArea() const {return itsLength * itsWidth;}
    long GetPerim() const {return 2*itsLength + 2*itsWidth;}
    int GetLength() const {return itsLength;}
    int GetWidth() const {return itsWidth;}
    void Draw() const;

    private:
    int itsLength;
    int itsWidth;

};

Rectangle::Rectangle(int len,int width)
:itsLength(len), itsWidth(width)
{

}

Rectangle::~Rectangle()
{

}

void Rectangle::Draw() const
{
    for (int i=0; i<itsLength; i++)
    {
        for (int j=0; j<itsWidth; j++)
        {
            cout << "X";
        }
        cout << "\n";
    }
}

class Square : public Rectangle
{
    public:
    Square(int len);
    Square(int len, int width);
    ~Square();
    long GetPerim() const {return 4 * GetLength();}
};

Square::Square(int len)
:Rectangle(len,len)
{

}

Square::Square(int len,int width)
:Rectangle(len,width)
{
    cout << "Fehler, kein Quadrat....ein Rechteck?\n";
}

int main()
{

    return 0;
}

Es kommt:

Compiling: C:\MinGW\Andi\kapitel 18.cpp
Linking console executable: C:\MinGW\Andi\kapitel 18.exe
C:\MinGW\Andi\kapitel 18.o:kapitel 18.cpp:(.text+0x3d6): undefined reference to vtable for Square' C:\\MinGW\\Andi\\kapitel 18.o:kapitel 18.cpp:(.text+0x400): undefined reference tovtable for Square'
C:\MinGW\Andi\kapitel 18.o:kapitel 18.cpp:(.text+0x42a): undefined reference to vtable for Square' C:\\MinGW\\Andi\\kapitel 18.o:kapitel 18.cpp:(.text+0x454): undefined reference tovtable for Square'
collect2: ld returned 1 exit status
Process terminated with status 1 (0 minutes, 1 seconds)
0 errors, 0 warnings

MfG
Stromberg

Btw, ist es eigentlich Absicht, daß Rectangle nicht von Shape abgeleitet ist?

...daß der Linker sich nicht über den fehlenden Dtor beschwert, liegt an den Eigenheiten des Compilers - der packt die vtable in die Datei mit der ersten virtuellen non-inline Methode der Klasse...

Ist aber schon eine selten dämliche Fehlermeldung, oder ?
Ich habe auch ganz schön gesucht, bis ich das gefunden habe..

@Stromberg: Damit einem sowas nicht passiert, schreibe ich immer erstmal gerne "triviale" Funktionen inline - da sieht man schneller, was noch fehlt.
Danach kann man einzelne Implementationen immer noch auslagern...

Gruß,

Simon2.

CStoll schrieb:

...daß der Linker sich nicht über den fehlenden Dtor beschwert, liegt an den Eigenheiten des Compilers - der packt die vtable in die Datei mit der ersten virtuellen non-inline Methode der Klasse...

Ist aber schon eine selten dämliche Fehlermeldung, oder ?
Ich habe auch ganz schön gesucht, bis ich das gefunden habe..

Schon möglich, aber damit muß man wohl leben (und ohne diese vtable geht's nicht).

So ist das doch schon hübsch

...Schon möglich, aber damit muß man wohl leben (und ohne diese vtable geht's nicht).

Mir leuchtet halt das Vorgehen des Compilers hier nicht ein. Wieso moniert er eine fehlende vtable an und warum fehlt sie, wenn die Implementation EINER Memberfunktion fehlt (was er ja als Letztes feststellt) ?

EDIT: AAAAAH - jetzt hab ich's verstanden !
Der Compiler legt die vtable in dem Modul an, in dem er die erste nicht-inline-Implementierung findet ....
Der Linker möchte die Implementierungen dort "reinhängen" - und dazu braucht er die vtable.

Was passiert eigentlich, wenn man dem Linker in mehreren Modulen eine vtable anbietet ? (wenn man die Implementierungen auf verschiedene cpp's verteilt, die man getrennt compiliert)
Stellt er dann "Identität" fest und entscheidet sich einfach für eine ?

Gruß,

Simon2.

(und für den Linker ist die vtable wichtiger als die nicht definierte Methode, deshalb beschwert er sich darüber, daß sie fehlt)

Edit:

Simon2 schrieb:

Was passiert eigentlich, wenn man dem Linker in mehreren Modulen eine vtable anbietet ? (wenn man die Implementierungen auf verschiedene cpp's verteilt, die man getrennt compiliert)
Stellt er dann "Identität" fest und entscheidet sich einfach für eine ?

Es gibt genau eine "erste" Methode - und wenn die doppelt vorkommt, wird der Linker sich darüber vermutlich auch beschweren. Kritisch wird es imho nur, wenn du mit expliziten inline-Angaben rumspielst - aber vermutlich endet das auch in Linkerfehlern.

...Es gibt genau eine "erste" Methode - und wenn die doppelt vorkommt, wird der Linker sich darüber vermutlich auch beschweren. ..

Mir schwebte Folgendes vor:

// MyFatClass.h
class MyFatClass {
// ... säckeweise Funktionsdeklarationen
};

// MyFatClass_impl1.cpp
#include "MyFatClass.h"

void MyFatClass::f1() { } // erste 
void MyFatClass::f2() { }
// ... säckeweise Funktionsdefinitionen

// MyFatClass_impl2.cpp
#include "MyFatClass.h"

void MyFatClass::f1001() { } // erste 
void MyFatClass::f1002() { }
// ... säckeweise Funktionsdefinitionen

Wenn ich nun die beiden cpps getrennt compiliere, stellt der Compiler für jede einmal "eine erste" fest und sollte in beiden objs eine vtable anlegen, die dann der Linker beide findet.
Das ist doch kein sooo exotisches Szenario, dass es bereits die Standardvorgaben sprengt, oder ?

Meine Vorstellung ist eigentlich eher so eine "Identitätsregel für ODR" wie es sie auch bei templates gibt...

Gruß,

Simon2.

Problematisch könnte nur folgendes werden:

//test.h
class test
{
  virtual void f1();//unter normalen Umständen ist das hier die erste Methode
  virtual void f2();
  virtual void f3();
  ...
};

//test1.cpp
#include "test.h"

inline void test::f1(){...}//wurde als inline deklariert, also ist f2 jetzt erste Methode

void test::f3(){...}

//test2.cpp
#include "test.h"
void test::f2(){...}
//hier weiß der Compiler nichts von dem obigen inline, also erwartet er die vtable in der test1.cpp

Danke.

Zu Deinem Beispiel: Mein gcc wirft dann gar ein "undefined symbol f1()" raus...

Gruß,

Simon2.