Vertauschen mit den Zeigern

Question

Um zwischen px und py zu tauschen, benötigen Sie einen Zeiger, der auf die Adresse py und px zeigt, um sie effektiv zu vertauschen.

Meine Frage ist mit der int temp, wenn der Wert von px in sie gesetzt wird, wie es den richtigen Wert zurück nicht geben, weil es keine Zeiger, der auf es ist in der Lage den richtigen Wert zu geben, und wie ist die Adresse des int temp nicht klonen, um einen falschen Wert zu geben?

void swap(int px, int py) 
{ 
    int temp; 
    temp = px; 
    px = py; 
    py = temp; 
} 

//pointer version 

void swap(int *px, int *py) 
{ 
    int temp; 
    temp = *px; 
    *px = *py; 
    *py = temp; 
} 

Answer 1

In dieser Funktion

void swap(int *px, int *py) 
{ 
    int temp; 
    temp = *px; 
    *px = *py; 
    *py = temp; 
} 

dort werden aufgezeigt tauschte Werte von px und py. Die Funktion tauscht die Zeiger nicht selbst aus.

Um die Werte zu vertauschen, auf die die Zeiger zeigen, benötigen Sie einen Zwischenspeicher, in dem temporär der Wert px gespeichert wird, der durch den Wert py überschrieben wird. Die Funktion verwendet die lokale Variable temp, die den Wert *px temporär speichert.

beachten, dass in dieser Zuordnungsanweisung

temp = *px; 

die variablen temp speichert den Wert von px hingewiesen, dass *px ist die int hat geben. Es ist nicht der Zeiger px selbst, der temp zugeordnet ist.

Answer 2

Beide Funktionen tauschen die int Werte. Aber wirkt sich dieser Austausch auf die int s des aufrufenden Codes aus?

Mit den zweiten swap() wird die Wirkung des Swaps in den ursprünglichen a,b gesehen, wie die Funktion mit den Adressen der ursprünglichena,b arbeitet.

int a = 1; 
int b = 2; 
swap_version2(&a, &b); 
printf("%d %d\n", a, b); // prints 2 1 

Mit den ersten swap(), die Wirkung des ausgelagert ist nicht im ursprünglichen c,d gesehen. als die swap() Funktion tauschte Kopien von c,d. Nettoeffekt: Die erste Tauschfunktion verschwendet einfach Zeit. Es tauscht nicht c,d.

int c = 3; 
int d = 4; 
swap_version1(c, d); 
printf("%d %d\n", c, d); // prints 3 4 

Answer 3

Es gibt zwei wichtige Dinge, die Sie wissen müssen.

1) Beim Aufrufen einer Funktion in C werden die Argumente immer als Wert übergeben. Wenn Sie innerhalb der FunktionenÄnderungen an den Variablen vornehmen, die den übergebenen Wert enthalten, gehen die Änderungen verloren, sobald die Funktion zurückkehrt. Mit anderen Worten: Jede innerhalb der Funktion vorgenommene Änderung kann außerhalb der Funktion nicht gesehen werden.

2) Beim Arbeiten mit Zeiger bedeutet der Operator * vor dem Zeiger the location pointed to by the pointer. Es heißt Dereferenzieren des Zeigers.Also, wenn Sie *px = 5; tun, tun Sie nicht ändern Sie jeden Zeiger Wert! Sie ändern den Wert an der Stelle, auf die der Zeiger zeigt.

Ein genauerer Blick auf Ihrem Code:

In Ihrem ersten Beispiel haben Sie so etwas wie:

void swap(int px, int py) 
{ 
    int temp; 
    temp = px; 
    px = py; 
    py = temp; 
} 

int main(void) 
{ 
    int x = 10; 
    int y = 100; 
    swap(x, y); 
    printf("%d %d\n", x, y); 
    return 0; 
} 

In C alles von Wert übergeben wird. Wenn Sie also swap aufrufen, werden die Werte 10 und 100 an die Funktion übergeben. Es ist nicht die Variablen x und y. Mit anderen Worten - px und py in der Funktion hat nichts mit den Variablen x und y in main zu tun. Dies bedeutet, dass jede Änderung an den Variablen px und py verloren geht, wenn die Funktion zurückkehrt und x und y nicht nicht ändern.

Ihr zweites Beispiel ist wie folgt aus:

void swap(int px, int py) 
{ 
    int temp; 
    temp = *px; 
    *px = *py; 
    *py = temp; 
} 

int main(void) 
{ 
    int x = 10; 
    int y = 100; 
    swap(&x, &y); // Notice the & operator 
    printf("%d %d\n", x, y); 
    return 0; 
} 

Wie immer haben wir Pass von Wert. Aber in diesem Fall sind die Werte, die Sie übergeben, die Werte von zwei pointer to int. Spezifischer übergeben Sie die Adresse x und y.

Wie, bevor Sie den Wert nicht ändern können, die an die Funktion übergeben wird (genau wie beim ersten Beispiel), aber Sie können ändern Sie den Wert von was auch immer der Zeiger auf zeigt.

Hier müssen Sie wissen, dass * vor dem Zeiger zugreifen, was auch immer der Zeiger zeigt.

So wird temp = *px den Wert lesen, auf den px zeigt. In diesem Fall ist es 10 so temp erhält den Wert 10.

*px = *py Dadurch liest den Wert py Punkte auf (d.h. 100), und es setzt, wo px Punkte (d.h. x in main nun 100).

*py = temp Dadurch liest der Wert temp hält (d 10), und es setzt, wo py Punkte (d.h. y in main nun 10). Wenn die Funktion zurückkehrt, wurde der Wert x und y vertauscht.

Beachten Sie, dass der Code nie einen Zeiger auf (auch bekannt als die Adresse von) temp verwendet. Die Variable temp wird nur als gewöhnliches int verwendet.