Dateien per include einbinden

MrMilk

Hallo,

ich habe drei Klassen: A,B und C. B und C sind jeweils von A abgeleitet. In A möchte ich nun einen Operator der ein Parameter vom Typ B entgegen nimmt.

Da die Klasse B weder in der A.cpp oder A.h eingebunden ist, habe ich in die A.h ganz oben ein #include "B.h" hingesetzt.

Leider gibt es nun für alles möglichen Mist Compilerfehler wo es sonst keinen Fehler gab.

Gibt es vielleicht eine goldene Regel wie etwas einzubinden ist?

Viele grüße
MM

Neo Gandar

Hast du in deinen Header Dateien Include Guards?

#ifndef KLASSEA_H
#define KLASSEA_H

//...Code

#endif

MrMilk

habe ich

Neo Gandar

Glaube das ging mit Forward Declaration.

Also in deiner A.h schreibst du vor deiner Klasse die Deklaration für die Klasse B. Jedoch ohne die Header Datei von B zu includieren.

class B;

class A{

//...

};

varginator

Hallo,

dann musst du die Klasse B im A-Header schon mal angeben (Forward Deklaration):

#ifndef KLASSEA_H
#define KLASSEA_H

#include "B.h"

class B;

class A {
...
A operator=(B &b);
...
}

#endif //KLASSEA_H

Gruß Simon

MrMilk

Hey,

vielen Dank für die Tipps.

Beim mir sind A und B auch noch Klassentemplates, muss ich die Templates dann auch davor setzten? Und was ist mit der Vererbung, wird einfach nur

class B;

geschrieben oder

class B:public A;

Viele Grüße
MM

pumuckl

Nein, eine Deklaration besteht nur aus dem Schlüsselwort class (oder struct, ist in dem Fall egal) sowie dem Namen. Vererbung gehört bereits zur Definition. Poste doch mal die wesentlichen Grundgerüste der Klassen.

MrMilk

Tata

template
<
    int i,
    int j,
    class c

>
class A
{
    //...
}

template
<
    int i,
    class c

>
class B: public A<i,i,c>
{
    //...
}

Viele Grüße
MM

LordJaxom

In diesem Fall musst Du vor der Definition von B die A.h includen, da bei der Ableitung die Klasse bzw. das Template bekannt sein muss. Vor der Definition von A, welche den Operator deklariert (nicht _definiert_!), musst Du B bekanntmachen:

template< int i, class c > class B;

Bevor Du den Operator nun definieren kannst, musst Du B.h includen. Das muss alles unterhalb der Klasse A passieren.

// B.h
#include "A.h"

template< int i, class c >
class B : public A< i, i, c >
{
};

// A.h

template< int i, class c > class B;

template< int i, int j, class c >
class A
{
    A operator+( B< ??? > const& b );
};

#include "B.h"

template< int i, int j, class c >
A< i, j, c > A< i, j, c >::operator+( B< ??? > const& b )
{
}

Natürlich MIT Includeguards, das ganze.

camper

LordJaxom schrieb:

In diesem Fall musst Du vor der Definition von B die A.h includen, da bei der Ableitung die Klasse bzw. das Template bekannt sein muss.

Nicht wenn A<i,i,c>wie hier eine abhängige Basis íst. Eine Vorwärtsdekläaration für A genügt dann zunächst.

LordJaxom

Gut zu wissen, wieder was gelernt

Sebastian Pizer

Gibt es vielleicht eine goldene Regel wie etwas einzubinden ist?

Ich denke, man kann Dir viel besser helfen, wenn Du sagst, was Du für ein Problem lösen willst und nicht wie. Dein wie-Ansatz kann man wahrscheinlich durch etwas eleganteres ersetzen.

Gruß,
SP