Irgendwie versuche ich 2 Header aufeinander zu verlinken und das funktioniert aber nicht. Was mache ich nur falsch?

error C4430: missing type specifier - int assumed. Note: C++ does not support default-int

#include <iostream>
#include "List2.h"
#include "Koordinate.h"
#include "Kante.h"

using namespace std;

class Knoten
{
public:
	Knoten (double x, double y) : k(x,y) { };
	Knoten (Koordinate k) : k(k) { };

	double entfernung(const Knoten& kn) const { 
		return k.entfernung(
			kn.get_koordinate()); };

	Koordinate get_koordinate() const { return k; };

	//void setze_kante(Knoten kn);
	//void loesche_kante(Knoten kn);

	friend ostream& operator<<(ostream& o, const Knoten& kn);
	bool operator==(const Knoten& kn) {	return (k==kn.k); };
	bool operator!=(const Knoten& kn) {	return (k!=kn.k); };

private:
	Koordinate k;
	List2<Kante> kanten;
};

#include <iostream>
#include "Knoten.h"

using namespace std;

class Kante
{
public:
	Kante (const Knoten& k_1, const Knoten& k_2);  // HIER IST DER FEHLER!
	~Kante();

	Knoten get_von() const { return *k_1; };
	Knoten get_nach() const { return *k_2; };
	double get_entfernng() const { return entfernung; };

	friend bool operator==(Kante ka_1, Kante ka_2);

private:
	Knoten *k_1, *k_2;
	double entfernung;
};

Deine Klassen brauchen nicht die vollstanedige Definition, sondern nur die reservierung des Namens langt -> Forward Deklaration.
Merke: fuer Zeiger, Referenzen und Rueckgabewerte langen Forwards !

Um eine Kante anzulegen, brauchst du nicht die definition des Knotens.
Deshalb, Knoten.h aus Kante.h raus, und nen Forward dafuer rein.
Der include des Knotens muss dann in die Impl der Kante (Kante.cpp)

Anmerkung:
using namespace std; im Header ist die EIntrittskarte zur Programmierhölle !!!

/// #include <iostream> /// warum brauchst du den ? Verwendest doch gar nix von 

/// using namespace std; /// Fail ! erst recht wenn mans gar nicht braucht ^^

class Knoten; // Forward 

class Kante
{
public:
    Kante (const Knoten& k_1, const Knoten& k_2);  // Sollte jetzt funktionieren
    ~Kante();

    Knoten get_von() const { return *k_1; };
    Knoten get_nach() const { return *k_2; };
    double get_entfernng() const { return entfernung; };

    friend bool operator==(Kante ka_1, Kante ka_2);

private:
    Knoten *k_1, *k_2;
    double entfernung;
};

Generell solltest Du vorsichtiger mit Abhaengigkeiten umgehen, und dir nicht so Zeugs reinziehen wo es nicht brauchst.
Forwards Nutzen wo es geht !
Deine Klassen werden Stabiler, und weniger ABhaengig (Black Box Prizip) und du kannst Implementierungs-Details besser verstecken.
Wenn diese Design Vorteile nicht genug sind, wirst zusaetzlich noch nen Geschwindigkeitsvorteil beim partitiellen neucompilieren feststellen ...

Les Dich mal zum Thema PIMPL (Pointer of Implementation)Idom / Compiler Firewall Idom ein !!!!

#include <iostream> -> checken ob nicht <iosfwd> langt !

List2<Kante> kanten; laesst sich definitiv gut "Pimpln"
const std::auto_ptr<List2<Kante> > mptrKanten; /// in der initliste nicht vergessen die liste real zu erzeugen

statt dem auto_ptr besser nen scoped pointer aus dem neuen Standard nehmen, oder aus der boost, wenn möglich.

Ciao ...

error C2027: use of undefined type 'Knoten'

Was mache ich jetzt? Soll ich nur Zeiger zurückgeben? Geht es nicht auf die untere Weise?

RHBaum schrieb:

class Knoten; // Forward 

class Kante
{
public:
    Kante (const Knoten& k_1, const Knoten& k_2);  // Sollte jetzt funktionieren
    ~Kante();
   
    Knoten get_von() const { return *k_1; };   // HIER IST DER FEHLER
    Knoten get_nach() const { return *k_2; };
    double get_entfernng() const { return entfernung; };

    friend bool operator==(Kante ka_1, Kante ka_2);

private:
    Knoten *k_1, *k_2;
    double entfernung;
};

Soll ich nur Zeiger zurückgeben? Geht es nicht auf die untere Weise?

Problem ist eher dass Du die funktion im header implementierst.
Warum implementeirst du die methoden im Header, den CTor aber ned ^^ du brauchst dann eh ne cpp.
Die Impl der Methoden gehoert definitiv in die cpp !!! (auch wenns mehr schreibarbeit ist)

Noch was:
Brauchst du die copy wirklich ?
Knoten ist definitiv auf nen CCTor angewiesen das es funktioniert.
den getter eine Kopie zurueckgeben lassen macht nur sinn, wenn die Kopie erzwingen woelltest bzw. das halten einer referenz verhindern trachtest.

Hasst du keinen Grund dazu ist die bessere signatur der Methode:
const Knoten & get_von() const;
Damit wirst auch "performant" wenn der Compiler keine return value optimization unterstützt ...

Was noch auffaellt:
Kante (const Knoten& k_1, const Knoten& k_2);
keinen StdCTor, die Angabe der Knoten k1 und k2 wird erzwungen.
Knoten *k_1, *k_2; k_1 und k_2 koennen deshalb durch die logic nie NULL sein ...
Zeiger die nie NULL werden koennen sind schlecht ^^ dafuer gibts Referenzen !

class Knoten; // Forward

class Kante
{
public:
    Kante (const Knoten& k_1, const Knoten& k_2); 
    ~Kante();

    const Knoten & get_von() const;
    const Knoten & get_nach() const;
    double get_entfernng() const;

    /// zum vergleichen sollten constante Objecte reichen,
    /// und damit auch referenzen
    friend bool operator==(const Kante & ka_1,const Kante & ka_2);

private:
    Knoten & k_1; /// koennen die Refs hier auch konstant sein ??? Kann Kante Knoten Manipulieren ???
    Knoten & k_2;
    double entfernung;
};

Ciao ...

RHBaum schrieb:

Noch was:
Brauchst du die copy wirklich ?
Knoten ist definitiv auf nen CCTor angewiesen das es funktioniert.
den getter eine Kopie zurueckgeben lassen macht nur sinn, wenn die Kopie erzwingen woelltest bzw. das halten einer referenz verhindern trachtest.

Was ist ein CCTor? Nie gehört...

RHBaum schrieb:

Hasst du keinen Grund dazu ist die bessere signatur der Methode:
const Knoten & get_von() const;
Damit wirst auch "performant" wenn der Compiler keine return value optimization unterstützt ...

Ach so macht man Getter!

Dank Dir!

Was ist ein CCTor?

CTor - Constructor (allgemein)
StdCtor/SCTor - Standard Constructor
CCTor - Copy Constructor
DTor - Destructor

Ich liebe Abkürzungen ^^

Ciao ...