Zeiger

rudiM

Hallo,

@Kolumbus: Du warst der Lösung wohl am nächsten, ich war wie so oft voreilig.

void swap(int *&x, *&y) 
{ 
    int *temp;
    temp = x; 
    x = y; 
    y = temp; 
}

ich hab die beiden Sternchen wohl selbst nicht beachtet. Schande über mich.
@ Braunstein: is ok.
Gruß Rudi

Braunstein

Da fehlt noch ein int.
So ist es dann OKer.

void swap(int *&x, int *&y)
{
    int *temp = x;
    x = y;
    y = temp;
}

rudiM

Oops, i did it again..............

Aber das bringt mich auf die Frage: Wieso schafft es der Compiler mehrere Variablen den gleichen Typs anlegen zu lassen:

void f()
{
int a,b,c,d;

usw.
}

aber nicht innerhalb eines Funktionsaufrufes? Wäre doch praktisch, oder?
Gruß, der schreibfaule Rudi

audacia

rudiM schrieb:

aber nicht innerhalb eines Funktionsaufrufes?

Innerhalb eines Funktionsaufrufes darfst du ohnehin nichts deklarieren.

Daß du in Funktionssignaturen (auf die du dich vermutlich beziehst) nicht mehrere Variablen des gleichen Typs ohne erneute Nennung desselben deklarieren kannst, dürfte darin begründet sein, daß dir in deklarativem Kontext zwei Terminalsymbole zur Verfügung stehen (' , ' und ' ; '), in der Funktionssignatur jedoch nicht. Der Compiler betrachtet Variablendefinitionen in Funktionssignaturen insofern nicht gesondert, nur eben mit einem anderen Terminalsymbol. Auch in normalem Kontext geht folgendes nicht:

int a, b, float c;

In diesem Kontext trennt ' ; ' Deklarationen und ' , ' Bezeichner. In einer Funktionssignatur trennt ' , ' Deklarationen, und ' ; ' ist nicht erlaubt. Wäre das anders, so stünde auch einer Mehrfachverwendung von Typen wie in Pascal nichts im Wege:

void foo (int a, b; float c) { ... }

Hi,

zu dem viel geliebten Thema Zeiger und gerade dem Beispiel in diesem Thread habe ich noch eine Frage. Mir sind folgende 2 Versionen bekannt:

Vertauschen von 2 Variablen mittels Zeiger

void swap(int *x, int *y) 
{ 
 int temp = *x; 
 *x = *y; 
 *y = temp; 
}

Vertauschen mittels Referenzen

void swap(int &x, int &y) 
{ 
 int temp = x; 
 x = y; 
 y = temp; 
}

Doch was bedeutet diese Version ? Einen Zeiger auf eine Referenz ?

void swap(int *&x, int *&y) 
{ 
 int *temp = x; 
 x = y; 
 y = temp; 
}

Kann mir das bitte jemand erklären, macht das Sinn, das so zu tun ? Vorteile ?

Killer-Kobold

Bei den oberen beiden Versionen werden die Werte getauscht (auf die die Zeiger zeigen). Bei der letzten Version werden die Zeiger getauscht (die Werte werden nicht geändert, dafür zeigen die Zeiger nun jeweils auf den anderen Wert).

Gruß KK

Vielen Dank für Deine Erklärung, KK. Um das Ganze noch abzurunden, kannst Du mir noch sagen wann man welche Methode benutzt, also wäre die Variante 3 deutlich schneller als die andern zwei oder ist das egal ?

Braunstein

Variante 3 macht etwas ganz anderes als die anderen beiden Varianten (Zeigertausch wie schon erklärt). Varianten 1 und 2 sind ebenfalls nicht äquivalent einsetzbar da der Aufrufsyntax unterschiedlich ist.
Was habt ihr alle gegen std::swap?