& im Funktionskopf

[äähhhö]

Hi...

int test(int *a) {...}

int b = 5;
test(&b);

Das ist klar (Pointer), aber wofür steht das hier:

int test(int &a) {...}

int b = 5;
test(b);

Oder geht das nur bei Strukturen?
Wenn ja oder nein: Was bringt das denn? ^^'

[Gast]

Der zweite Fall wäre eine Rezerenz. Die gibts aber nur in C++, nicht in C.

[äähhhö]

Das heißt also, dass beim Aufrufen der Funktion keine Kopie erzeugt, sondern auf die ursprüngliche Variable zugegriffen wird?

Wenn dies der Fall ist, wären die beiden Code-Schnipsel denn dann nicht nahezu gleich?
Ob nun Zeiger oder Referenz, es kommt auf das gleiche hinaus?

[Mario Sandler]

Ja, allerdings sind Referenzen leichter zu handhaben (eben wie normale Variablen).

[äähhhö]

Ok, danke, also heißt das, dass ich wenn schon Pointer benutzen müsste..
Aber was verbraucht eigentlich mehr Speicher:

int test(int b) {
return b:
}

int main() {
int a = 5;
test(a);
return 0;
}

int test(int *b) {
return *b:
}

int main() {
int a = 5;
test(&a);
return 0;
}

2 ints
oder
1 int und 1 Zeiger?

[Mario Sandler]

Abgesehn davon das die Beispiele keinen Sinn machen verbrauchen
bei einem int normalerweise alle Varianten gleich viel.
Also Call-by-Value verbraucht 1 int, und Call-by-Reference 1 Zeiger der
meist genauso groß ist wie ein int (Referenzen selbst sind intern als Zeiger
dargestellt).
Bei der Pointer/Referenz-Variante kannst du dir allerdings den Rückgabewert sparen

[supertux]

äähhhö schrieb:

Ob nun Zeiger oder Referenz, es kommt auf das gleiche hinaus?

nein. Du kannst dasselbe erzielen, aber das heißt nicht, dass der Code "äquivalent" wird oder so. Betrachte folgenden Code:

/* C Variante mit Zeigern */
#include <stdio.h>

int compute_somthing(int ptr)
{
    return ptr + 13;
}

void foo(int *ptr)
{
  int z;
  *ptr = 8;
  z = 10;

  /* ab jetzt brauche ich change_me nicht mehr zu verändern */
  ptr = &z;
  *ptr *= compute_somthing(*ptr);
}

int main(void)
{
   int change_me;
   foo(&change_me);
   printf("C: change_me = %d\n", change_me);
   return 0;
}

und jetzt dasselbe aber mit Referenzen

// C++ Variante mit Referenzen
#include <iostream>                                                         

int compute_somthing(int ptr)                                              
{                                                                           
    return ptr + 13;                                                       
}                                                                           

void foo(int &ptr)                                                          
{                                                                           
  int z;                                                                    
  ptr = 8;
  z = 10;                                                                   

  /* ab jetzt brauche ich change_me nicht mehr zu verändern */              
  ptr = z;
  ptr *= compute_somthing(ptr);                                            
}                                                                           

int main(void)                                                              
{                                                                           
   int change_me;                                                           
   foo(change_me);
   std::cout << "C++: change_me = " << change_me << std::endl;                   
   return 0;                                                                
}

Die Ausgabe:

C: change_me = 8
C++: change_me = 230

Beim C Programm hat change_me den Wert 8 (nach dem Aufruf von foo). 'ptr' zeigt irgendwann auf eine andere Stelle und change_me "merkt" das nicht. Wären das alle C++ Referenzen (wie im C++ Code), dann wäre das nicht möglich.