Folgendes Problem, um die Software für eine Studienorganisation zu realisieren muss ein CHochschul-Objekt erzeugt werden, um dann ein CStudienorganisator-Objekt zu erzeugen. Um das zu kontrollieren hatte ich eigentlich vor ein CHochschul-Objekt an den Konstruktor von CStudienorganisator zu übergeben. Der Sinn : keine Hochschule -> kein Studienorganisator. Schaut Euch bitte mal folgenden Quelltext an und sagt mir Eure Meinung. Gehts auch anders ???

(Fehlermeldung vom Compiler ganz unten)

***********
// Main.cpp
***********

#include "CHochschule.h"

#include <stdlib.h>

int main ( )
{
	// create a new CHochschule object
	cout << "Eine neue Hochschule wurde eingeweiht!" << endl;
	CHochschule* Hochschule;
	Hochschule = new CHochschule( "HTWK" );

	// get the name of the object
	Hochschule->getName();

	// create a new CStudienorganisator object
	CStudienorganisator* Studienorganisator;
	Studienorganisator = new CStudienorganisator( "Frau Mueller", Hochschule );

	// get the name of the object
	Studienorganisator->getName();

	system("PAUSE");
	return 0;
}

______________________________________________________________________________

******************
// CHochschule.cpp
******************

#include <iostream.h>
#include "CStudienorganisator.cpp"

class CHochschule
{
	class CStudienorganisator;

public:
	CHochschule(					// standard constructor
		char*			cName		// name of the object
		);
	~CHochschule(					// standard destructor
		);

	void getName(					// return the name of the object
		);

protected:
	char*				m_cName;	// name of the object

};

______________________________________________________________________________

************************
// CStudienorganisator.h
************************
class CStudienorganisator
{

class CHochschule;

public:
	CStudienorganisator(					// standard constructor
		char*				cName,			// name of the object
		CHochschule*		pCHochschule	// pointer on a CHochschule object
		);
	~CStudienorganisator(					// standard destructor
		);

	void getName(							// print the name of the object
		);

protected:
	char*				m_cName;			// name of the object
	CHochschule*		m_pCHochschule;		// pointer on a CHochschule object

};

______________________________________________________________________________

**************************
// CStudienorganisator.cpp
**************************

#include "CStudienorganisator.h"

#include <stdlib.h>

// *****************************
// *** class implementations ***
// *****************************

//
// constructor
//
CStudienorganisator::CStudienorganisator( char* cName, CHochschule *pCHochschule )
	: m_cName( cName )
	, m_pCHochschule( pCHochschule )
{
}

//
// standard destructor
//
CStudienorganisator::~CStudienorganisator()
{
}

//
// getName()
//	return the name of the object
//
void CStudienorganisator::getName()
{
	cout << "Der Name des Studienorganisators ist : " << m_cName << endl;
}

/*
c:\HOCHSCHULE\Main.cpp(19): error C2664: 'CStudienorganisator::CStudienorganisator(char *,CStudienorganisator::CHochschule *)' : cannot convert parameter 2 from 'CHochschule' to 'CStudienorganisator::CHochschule *'
*/

Ja, wo faengt man an ...

Aehm, du verhaust hier irgendwas mit header und cpp dateien !

#include "CStudienorganisator.cpp"

Sieht aeusserst unschoen aus, und faellt sofort auf !

Includen tut man meistens die deklarationen, also die .h dateien, keine cpp dateien ... Ausserdem ist das arbeiten mit forward-Deklarationen hier voellig falsch.

class CHochschule
{
class CStudienorganisator;

Deshalb auch die fehlermeldung, du deklarierst 2 mal die Hochschule, einmal als funktionsfaehige klasse, und als Membertyp deiner CStudienorganisator-Klasse. Dass passt dann ned ...

2. du schreibst klassen, also C++
als strings nimm lieber STL Strings und keine C Strings
Apropo

new CHochschule( "HTWK" );

wuerde auch ned funktionieren, weil der Parameter vom Construktor *char ist, aber "HTWK" ne Constante Zeichenkette, wird er dir anmeckern !

3. Kommentare in der Parameterliste und die zeilenumbrueche machen die ganze sache irgendwie unleserlich ... ist geschmacksache, aber mich verwirrts

Studienorganisator->getName();

Ich nehm an die methode macht irgendwas schweiniges auf der Standardausgabe oder so kann man machen, ist aber eher irgendwie unflexibel, gib der methode wenigstens nen parameter mit, wo sie das Zeugs hinschreiben soll ... oder noch viel besser, lass die Klassen einfach nur ihren Namen zruueckgeben, und kuemmer dich ums ausgeben an anderen Stellen ... sonst kommst bei spaeteren Erweiterungen schnell in Huddelein ... Ned so viele Themen in eine Klasse packen !

deine Hochschulklasse sollte dan in etwa so aussehen :

****************** 
// Hochschule.h 
****************** 
#include <string>

class CHochschule 
{ 
public: 
    // CTor gleich mit namen ! 
    CHochschule(const std::string astrName); 
    // DTor 
    virtual ~CHochschule(); // Destruktor virtual ... falls du mal von der Klasse ableiten willst 
    // Namen zurueckliefern 
    const std::string&  getName() const;  // Memberfunktion constant machen, damit sie auch auf constanten Instanzen funzt 
    // und als rueckgabewert ne constante referenz auf nen std::string vermeidet kopiererei,
protected: 
    // Members
    // name of the object ... und warum nicht gleich constant, aendert sich ja auch nie
    const std::string  m_strName;  

};

und die Zugehoerige Implementation

****************** 
// Hochschule.cpp 
****************** 
// den CTor
CHochschule::CHochschule(const std::string astrName):
m_strName(astrName) // da die membervariable constant ist, zuweisung ueber init-Liste
{
}
// der DTor
CHochschule::~CHochschule()
{
    // der Dtor brauch gar nix machen, weil der String aus der STL clever ist und sich selber loescht ... 
}
// den namen zurueckgeben 
const std::string&  CHochschule::getName() const
{
    return m_strName; // einfach als refernz den member zurueckgeben ... darf sowieso keiner veraendern 
}

Deine Studienorganisatorklasse, solltest nu selber entwerfen koennen

noch nen Tipp !

Der Sinn : keine Hochschule -> kein Studienorganisator.

CStudienorganisator( // standard constructor 
char* cName, // name of the object 
CHochschule* pCHochschule // pointer on a CHochschule object 
);

wenn nen Zeiger als parameter uebergibst, kann der Zeiger auch Null sein ... das widerspricht deiner Logic ...
Bessser ! Speicher dir kein Zeiger auf die Hochschule, sondern Halte Ne referenz !

Sprich, membervariable vom Typ:
const CHochschule & m_Hochschule;
und dem Konstruktor auch ne referenz ... oder noch besser, mach beides als constante refernz, wenn der Studienorganisator ned auf der Hochschule rumschreiben tut ... (da die mebervariable protected machen willst, nehm ich an du willst ableiten ... und da hat der parent zugriff auf die Variable ... also schuetze sie vor missbrauch)

CStudienorganisator::CStudienorganisator(const std::string astrName,const CHochschule & a_hochschule):
m_Hochschule(a_hochschule),
m_strName(astrName)
{
}

Waer nen brauchbarer Construktor ...

Noch nen Letzter Tipp
das C vor Klassennamen ist Geschmackssache, meiner meinung nach schlechter Geschmack Errinert zu sehr an ne Klassenbiblo von M$, weswegen der Post auch sicher hier gelandet ist ...
Nimm lieber nen Namespace, wenn deine Klassen Kennzeichnen Willst ...

Ciao ...