struct KNOTEN {
unsigned rang;
unsigned vorgaenger;
};

struct KANTE {
/hier schreibt er mir folgenden Fehler:
KANTE&KANTE::operator=(const KANTE)/

unsigned index;
unsigned anfangsknoten;
unsigned endknoten;
int gewicht;
};

Kann mir jemand sagen, was das bedeutet?
Und nochetwas Kleines: MUSS man Konstruktor und Destruktor in eine Klasse implementieren?
Danke im voraus,
Gruß Oliver.

Erstmal benutze doch bitte die cpp-Tags, um Code darzustellen. (unter den Smylies).

Also das ist nicht wirklich ein Fehler. Kannst du bitte die genaue Fehlermeldung + Compiler, den du benutzt posten?
Einen Fehler sehe ich da nämlich nicht und unter MSVC++ 08 Express wird das ganze kompiliert ohne einen Fehler oder Warnung. (Das ausgeklammerte habe ich so gelassen).

Wenn das nicht der richtige Code ist,der den Fehler erzeugt, dann bitte den Vollständigen, da es sonst nicht viel bringt zu raten.

Und nochetwas Kleines: MUSS man Konstruktor und Destruktor in eine Klasse implementieren?

Nein. Aber deklarieren muss man ihn dort. Dann kannst du ihn in der .cpp definieren.

btw:
Klassennamen in Grossbuchstaben zu schreiben ist eher unüblich und imo auch nicht schön/lesbar. (Normalerweise sind Makros alles in Grossbuchstaben).

Und nochetwas Kleines: MUSS man Konstruktor und Destruktor in eine Klasse implementieren?

Nein. Aber deklarieren muss man ihn dort. Dann kannst du ihn in der .cpp definieren.

Das stimmt so nicht. Man muss einen Konstruktor weder deklarieren noch definieren. Wenn man es nicht tut, dann macht das der Compiler für einen. Das gleiche gilt für den Destruktor, den Copy-Konstruktor und den Zuweisungsoperator.
In vielen Fällen tun diese Standardfunktionen aber nicht das, was der Programmierer will.

drakon schrieb:

Und nochetwas Kleines: MUSS man Konstruktor und Destruktor in eine Klasse implementieren?

Nein. Aber deklarieren muss man ihn dort. Dann kannst du ihn in der .cpp definieren.

Das stimmt so nicht. Man muss einen Konstruktor weder deklarieren noch definieren. Wenn man es nicht tut, dann macht das der Compiler für einen. Das gleiche gilt für den Destruktor, den Copy-Konstruktor und den Zuweisungsoperator.

Ja, sorry, ich habe die Frage falsch betont gelesen. Ich habe es so verstanden, WENN man einen implementiert und nicht allgemein.

In vielen Fällen tun diese Standardfunktionen aber nicht das, was der Programmierer will.

Da kann ich leider aber nicht ganz zustimmen. Also besonders beim "vielen". Ich schreibe mir eine Klasse, die das gefährliche für mich übernimmt und habe dann einfach diese Klasse bei der "richtigen" Benutztung. Also kann ich mich oft auf die Compiler generierten Funktionen verlassen.

Da kann ich leider aber nicht ganz zustimmen. Also besonders beim "vielen". Ich schreibe mir eine Klasse, die das gefährliche für mich übernimmt und habe dann einfach diese Klasse bei der "richtigen" Benutztung. Also kann ich mich oft auf die Compiler generierten Funktionen verlassen.

RAII-Klassen muss man erstmal schreiben, und selbst wenn Du in der "richtigen" Klasse die RAII-Klasse benutzt, sind das trotzdem viele Fälle. Das gleiche gilt für Container. Man hat vielleicht nicht so oft Berührung damit, aber es sind trotzdem sehr viele Fälle, wo das ganze im Hintergrund werkelt. Darauf bezog ich mich.

void sortieren(vector<KANTE> &K) {
std::sort(K.begin(), K.end(), kantenvgl /*hab ich vorher definiert*/);
}; //Def. von sortieren

std::vector<KANTE> temp; //... fülle vektor, danach :
vector<KANTE> &auftemp=temp
sortieren(auftemp);
weiterefunktion(auftemp);

Das klappt nicht. Könnt ihr mir helfen?
Gruß Oliver.

P.S. wofür sind die cpp tags denn gut? Ich brauch doch keine deltas und epsilons .

P.S. wofür sind die cpp tags denn gut? Ich brauch doch keine deltas und epsilons .

Der Code wird durch die Tags mit Syntaxhighlighting usw. dargestellt und ist somit viel lesbarer. Schau einfach mal in die anderen threads im Forum, dort wirst du das fast überall sehen.

Hier ein Beispiel, dass wunderbar funktioniert:

void sort ( std::vector<int>& v )
{
	std::sort ( v.begin (), v.end () );
}

void out ( const std::vector<int> & v )
{
	for ( std::vector<int>::size_type i = 0 ; i < v.size () ; i++ )
	{
		std::cout << v[i] << "\n";
	}
}	

int main ()
{	
	std::vector<int> vec;
	vec.push_back ( 5 );
	vec.push_back ( 8 );
	vec.push_back ( 1 );

	std::cout << "vorher: " << std::endl;
	out ( vec );

	sort ( vec );
	std::cout << "nachher: " << std::endl;
	out ( vec );
}

So sähe das Ganze mit C++-Tags aus. Jetzt noch richtig einrücken, und dann ist es schon fast perfekt...

Wie schon gesagt: Was geht denn nicht? Liegt der Fehler in sortieren() ? Das Vergleichsprädikat funktioniert? Und weshalb erstellst du eine lokale Referenz auftemp und übergibst die, anstatt gleich temp zu übergeben?