ich habe folgendes Problem, zu dem ich über die Suchfunktion leider nichts gefunden habe:

Ich möchte in einer Klasse Linienrichtung auf Elemente der Basisklasse Linie zugreifen. Beide Klassen werden dynamisch erstellt:

Datei Linie.h:
Hallo,

ich habe folgendes Problem, zu dem ich über die Suchfunktion leider nichts gefunden habe:

Ich möchte in einer Klasse Linienrichtung auf Elemente der Basisklasse Linie zugreifen. Beide Klassen werden dynamisch erstellt:

Datei Linie.h:

class Linie
{
public:
	const int val_liniennr;

	Linienrichtung* richtung_fw;
	Linienrichtung* richtung_bw;

	Linie(const int tmp_liniennr) 
		: val_liniennr(tmp_liniennr) {
	}
};

Datei Linienrichtung.h:

class Linienrichtung : public Linie
{
public:
	const string val_name;
	const string val_hauptziel;

	Linienrichtung(const string tmp_name, const string tmp_hauptziel) 
		: val_name(tmp_name), 
		val_hauptziel(tmp_hauptziel) {
	}
};

Ich möchte in Linienrichtung.h auf das Element "val_liniennr" der zugehörigen Basisklasse "Linie" zugreifen.

Wenn ich nun kompiliere, erscheint jedoch in Linienrichtung.h die Meldung

error C2504: 'Linie': Basisklasse undefiniert

Beide Headerdateien sind jedoch in der Hauptdatei includiert, also

#include "Linienrichtung.h"
#include "Linie.h"

Wenn ich zusätzlich noch in Linienrichtung.h

#include "Linie.h"

einfüge, werden die Elemente der Unterklasse in Linie.h nicht mehr gefunden.

Hat jemand eine Idee, wo mein Fehler liegt? Oder gibt es gar keine Möglichkeit, bei dynamischen Klassen auf die Basisklasse zuzugreifen? Würde mich jedenfalls sehr über Antwort freuen!

Vielen Dank im Voraus!

Andy

Datei Linie.h:

class Linienrichtung;

class Linie
{
public:
	const int val_liniennr;

	Linienrichtung* richtung_fw;
	Linienrichtung* richtung_bw;

	Linie(const int tmp_liniennr) 
		: val_liniennr(tmp_liniennr) {
	}
};

Datei Linienrichtung.h:

#include "linie.h"

class Linienrichtung : public Linie
{
public:
	const string val_name;
	const string val_hauptziel;

	Linienrichtung(const string tmp_name, const string tmp_hauptziel) 
		: val_name(tmp_name), 
		val_hauptziel(tmp_hauptziel) {
	}
};

Sollte es eigentlich tun...
Aber vorsicht der C'tor von Linienrichtung ruft nicht deine Ctor-Linie(const int) auf sondern den Standard-C'tor.

Sollte dann so aussehen

Linienrichtung(const string tmp_name, const string tmp_hauptziel,const int tmp_liniennr) 
		: val_name(tmp_name), 
		val_hauptziel(tmp_hauptziel) : Linie(tmp_liniennr) {
	}

Ich habe nämlich in Linie.h folgende Funktion:

void Linie::show_linie(Linie* init_linie, string init_str_variantenart)
{
	init_linie->richtung_fw->show_linienrichtung(init_linie->richtung_fw, init_str_variantenart);
	init_linie->richtung_bw->show_linienrichtung(init_linie->richtung_bw, init_str_variantenart);
}

Nun wird nicht mehr erkannt, dass "richtung_fw" ein Element der Unterklasse "Linienrichtung" ist.
Ich bekomme die Fehlermeldungen

error C2027: Verwendung des undefinierten Typs "Linienrichtung"

und

error C2227: Der linke Teil von '->show_linienrichtung' muss auf Klasse/Struktur/Union zeigen

Hast Du dafür noch eine Idee?

Vielen Dank!

Andy

linie.h

#ifndef __LINIE_
#define __LINIE_

class Linierichtung; //Forward-Deklaration

class Linie {
...
};

#endif

linienrichtung.h

#ifndef __LINIENRICHTUNG_
#define __LINIENRICHTUNG_

#include "linie.h"

class Linierichtung : public Linie {
...
};

#endif

linie.cpp

#include "linie.h"
#include "linienrichtung.h"

void Linie::show(...) { }
// blabalb der Rest auch

linienrichtung.cpp

#include "linienrichtung.h"

//blablabla

Der erste Fehler tritt in Linienrichtung.cpp auf und besagt, dass die Elemente der Klasse Linienrichtung nicht gefunden werden.

Linienrichtung.cpp:

#include "Linienrichtung.h" 

void Linienrichtung::show_linienrichtung(Linienrichtung* init_linienrichtung, string init_str_variantenart) 
{
    cout << "  " << init_linienrichtung->val_name << " -> Ri. " << init_linienrichtung->val_hauptziel << endl;
    //...
}

"val_name" und "val_hauptziel" sollen hier angeblich keine Elemente von "Linienrichtung" sein, obwohl sie ja in Linienrichtung.h definiert sind...

Ich blicke hier wirklich nicht mehr durch

Noch eine Idee?

Grüße

Andy

Hmmm, ist überhaupt show_linienrichtung(...) in der Klasse deklariert ???

Ja, ist es... Aber ich glaube, ich lasse es jetzt lieber so wie es war und speichere die Liniennummer der Basisklasse noch mal in der Unterklasse "Linienrichtung". Ist dann zwar redundant, aber das Problem scheint wohl recht kompliziert zu sein

Trotzdem danke

Andy

Ansonsten solltest du mal über dein Design nachdenken - eine Linie hat/kennt zwei Richtungen - eine Richtung ist eine Linie -... irgendwo drehst du dich da im Kreis.

Ich habe immer gedacht, dass __ (Doppel-Unterstrich) in den Includeguards böse ist. Sogar sehr böse.

Du hast recht. Es ist ein Fehler.

Ansonsten solltest du mal über dein Design nachdenken - eine Linie hat/kennt zwei Richtungen - eine Richtung ist eine Linie -... irgendwo drehst du dich da im Kreis.

Ja, das kommt mir auch so vor. Allerdings muss ich auch dazu sagen, dass dies mein erstes Projekt ist, in dem ich Klasseneigenschaften vererbe. Jedoch müsste es doch schon möglich sein, von einer Linie auf ihre beiden Fahrtrichtungen zuzugreifen und gleichzeitig auch von einer Fahrtrichtung auf ihre übergeordnete Linie?

Jedenfalls hier mein Code. "Linienvariante" ist eine Unterklasse zu "Linienrichtung", "Linienverlauf" eine Unterklasse zu "Linienvariante".

Hauptdatei (.cpp):

#include <iostream>
#include <iomanip>
#include <windows.h>
#include <sql.h>
#include <sqlext.h>
#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <fstream>
#include <sstream>
#include <time.h>

#include "consts.h"
#include "mt-rand.h"
#include "Ort.h"
#include "Strecke.h"
#include "Linienverlauf.h"
#include "Linienvariante.h"
#include "Linienrichtung.h"
#include "Linie.h"

//...

class Daten 
{
public:
	Daten();
	void main(void);
private:
	void set_verbindungsparameter(const string init_str_URI, const string init_str_user, const string init_str_passwort);
	void init(void);
	void get_orte(void);
	void get_strecken(void);
	void get_strecken_hp(void);
	void get_streckenfahrzeiten(void);
	void get_linien(void);
	Linienrichtung* get_linienrichtung(Linie* tmp_linie, string tmp_richtung);
	vector<Linienvariante*> get_linienvarianten(Linienrichtung* init_linienrichtung, string init_richtung);
	void get_linientakte(Linienvariante* init_linienvariante);
	Linienverlauf* get_linienverlauf(Linienvariante* init_linienvariante);

	void add_strecke_hp(const Strecke* strecke1, const Strecke* strecke2, const Strecke* strecke3);
	string ersetze_umlaut(string name, string umlaut);

	void show_orte(void);
	void show_strecken(vector<Strecke*>);
	void show_linien_alle(void);
	void show_linien_aktiv(void);
	void show_error(ostringstream &oss, int prio);

	SQLRETURN lese_daten(string str_sql);

	//Verbindungsdaten für ODBC-Datenbank
	string str_URI;
	string str_user;
	string str_passwort;

	//ODBC-Verbidungshandles
	SQLHANDLE hEnvironment;
	SQLHANDLE hConnection;
	SQLHANDLE hStatement;

	Netzwerk MyNetzwerk;
	vector<Linienverlauf*> vec_linienverlaeufe;

	string str_pfad_errorlog;
	int anz_datenfehler;
};

//...

void Daten::get_linien(void)
{
	//...

	//hier wird eine Linie erstellt
	for (unsigned int i=0; i<anz_datensaetze; i++) {
		Linie* akt_linie = new Linie(arr_linien[i].iLINIE_NR);
		MyNetzwerk.vec_linien.push_back(akt_linie);
	}
}

Linie.h

#ifndef _LINIE
	#define _LINIE

using namespace std;

class Linienrichtung;

class Linie
{
public:
	const int val_liniennr;
	int anz_varianten_aktiv;

	Linienrichtung* richtung_fw;
	Linienrichtung* richtung_bw;
	void show_linie(Linie* init_linie, string init_str_variantenart);

	Linie(const int tmp_liniennr) 
		: val_liniennr(tmp_liniennr) {
			anz_varianten_aktiv = 0;
	}
};

#endif

Linie.cpp:

#include "Linie.h"
#include "Linienrichtung.h" 

void Linie::show_linie(Linie* init_linie, string init_str_variantenart)
{
	cout << "Linie " << setw(2) << init_linie->val_liniennr << ": " << endl;
	cout << "  " << init_linie->anz_varianten_aktiv << " aktive Varianten" << endl;
	init_linie->richtung_fw->show_linienrichtung(init_linie->richtung_fw, init_str_variantenart);
	init_linie->richtung_bw->show_linienrichtung(init_linie->richtung_bw, init_str_variantenart);
}

Linienrichtung.h:

#ifndef _LINIENRICHTUNG
	#define _LINIENRICHTUNG

#include "Linie.h"

using namespace std;

class Linienrichtung : public Linie
{
public:
	const string val_name;
	const string val_hauptziel;
	int anz_varianten;
	int anz_varianten_aktiv;
	vector<Linienvariante*> vec_linienvarianten;
	void show_linienrichtung(Linienrichtung* init_linienrichtung, string init_str_variantenart);

	Linienrichtung(const string tmp_name, const string tmp_hauptziel) 
		: val_name(tmp_name), 
		val_hauptziel(tmp_hauptziel) {
			anz_varianten = 0;
			anz_varianten_aktiv = 0;
	}

	Linienrichtung(const string tmp_name, const string tmp_hauptziel, const int tmp_liniennr)
		: val_name(tmp_name), 
		val_hauptziel(tmp_hauptziel) : Linie(tmp_liniennr) {
			anz_varianten = 0;
			anz_varianten_aktiv = 0;
	}
};

#endif

Linienrichtung.cpp:

#include "Linienrichtung.h" 

void Linienrichtung::show_linienrichtung(Linienrichtung* init_linienrichtung, string init_str_variantenart) 
{
    cout << "  " << init_linienrichtung->val_name << " -> Ri. " << init_linienrichtung->val_hauptziel << endl;
	cout << "    " << init_linienrichtung->anz_varianten_aktiv << " aktive " << init_linienrichtung->val_name << "-Varianten" << endl;
	for (int i=0; i<init_linienrichtung->vec_linienvarianten.size(); i++) {
            //...
	}
}

Grüße

Andy