Pointer-Adresse Frage

hi,

ich versuche grade den qualitativen unterschied zwischen diesen beiden funktionen zu verstehen:

void testfunktion_1(int & b)
{
	b = 3;
}

void testfunktion_2(int * b)
{
	*b = 6;
}

gibt es eine argumentation einer dieser zwei arten zeiger bzw. adresse zu übergeben, zu favoriseren ?

ich glaube das obere ist ohnehin kein reines C mehr sondern schon eine C++ erweiterung? kann das sein?

bauerb

Hi!

Stimmt. Das zweite ist ein C++ Feature und nennt sich References.

Bsp:

void testfunktion_1(int & b)
{
    b = 3;
}

void testfunktion_2(int * b)
{
    *b = 6;
}

int main()
{
    int test=1;

    testfunktion_1(test);
    testfunktion_2(&test);
}

Der Vorteil von References ist, dass das Datum per Reference übergeben wird und nicht per Value.

mfg bauerb

drakon

bauerb schrieb:

Hi!

Stimmt. Das zweite ist ein C++ Feature und nennt sich References.

Wenn schon, ist das das erste Beispiel.

Der Vorteil von References ist, dass das Datum per Reference übergeben wird und nicht per Value.

Und was wird bei einem Zeiger gemacht?

@topic:
Der Unterschied von Zeiger und Referenzen und deren Vor/Nachteile wird des öfteren Diskutiert. Kanns mal hier suchen, dann findest du bestimmt die letzte, relativ lange Diskussion dazu.

Aber hier kann man schon ein paar Sachen dazu sagen.
1. Bei der Referenz (void testfunktion_1(int & b)) muss sich der Aufrufer der Funktion nicht darum kümmer, wie das jetzt übernommen wird. Beim Zeiger musst du speziell die Adresse übergeben. (Somit ist die Referenz einfacher zu benutzen).
Das führt uns jetzt dahin, dass wir anstatt einen Zeiger auf ein Objekt einfach 0 angeben können, was dann undefiniertes Verhalten in der Funktion hervorruft. (Also müsste man dort noch überprüfen, ob überhaupt ein gültiger Zeiger übergebenworden ist), was bei einer Referenz nicht passieren kann.

EDIT:
Das habe ich gemeint: (gleiche Fragestellung). Da findest du auch noch Verweise auf noch ältere Thraeds.
http://www.c-plusplus.net/forum/viewtopic-var-t-is-215245-and-highlight-is-*zeiger*+*referenzen*.html

bauerb schrieb:

Hi!

Stimmt. Das zweite ist ein C++ Feature und nennt sich References.

Bsp:
void testfunktion_1(int & b)
{
    b = 3;
}

void testfunktion_2(int * b)
{
    *b = 6;
}

int main()
{
    int test=1;

    testfunktion_1(test);
    testfunktion_2(&test);
}
Der Vorteil von References ist, dass das Datum per Reference übergeben wird und nicht per Value.

testfunktion_2(&test);
Hier wird die Adresse von test übergeben - und nicht der Wert!
... und nicht per Value.?

mfg bauerb

danke für eure antworten.

wie verwende ich den die referenzvariablen in klassen?

scheinbar hab ich da ein problem bei der initialisierung, wenn ich eine referenz als member aufnehmen....

ich muss einer referenz zwingend einen wert zuweisen?! und wenn ich keinen habe?

drakon

Jogi23423 schrieb:

danke für eure antworten.

wie verwende ich den die referenzvariablen in klassen?

scheinbar hab ich da ein problem bei der initialisierung, wenn ich eine referenz als member aufnehmen....

ich muss einer referenz zwingend einen wert zuweisen?! und wenn ich keinen habe?

Du musst eine haben. Die übergibst du dann im ctor. Also in der Initialisierungsliste.

Xantus

drakon schrieb:

Jogi23423 schrieb:

ich muss einer referenz zwingend einen wert zuweisen?! und wenn ich keinen habe?

Du musst eine haben. Die übergibst du dann im ctor. Also in der Initialisierungsliste.

Wenn du keinen hast, dann nimmst du halt einen Zeiger und initialisierst ihn mit 0

Erhard Henkes

Der Unterschied zwischen C-Pointer und C++-Referenz besteht darin, dass Du auf den C-Pointer im Speicher zugreifen kannst, während die C++-Referenz "versteckt" gehandhabt wird.

Hier ein Musterprogramm:

#include <iostream>
#include <conio.h>
using std::cout;
using std::endl;

//globale Variablen
int a = 1;
int b = 2;

void ausgabe()
{
    cout << &a << ": " << a << "\t " << &b << ": " << b  << endl << endl;
}

void erfolgloser_swap( int x, int y )
{
  cout << "Kopien auf dem Stack: " << endl;
  cout << &x << ": " << x << "\t " << &y << ": " << y << endl;

  int temp = x;
  x = y;
  y = temp;

  cout << &x << ": " << x << "\t " << &y << ": " << y << endl;
  cout << "swap nur lokal erfolgreich." << endl;
}

void zeiger_swap( int * x, int * y ) // C-Lösung
{
  int temp = *x; // Inhalts-Operator // Dereferenzierungs-Operator
  *x = *y;
  *y = temp;
}

void referenzen_swap( int & x, int & y ) // C++-Lösung
{
  int temp = x;
  x = y;
  y = temp;
}

int main()
{
    cout << "Ausgangssituation: " << endl;
    ausgabe();

    cout << "Tausch mittels std::swap(x,y): " << endl;            
    std::swap(a,b); // Methode der Wahl aus der STL
    ausgabe();

    cout << "Tausch mittels Zeiger: " << endl;            
    zeiger_swap(&a, &b);
    ausgabe();

    cout << "Tausch mittels Referenzen: " << endl;            
    referenzen_swap(a,b);
    ausgabe();

    cout << "Erfolgloser Tausch, da nur lokale Kopien getauscht werden." << endl;            
    erfolgloser_swap(a,b);
    ausgabe();

    cout << "Tausch mittels Register eax und ebx: " << endl;        
    //swap (a,b)
    __asm("mov _b, %eax"); //AT&T Syntax bei Dev-C++
    __asm("mov _a, %ebx");
    __asm("mov %eax, _a");
    __asm("mov %ebx, _b");
    ausgabe();

    getch();
}