[C++] base class has incomplete type

[SlaadjeBla]

Ik heb een applicatie met een menustructuur. De menu structuur wordt gemaakt door middel van enkele classes.

Er is een IMenuItem interface, met daarin enkele pure virtual functions. Vervolgens zijn er twee sub-classes die van IMenuItem erven.

Nu krijg ik de volgende errors:
menu/DierItem.h:8: base class `IMenuItem' has incomplete type
make: *** [menu/IMenuItem.o] Error 1

en:
menu/WerknemerItem.h:9: base class `IMenuItem' has incomplete type

Op google is veel te vinden over de incomplete type, maar niet de oorzaak van deze error. Wie weet waardoor deze error veroorzaakt wordt? Ik include in beide sub-classes de baseclass (weet niet of dat noodzakelijk is, maar het weghalen geeft geen resultaat).

[staefke]

Een beetje meer code zou handig zijn......
Misschien heb je een aantal pure virtual functions niet geimplementeerd in je subclasses ?
btw welke compiler gebruik je ?

[.oisyn]

De base class is dus nog niet volledig gedefinieerd. Code zou wel handig zijn ja, staat ook in P&W FAQ - De "quickstart"

Deze code geeft die error

C++:

/*
    declaratie van Base, geen definitie.
    Hier zeg je dus: "er bestaat een Base", maar de inhoud geef je nog niet
*/
struct Base;


// definitie van Derived
struct Derived : public Base
{
    // ...
};

// definitie van Base, hier vul je het dus in
struct Base
{
    // ...
};

op het moment dat Derived gedefinieerd wordt is Base alleen nog gedeclareerd, maar de inhoud is nog niet bekend. Base is dus een incomplete type

[ Voor 3% gewijzigd door .oisyn op 12-01-2004 16:28 ]

[curry684]

Uhm oisyn je bent aan het prutsen, die code van jou geeft gewoon als error 'Undefined type Derived'

Als je nu eens de Derived class van de Base class zou inheriten komt het al logischer over

[.oisyn]

Dat staat er toch

[SlaadjeBla]

Wat ik deed - en God mag weten waarom - was een object file proberen te maken van een abstract class. Dit pikte hij dus niet.

de logische manier is uiteraard:

code:

class base{
   public:
      virtual int getInt() = 0;
      virtual string getString() =0;
      virtual ~base(){}
}

class derived : public base{
   public:   
      int getInt();
      string getString();
      virtual ~derived();
}

Ook niet vergeten om de destructor virtual te maken en gelijk een lege body te geven {}. Dat was namelijk de volgende fout van mij, waardoor mij geen linker-errors bespaard bleven.

Een leerzamen en vermoeiende fout.

[.oisyn]

SlaadjeBla schreef op 12 januari 2004 @ 20:06:
Wat ik deed - en God mag weten waarom - was een object file proberen te maken van een abstract class. Dit pikte hij dus niet.

Ik weet niet wat je deed, maar dat kan gewoon hoor. Lege source files kun je ook compilen, net als het compileren van abstract classes. Kun je je exacte code eens geven rond de error?

Ook niet vergeten om de destructor virtual te maken en gelijk een lege body te geven {}. Dat was namelijk de volgende fout van mij, waardoor mij geen linker-errors bespaard bleven.

dat is natuurlijk net zoals bij gewone virtual memberfuncties. Of je implementeert ze, of je maakt ze abstract

[schoene]

Ik vermoed dat hij bedoelt dat hij een instantie probeerde te maken van een abstracte klasse, en dat kan niet he.

C++:

class Base
{
public:
  Base () {}
  virtual ~Base () {}

  virtual DoeIets () = 0;
}

// in code:
Base tmp; // <== kan niet

[.oisyn]

Dan vind ik het een rare error, want Base is in jouw voorbeeld geen incomplete type. Een incomplete type is een type dat wel is gedeclareerd, maar nog niet is gedefinieerd, zoals in mijn voorbeeld bovenaan in deze draad

quote: http://www.kuzbass.ru/docs/isocpp/basic.html#basic.types

3.9.6
A class that has been declared but not defined, or an array of unknown size or of incomplete element type, is an incompletely-defined object type.*

[Footnote: The size and layout of an instance of an incompletely-defined object type is unknown. --- end foonote]

Incompletely-defined object types and the void types are incomplete types (basic.fundamental). Objects shall not be defined to have an incomplete type

[MSalters]

Even opletten: Als je een destructor abstract maakt, dan moet je'm nog steeds definieren.
Dat is omdat een destructor automatisch aangeroepen wordt door de derived destructor, en bij een normale virtual functie gebeurt dat niet.

[Verwijderd]

msalters : bedoel je dit ?

C++:

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

waarom zou je in godsnaam een destructor abstract willen maken?

[.oisyn]

Om ervoor te zorgen dat derived classes 'm ook implementeren lijkt me. Waarom je dat specifiek zou willen zou ik niet weten, maar het is een goede manier om een klasse abstract te laten zijn zonder dat ie verder abstracte functies heeft (afgezien van de destructor dus)

[curry684]

.oisyn schreef op 14 januari 2004 @ 16:49:
Om ervoor te zorgen dat derived classes 'm ook implementeren lijkt me. Waarom je dat specifiek zou willen zou ik niet weten, maar het is een goede manier om een klasse abstract te laten zijn zonder dat ie verder abstracte functies heeft (afgezien van de destructor dus)

Over het algemeen maak ik voor dat doel de constructor(s) protected, iets handiger en imho nettere constructie om instantiering te voorkomen van een verder compleet geimplementeerde class.

[.oisyn]

Is ook zo idd