Permutation des pointeurs en C (char, int)

La première chose que vous devez comprendre est que lorsque vous passez quelque chose à une fonction, que quelque chose est copié dans les arguments de la fonction.

Supposons que vous ayez ce qui suit:

void swap1(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    assert(a == 17);
    assert(b == 42);
    // they're swapped!
}

int x = 42;
int y = 17;
swap1(x, y);
assert(x == 42);
assert(y == 17);
// no, they're not swapped!

Les variables d'origine ne seront pas échangées, car leurs valeurs sont copiées dans les arguments de la fonction. La fonction procède ensuite à l'échange des valeurs de ces arguments, puis retourne. Les valeurs d'origine ne sont pas modifiées, car la fonction échange uniquement ses propres valeurs privées copie.

MAINTENANT, Comment Pouvons-nous contourner cela? La fonction a besoin d'un moyen de se référer aux variables d'origine, pas de copies de leurs valeurs. Comment pouvons-nous nous référer à d'autres variables en C? Utilisation de pointeurs.

Si nous passons des pointeurs à nos variables dans la fonction, la fonction peut échanger les valeurs dans nos variables, au lieu de ses propres copies d'arguments.

void swap2(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
    assert(*a == 17);
    assert(*b == 42);
    // they're swapped!
}

int x = 42;
int y = 17;
swap2(&x, &y); // give the function pointers to our variables
assert(x == 17);
assert(y == 42);
// yes, they're swapped!

Remarquez comment à l'intérieur de la fonction, nous n'attribuons pas aux pointeurs, mais à ce qu'ils pointent. Et les pointeurs pointent vers nos variables x et y. La fonction Change directement les valeurs stockées dans nos variables à travers les pointeurs que nous lui donnons. Et c'est exactement ce dont nous avions besoin.

Maintenant, que se passe-t-il si nous avons deux variables de pointeur et que nous voulons échanger les pointeurs eux-mêmes (par opposition aux valeurs qu'ils pointent)? Si nous passons des pointeurs, les pointeurs seront simplement copiés (pas les valeurs vers lesquelles ils pointent) vers les arguments.

void swap3(int* a, int* b) {
    int* temp = a;
    a = b;
    b = temp;
    assert(*a == 17);
    assert(*b == 42);
    // they're swapped!
}
void swap4(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
    assert(*a == 17);
    assert(*b == 42);
    // they're swapped!
}

int x = 42;
int y = 17;
int* xp = &x;
int* yp = &y;
swap3(xp, yp);
assert(xp == &x);
assert(yp == &y);
assert(x == 42);
assert(y == 17);
// Didn't swap anything!
swap4(xp, yp);
assert(xp == &x);
assert(yp == &y);
assert(x == 17);
assert(y == 42);
// Swapped the stored values instead!

La fonction swap3 échange seulement ses propres copies privées de nos pointeurs qu'il obtient dans ses arguments. C'est le même problème que nous avons eu avec swap1. Et swap4 change les valeurs vers lesquelles pointent nos variables, pas les pointeurs! Nous donnons à la fonction un moyen de se référer aux variables x et y, mais nous voulons qu'ils se réfèrent à xp et yp.

Comment on fait ça? Nous lui transmettons leurs adresses!

void swap5(int** a, int** b) {
    int* temp = *a;
    *a = *b;
    *b = temp;
    assert(**a == 17);
    assert(**b == 42);
    // they're swapped!
}


int x = 42;
int y = 17;
int* xp = &x;
int* yp = &y;
swap5(&xp, &yp);
assert(xp == &y);
assert(yp == &x);
assert(x == 42);
assert(y == 17);
// swapped only the pointers variables

De cette façon, il échange nos variables de pointeur (remarquez comment xp pointe maintenant vers y) mais pas le les valeurs qu'ils pointent. Nous lui avons donné un moyen de se référer à nos variables de pointeur, afin qu'il puisse les changer!

Maintenant, il devrait être facile de comprendre comment échanger deux chaînes Sous la forme de variables char*. La fonction d'échange doit recevoir des pointeurs sur char*.

void swapStrings(char** a, char** b){
    char *temp = *a;
    *a = *b;
    *b = temp;
    assert(strcmp(*a, "world") == 0);
    assert(strcmp(*b, "Hello") == 0);
}

char* x = "Hello";
char* y = "world";
swapStrings(&x, &y);
assert(strcmp(x, "world") == 0);
assert(strcmp(y, "Hello") == 0);