Un besoin courant lors de la programmation en langage C est d'échanger les valeurs de deux éléments d'un tableau. Cette opération est utilisée dans de nombreux algorithmes et programmes, il est donc très important d'apprendre à écrire du code qui échange les valeurs d'un tableau. Ce tutoriel vous présentera comment utiliser le langage C pour implémenter cette fonction.
Avant de commencer à écrire le code, nous devons d’abord clarifier le but de l’échange de valeurs d’éléments de tableau. Échanger les valeurs des éléments du tableau signifie échanger les valeurs de deux éléments. Afin de réaliser cette fonction, on peut utiliser une variable auxiliaire pour stocker temporairement la valeur d'un élément, puis attribuer la valeur d'un autre élément à cette variable, et enfin attribuer la valeur de la variable auxiliaire au deuxième élément. Voici un exemple de code qui échange les valeurs des éléments du tableau :
4 Tutoriel sur l'écriture de code pour échanger des valeurs de tableau en langage C
#inclure
void swap(int *a, int *b) {
int temp = *a;
*une = *b;
*b = température ;
}
int main() {
int arr[] = {4, 2, 6, 1, 8};
int taille = taillede(arr) / taillede(arr[0]);
int premierIndex = 0 ;
int secondIndex = 3;
printf(\array avant échange:\ for (int i = 0; i < size; i++) {
printf(\d\arr[i]);
}
printf(\n\ swap(&arr[premierIndex], &arr[secondIndex]);
printf(\Tableau échangé :\ pour (int i = 0; i < taille; i++) {
printf(\d\arr[i]);
}
printf(\n\ retourner 0;
}
Dans ce code, nous définissons une swapfonction qui accepte deux pointeurs comme paramètres. swapLa fonction utilise une variable auxiliaire temppour stocker la valeur du premier élément, puis attribue la valeur du deuxième élément au premier élément et enfin attribue la valeur de la variable auxiliaire au deuxième élément. Dans mainla fonction, nous définissons un tableau d'entiers arret initialisons les valeurs de certains éléments. Nous choisissons d'échanger les deux éléments à l'index 0 et à l'index 3 dans le tableau et swapimplémentons l'échange en appelant une fonction.
En exécutant ce code, nous pouvons voir le résultat suivant :
Tableau avant échange : 4 2 6 1 8
Tableau échangé : 1 2 6 4 8
Grâce à cet exemple simple, nous avons appris à utiliser le langage C pour écrire du code qui échange les valeurs des éléments d'un tableau. Ensuite, nous pouvons étendre davantage cette fonctionnalité pour fonctionner avec différents types de tableaux.
Pour différents types de tableaux, nous pouvons implémenter des fonctions d'échange universelles en utilisant des méthodes de programmation génériques. La programmation générique est une méthode de programmation qui nous permet d'écrire du code indépendant de types spécifiques. En langage C, nous pouvons utiliser voiddes pointeurs pour implémenter une programmation générique. Voici un exemple de code qui utilise la programmation générique pour implémenter une fonction générique qui échange les valeurs des éléments du tableau :
#inclure
void swap (void *a, void *b, size_t taille) {
char temp[taille];
memcpy(temp, a, taille);
memcpy(a, b, taille);
memcpy(b, temp, taille);
}
int main() {
int arr1[] = {4, 2, 6, 1, 8};
int taille1 = taillede(arr1) / taillede(arr1[0]);
int premierIndex1 = 0;
int secondeIndex1 = 3;
double arr2[] = {3,14, 2,71, 1,41, 2,23} ;
int taille2 = taillede(arr2) / taillede(arr2[0]);
int premierIndex2 = 1;
int secondeIndex2 = 2;
printf(\tableau entier avant échange :\ for (int i = 0; i < size1; i++) {
printf(\d\arr1[i]);
}
printf(\n\ swap(&arr1[firstIndex1], &arr1[secondIndex1], sizeof(int));
printf(\Tableau d'entiers échangés :\ for (int i = 0; i < size1; i++) {
printf(\d\arr1[i]);
}
printf(\n\ printf(\Tableau à virgule flottante double précision avant échange :\ for (int i = 0; i < size2; i++) {
printf(\2lf\arr2[i]);
}
printf(\n\ swap(&arr2[firstIndex2], &arr2[secondIndex2], sizeof(double));
printf(\Tableau à virgule flottante double précision échangé :\ for (int i = 0; i < size2; i++) {
printf(\2lf\arr2[i]);
}
printf(\n\ retourner 0;
}
Dans ce code, nous avons modifié swapla définition de la fonction afin qu'elle accepte un paramètre supplémentaire sizepour spécifier la taille en octets de l'élément. À l'intérieur de la fonction, nous utilisons memcpydes fonctions pour implémenter des échanges de valeurs d'éléments génériques. Dans mainla fonction, nous définissons deux tableaux, l'un est un tableau d'entiers arr1et l'autre est un tableau à virgule flottante double précision arr2. Nous échangeons respectivement différents éléments du tableau et produisons le tableau avant et après l'échange.
En exécutant ce code, nous pouvons voir le résultat suivant :
Tableau d'entiers avant échange : 4 2 6 1 8
Tableau d'entiers échangés : 1 2 6 4 8
Tableau à virgule flottante double précision avant échange : 3,14 2,71 1,41 2,23
Tableau à virgule flottante double précision échangé : 3,14 1,41 2,71 2,23
Grâce à cet exemple, nous avons appris à écrire une fonction d'échange générale pouvant être appliquée à différents types de tableaux.
Pour résumer, ce tutoriel vous a présenté comment écrire du code pour échanger les valeurs des éléments d'un tableau en utilisant le langage C. Nous utilisons d'abord une variable auxiliaire pour implémenter l'échange, puis utilisons des méthodes de programmation génériques pour rendre la fonction d'échange applicable à différents types de tableaux. En apprenant ces connaissances, nous pouvons mieux appliquer le langage C au développement de la programmation. J'espère que ce tutoriel sera utile à tout le monde !
Le code de cet article est transféré de : https://www.wodianping.com/c/2023-08/253940.html