Ich habe ein paar Klassen, die in Wirklichkeit weit umfangreicher sind. Bei der Vererbung und dem Konstruktor der Abgeleiteten Klasse bekomme ich Probleme.

Mein Test Programm sieht wie folgt aus:

ClassPreDefintion.h

#define CLASS_PRE_DEFINITION_H

class CDomain {
    protected:
	char* Name;

    public:
	CDomain();
};

class CBoundary {
    protected:
	char* Name;
	CDomain* D;

    public:
	CBoundary(CDomain* pD);
};

class CInlet : CBoundary {
    private:
	double NormalVelocity;

    public:
	CInlet(CDomain* pD) : CBoundary(pD); /*Fehlermeldung: Expected a"{"*/
};

Functions.h

#define CLASS_FUNCTIONS_H

CDomain::CDomain() {
	Name = nullptr;
}

CBoundary::CBoundary(CDomain* pD) {
	this->D = pD;
	Name = nullptr;
}

CInlet::CInlet(CDomain* pD) {

}

main.cpp

#ifndef CLASS_PRE_DEFINITION_H
	#include "ClassPreDefinition.h"
#endif

#ifndef CLASS_FUNCTIONS_H
	#include "Functions.h"
#endif

int main() {
	return 0;
}

Ich möchte die Klassen gerne vordefinieren und den jeweiligen Konstruktor in einem separaten Headerfile beschreiben. Bei normalen Funktionen und bei Konstruktoren von einfachen Klassen ist das kein Problem. Das geht doch sicher auch bei abgeleiteten Klassen, oder?

Vielen Dank im Voraus.

ClassPreDefintion.h
ClassPreDefintion.cpp
main.cpp

Dann gehört die Initialisierungsliste (CInlet) nicht zur Deklaration, sondern zur Definition, also in diesem Fall in die cpp-Datei.

Und die Geschichte mit den Include-Guards solltest Du Dir auch ganz dringend noch mal ansehen, die gehören ins Headerfile ...

ClassPreDefinition.h

#define CLASS_PRE_DEFINITION_H

class CDomain {
private:
	char* Name;

public:
	CDomain();
};

class CBoundary {
protected:
	char* Name;
	CDomain* D;

public:
	CBoundary(CDomain* pD);
};

class CInlet : public CBoundary {
private:
	double NormalVelocity;

public:
	CInlet(CDomain* pD);
};

Function.h

#define CLASS_FUNCTIONS_H

CDomain::CDomain() {
	Name = nullptr;
}

CBoundary::CBoundary(CDomain* pD) {
	this->D = pD;
	Name = nullptr;
	printf("CBoundary constructor!\n");
}

CInlet::CInlet(CDomain* pD) : CBoundary(pD){
	this->D = pD;
	printf("CInlet constructor!\n");
}

main.cpp

#ifndef STDIO_H
	#define STDIO_H
	#include <stdio.h>
#endif

#ifndef CLASS_PRE_DEFINITION_H
	#include "ClassPreDefinition.h"
#endif

#ifndef CLASS_FUNCTIONS_H
	#include "Functions.h"
#endif

int main() {
	CDomain* D = new CDomain();
	CBoundary* B = new CBoundary(D);
	CInlet* In = new CInlet(D);

	getchar();
	return 0;
}

Results wie erwartet:
*
CBoundary constructor!
CBoundary constructor!
CInlet constructor!
*

Mich würde aber trotzdem mal interessieren, was an diesem Ansatz falsch ist - also, die Einwendung von Belli.

Ich dachte, ein Headerfile wird einfach in das main.cpp kopiert.
Wie binde ich dann das zweite cpp File mit ein?

Ein Headerfile wird dahin kopiert (via #include), wo man es benötigt.
Und cpp-Files werden kompiliert und danach zusammengelinkt.
Wie das konkret gemacht wird, hängt davon ab, wie Du Deine Programme baust: Durch Kommandozeilenbefehle oder mittels einer IDE ...
In der Kommandozeile zB.

cl /EHsc main.cpp ClassPreDefintion.cpp (wenn Du Visual Studio benutzt) oder
g++ main.cpp ClassPreDefintion.cpp (Wenn Du g++ benutzt)

Und wie gesagt: Include-Guards gehören nicht in ein cpp-File.