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

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

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

vector<double> & const values

ergibt keinen Sinn (und wird auch nicht kompilieren).

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.

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)