Implémenter la fonction Swap en C

1. Utiliser une variable temporaire pour implémenter la fonction de permutation en C
2. Utiliser les opérations arithmétiques pour implémenter la fonction de permutation en C
3. Utiliser l’opération XOR au niveau du bit pour implémenter la fonction de permutation en C
4. Utilisez l’opération XOR au niveau du bit et les macros pour implémenter la fonction de permutation en C

Cet article explique plusieurs méthodes d’implémentation de la fonction swap dans C.

Utiliser une variable temporaire pour implémenter la fonction de permutation en C

La fonction swap est une opération typique à effectuer sur des variables. Il n’y a pas de fonction de bibliothèque standard C qui fournit la fonctionnalité comme C++ a la fonction std::swap. Dans cet article, nous implémentons des fonctions d’échange pour les valeurs intégrales; à savoir, la plupart d’entre eux prennent des arguments de type long int, mais on peut toujours définir plusieurs prototypes pour différents types et garantir des fonctionnalités génériques en utilisant des extensions de macro. L’exemple suivant illustre la fonction d’échange à l’aide de la variable temporaire. Notez que, même s’il s’agit de l’implémentation la plus simple, celle-ci est relativement la version la plus rapide parmi d’autres répertoriées ci-dessous (lorsque les optimisations du compilateur sont utilisées).

#include <stdio.h>
#include <stdlib.h>

void swap(long *x, long *y) {
  long tmp = *x;
  *x = *y;
  *y = tmp;
}

int main(int argc, char *argv[]) {
  if (argc != 3) {
    printf("Usage: ./program first_number second_number/n");
    return 1;
  }

  long x = strtol(argv[1], NULL, 0);
  long y = strtol(argv[2], NULL, 0);

  printf("x:%ld, y:%ld\n", x, y);
  if (x != y) swap(&x, &y);
  printf("x:%ld, y:%ld\n\n", x, y);

  exit(EXIT_SUCCESS);
}

Exemple de commande:

./program 123 432

Production:

x:123, y:432
x:432, y:123

Utiliser les opérations arithmétiques pour implémenter la fonction de permutation en C

Alternativement, on peut implémenter une fonction d’échange en utilisant uniquement des opérations d’addition et de soustraction. Nous opérons sur les pointeurs passés dans la fonction, modifiant ainsi directement les valeurs des arguments. Dans la fonction main, il y a une condition if avant que la fonction swap ne soit appelée pour éviter l’invocation lorsque les opérandes sont égaux.

#include <stdio.h>
#include <stdlib.h>

void swap(long *x, long *y) {
  *x = *x + *y;
  *y = *x - *y;
  *x = *x - *y;
}

int main(int argc, char *argv[]) {
  if (argc != 3) {
    printf("Usage: ./program first_number second_number/n");
    return 1;
  }

  long x = strtol(argv[1], NULL, 0);
  long y = strtol(argv[2], NULL, 0);

  printf("x:%ld, y:%ld\n", x, y);
  if (x != y) swap(&x, &y);
  printf("x:%ld, y:%ld\n\n", x, y);

  exit(EXIT_SUCCESS);
}

Utiliser l’opération XOR au niveau du bit pour implémenter la fonction de permutation en C

L’implémentation la plus délicate et légèrement compliquée de la fonction swap est celle où l’opération XOR au niveau du bit est utilisée. Notez que cette version n’a pas besoin d’une troisième variable comme l’exemple précédent. Dans un premier temps, nous stockons le résultat XOR-ed des entiers donnés à l’un de leurs emplacements. Ensuite, nous XOR la valeur stockée (y) avec l’autre entier et stockons le résultat à la place de ce dernier. Enfin, les deux variables sont à nouveau XOR-ed, et le résultat est stocké dans la première variable modifiée - y dans ce cas. Cette implémentation implique plus d’instructions de code machine lorsqu’elle est compilée sans indicateurs d’optimisation, ce qui donne une solution plus gourmande en calcul.

#include <stdio.h>
#include <stdlib.h>

void swap(long *x, long *y) {
  *y = *x ^ *y;
  *x = *x ^ *y;
  *y = *x ^ *y;
}

int main(int argc, char *argv[]) {
  if (argc != 3) {
    printf("Usage: ./program first_number second_number/n");
    return 1;
  }

  long x = strtol(argv[1], NULL, 0);
  long y = strtol(argv[2], NULL, 0);

  printf("x:%ld, y:%ld\n", x, y);
  if (x != y) swap(&x, &y);
  printf("x:%ld, y:%ld\n\n", x, y);

  exit(EXIT_SUCCESS);
}

Utilisez l’opération XOR au niveau du bit et les macros pour implémenter la fonction de permutation en C

Comme démontré dans l’exemple précédent, la fonction de permutation XOR peut également être implémentée en tant que macro de type fonction. Notez qu’il doit y avoir une vérification si les deux opérandes sont le même objet; sinon, la macro affecte zéro à l’objet, ce qui entraîne une sortie erronée. Ce contrôle est implémenté en utilisant ?: Conditionnel, et alors seulement nous exécutons l’algorithme de permutation XOR similaire à l’implémentation précédente. Notez cependant que cette macro de type fonction ne peut traiter que des valeurs intégrales.

#include <stdio.h>
#include <stdlib.h>

#define XORSWAP(a, b) \
  ((&(a) == &(b)) ? (a) : ((a) ^= (b), (b) ^= (a), (a) ^= (b)))

int main(int argc, char *argv[]) {
  if (argc != 3) {
    printf("Usage: ./program first_number second_number/n");
    return 1;
  }

  long x = strtol(argv[1], NULL, 0);
  long y = strtol(argv[2], NULL, 0);

  printf("x:%ld, y:%ld\n", x, y);
  XORSWAP(x, y);
  printf("x:%ld, y:%ld\n", x, y);

  exit(EXIT_SUCCESS);
}