Parameter und Rückgabewerte

PACoSys

Hallo zusammen,

folgende Sache angenommen ich habe mir eine enum definiert, und in irgendeiner Funktion wird eine andere Funktion aufgerufen, die als Parameter eine Ausprägung des enums erwartet.

enum FileType
{
	UNKNOWN = -1,
	TXT,
	DOC
}

void irgendeineFkt()
{
	FileType fileType = TXT;
	eineAndereFkt(fileType);
}

// Variante 1
void eineAndereFkt(const FileType & fileType){}

// Variante 2
void eineAndereFkt(const FileType fileType){}

// Variante 3
void eineAndereFkt(FileType fileType){}

Welche Variante wäre zu empfehlen (Variante 1)?

Und eine zweite Sache angenommen ich hätte eine Funktion f1, welche eine Funktion f2 oder f3 aufruft, f2 und f3 rufen wiederum f4 auf. Als Rückgabe erwartet f1 einen vector z.B. mit double Werten. Wie sollten dann die Funktionen gestaltet werden (zwecks Performance, Konformität, etc)? Sollte der vector als Parameter mit Adressoperator übergeben werden oder sollten die Funktionen einen vector zurückgeben? Z.B. so:

void f1()
{
	vector<double> values;

	if (bedingung)
	{
		values = f2();
	}
	else
	{
		values = f3();

	}
	//machIrgendwasMitValues();
}

vector<double> f2()
{
	//machWas();
	return f4();
}

vector<double> f3()
{
	//machWasAnderes();
	return f4();
}

vector<double> f4()
{
	vector<double> values;
	//befuelleVector();
	return values;
}

Danke schon mal für Eure Hilfe.

Gruß
Patrick

David_pb

1. Variante 3
2. Du könntest den vector per Referenz als Parameter an die Funktionen geben, dann würdest du dir das Kopieren sparen.

PACoSys

David_pb schrieb:

1. Variante 3

Und warum?

David_pb schrieb:

2. Du könntest den vector per Referenz als Parameter an die Funktionen geben, dann würdest du dir das Kopieren sparen.

Also

void f2(vector<double> & values){}

Gruß
Patrick

David_pb

1. Weil es hier kein Sinn macht konstante Referenzen zu übergeben. Enums werden wie ints behandelt.
2. Genau

PACoSys

Kann ich bei 2. noch irgendwas const definieren (Habe mal irgendwo gelesen man soll so viel wie möglich const definieren.)?

Wenn ich es so definiere:

void f2(const vector<double> & values){}

Dann ist ja der vector const oder nicht. Und wenn ich es so definiere:

void f2(vector<double> const & values){}

Dann ist doch nur die Referenz auf den vector const und der vector veränderbar oder nicht?

Gruß
Patrick

Th

Nein, deine beiden Zeilen sind inhaltlich identisch.
Bei Zeigern kann man 2mal const angeben, bei Referenzen nur 1 mal, denn

vector<double> & const values

ergibt keinen Sinn (und wird auch nicht kompilieren).

David_pb

PACoSys schrieb:

Kann ich bei 2. noch irgendwas const definieren (Habe mal irgendwo gelesen man soll so viel wie möglich const definieren.)?

So viel wie möglich. Aber z.T. machts einfach keinen Sinn und verwirrt nur.

netrobot

enum FileType
{
UNKNOWN = -1,
TXT,
DOC
}

void irgendeineFkt()
{
FileType fileType = TXT;
eineAndereFkt(fileType);
}

// Variante 1
void eineAndereFkt(const FileType & fileType){}

// Variante 2
void eineAndereFkt(const FileType fileType){}

// Variante 3
void eineAndereFkt(FileType fileType){}

V1. du hast intern die object values abfragen, ohne etwas zu ändern und es spart copy ctor.(macht keinen Sinn hier, weil FileType ist nicht anders als int)
V2. vergiss es.
V3. besser, aber hier call by value, keine Änderung in orig. fileType möglich.
V4.

void eineAndereFkt(FileType& fileType){}

Änderung auf orig. fileType möglich

Frage 2.
keyword: wer soll platz allokieren.

sollten die Funktionen einen vector zurückgeben

entspricht, vector internal erzeugt, und nach aussen gefürht.(macht machmal problem und auch unlogisch)