Zeiger/Referenz-Operationen identisch?

Hallo,

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

feigling

Du übersichst, dass die 2. Funktion nicht mit C zu verwirklichen ist, sondern C++ Code darstellt.

C++ Forumbot

Dieser Thread wurde von Moderator/in Tim aus dem Forum ANSI C in das Forum C++ verschoben.

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

Dieses Posting wurde automatisch erzeugt.

BorisDieKlinge

die funktionen amchen schon das selbe.. aber zwischen zeiger und referenzen besteht trozdem ein unterschied...

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:)

queer_boy

_peter schrieb:

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.

BorisDieKlinge schrieb:

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

Nein, leider nicht.

Finde die Lösung mit Zeigern nicht besonders gut. Da halten viele eine Überprüfung auf 0 für notwendig.

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

Xin

_peter schrieb:

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.
}