die beiden folgenden Funktionen machen offenbar das selbe:

void seti(int* i)
{
	*i = 3;
}

void setj(int& j)
{
	j = 3;
}

int main()
{
 	int i = 1;
	int j = 1;	

    seti(&i);
	setj(j);

    // i = 3
    // j = 3

	return 0;
}

Variante 1 gefällt mir deutlich besser, denn da sieht man schon beim Implementieren, dass Parameter i sehr wahrscheinlich von der Funktion geändert wird.
Sind beide Funktionen wirklich äquivalent oder übersehe ich etwas?

Peter

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

funk A:

beim aufruf dieser funktion wird ein zeiger von i kopiert und über den in der funtion darauf zugegriffen...

funk B:

beim aufruf der funktion wird direkt die adresse von j durchgeschleust und verwendet.....

hoffe habe das einigermassen richtig und gut erklären können:)

Variante 1 gefällt mir deutlich besser, denn da sieht man schon beim Implementieren, dass Parameter i sehr wahrscheinlich von der Funktion geändert wird.

wenn du eine nicht-konstante referenz übergibst, läutet auch immer der alarm "achtung, die variable wird geändert". und spätestens bei konstrukten wie

void foo (int *& x);

bist du froh, dass du nicht mit zeigern-auf-zeiger arbeiten musst

referenzen sind hipper.

hoffe habe das einigermassen richtig und gut erklären können:)

Nein, leider nicht.

void seti(int* i) 
{ 
   if(i != 0)
    *i = 3; 
}

Hallo,

die beiden folgenden Funktionen machen offenbar das selbe:

void seti(int* i)
{
	*i = 3;
}

void setj(int& j)
{
	j = 3;
}

Variante 1 gefällt mir deutlich besser, denn da sieht man schon beim Implementieren, dass Parameter i sehr wahrscheinlich von der Funktion geändert wird.
Sind beide Funktionen wirklich äquivalent oder übersehe ich etwas?

Peter

Die Funktionen sind äquivalent, es werden in beiden Fällen Adressen kopiert. Aber darum geht es bei den Referenzen nicht.
Referenzen sind Zeiger, die Dir garantieren (sogut es geht - man kann es auch vermurksen), dass sie auf ein existierendes Objekt zeigen. Du verwendest eine Referenz wie einen lokales Objekt auf dem Stack, bei einem Zeiger ist die Chance, dass der Zeiger ungültig ist, definitiv gegeben.

Die Referenz ist also IMMER zu bevorzugen, der Zeiger nur da, wenn ein nicht gültiger Zeiger akzeptabel ist (z.B. NULL).

Ob ein Parameter geändert wird, solltest Du nicht von Zeiger oder Refernz abhängig machen. Das Schlüsselwort heißt "const". Ein const Argument darf nicht verändert werden.
Deine Funktionen sollten also

void seti(int const & i)  // i ist const und wird nicht verändert.
{
	i = 3;     // das geht nicht, du hast in der Signatur garantiert, dass i nicht geändert wird.
}

void setj(int & j)   // nicht const => Du musst davon ausgehen, das j bei verändert wird.
{
	j = 3;      // kein Problem.
}