Datasets:
Kant1
/
French_Wikibooks_articles

Dataset card Data Studio Files Community
1
text
stringlengths
0
211k
int *** malloc_3d(int nb_tableau, int lignes, int colonnes)
int i;
int j;
int***t = malloc(sizeof(*t) * nb_tableau);
/* première dimension */
if (t==NULL)
printf ("Impossible d'initialiser avec malloc\n" );
exit (-1);
for (i=0;i< nb_tableau;i++) {
t[i] = malloc(sizeof(**t) * lignes);
/* deuxième dimension */
if (t[i]==NULL) {
printf ("Impossible d'initialiser avec malloc\n" );
exit (-1);
for (j=0;j<lignes;j++) {
/* troisième dimension */
t[i][j] = malloc(sizeof(***t) * colonnes);
if (t[i][j]==NULL)
printf ("Impossible d'initialiser avec malloc\n" );
exit (-1);
return t;
Utilisation des pointeurs sur des tableaux particuliers.
Il est possible avec un pointeur de lire/parcourir les éléments d'une structure.
Chaque éléments d'une structure utilise un espace qui permet de calculer des déplacements.
Cependant cette utilisation est dangereuse, comme dans l'exemple ci-dessous qui ne fonctionne que sur les processeurs où la taille d'un pointeur égale celle d'un entier de type codice_1, ce qui n'est généralement pas le cas sur les processeurs 64 bits.
struct s
int a;
int b;
char *s;
}s;
int main(void)
struct s st={1,1,"salut"};
void *p=&st;
printf("%s\n", (char *)((void **)p)[2]);
/* <!> si sizeof(int) < sizeof(void*) le pointeur pointe après la structure ! */
/*<==OU==>*/
p += 2*sizeof(int);
printf("%s\n", (char *)((void **)p)[0]);
p -= 2*sizeof(int);
memset(p,-1, 2*sizeof(int));
printf("%i,%i\n", st.a, st.b);
memset((int *)p,0, 2*sizeof(int));
printf("%i,%i\n", st.a, st.b);
((int *)p)[0] = 1;
((int *)p)[1] = 0;
printf("%i,%i\n", st.a, st.b);
printf("%s\n", st.s);
return 0;
Utilisation des pointeurs pour passer des paramètres par adresse.
Toutes les variables en C, à l'exception des tableaux, sont passés par valeurs aux paramètres des fonctions. C'est à dire qu'une copie est effectuée sur la pile d'appel. Si bien que toutes les modifications de la variable effectuées dans la fonction seront perdues une fois de retour à l'appelant. Or, il y a des cas où l'on aimerait bien pouvoir modifier une variable passée en paramètre et que ces modifications perdurent dans la fonction appelante. C'est un des usages des paramètres par adresse : permettre la modification d'une variable de l'appelant, comme dans l'exemple suivant :
/* Ce code échange le contenu de deux variables */
void echange(int *a, int *b)
int tmp = *a;
*a = *b;
*b = tmp;
int main(void)
int a = 5;
int b = 2;
printf("a = %d, b = %d.\n", a, b);
/* On passe à 'echange' les adresses de a et b. */
echange(&a, &b);
printf("a = %d, b = %d.\n", a, b);
echange(&a, &b);
printf("a = %d, b = %d.\n", a, b);
return 0;
Ce passage par adresse est extrêmement répandu pour optimiser la quantité de données qui doit transiter sur la pile d'appel (qui est, sur beaucoup de systèmes, de taille fixe). En fait, même si la variable ne doit pas être modifiée, on utilise quand même un passage par adresse, juste pour éviter la copie implicite des variables autres que les tableaux. Ceci est particulièrement intéressant avec les structures, puisque celles-ci ont tendance à être assez imposantes, et cela ne nuit pas trop la lisibilité du programme.
Tableaux dynamiques et passage de tableaux comme arguments d'une fonction.
Comme on vient de le voir, l'intérêt principal d'une allocation dynamique est de pouvoir lancer son programme sans connaître la taille du tableau qu'on utilisera; celle-ci sera établie en cours de fonctionnement.
Cependant, un autre intérêt du tableau dynamique est de pouvoir être passé comme argument d'une fonction pour des tableaux à plusieurs dimensions.
En reprenant la fonction codice_37 vue précédemment, on peut écrire :
int fonction_3d (int ***tab);
int main(int argc, char **argv)
/* Tableau dynamique créé avec des malloc() */
int ***tab = malloc_3d(2, 10, 10);
fonction_3d (tab);
return EXIT_SUCCESS;
/* fonction recevant le tableau en 3d */
void fonction_3d (int ***tab)
/* On peut utiliser ici la notation tab[i][j][k] en veillant à
ce que i, j, k ne sortent pas des bornes du tableau -> dans
cet exemple tab[3][9][9] est illégal alors que tab[1][3][7]
peut être utilisé.
On ne pourra pas savoir si on sort du tableau !
Pointeurs vers fonctions.
Les pointeurs vers les fonctions sont un peu spéciaux, parce qu'ils n'ont pas d'arithmétique associée (car une telle arithmétique n'aurait pas beaucoup de sens). Les opérations permises avec les pointeurs sur fonctions sont en fait relativement limitées :
type_retour (*pointeur_fonction)(liste_paramètres);
Déclare codice_38, un pointeur vers une fonction prenant codice_39 comme paramètres et renvoyant codice_40. Le parenthésage est ici obligatoire, sans quoi l'étoile se rattacherait au type de retour. Pour faire pointer un pointeur vers une fonction, on utilise une affectation « normale » :
pointeur_fonction = &fonction;
/* Qui est en fait équivalent à : */
pointeur_fonction = fonction;
Où codice_41 est compatible avec le pointeur (mêmes paramètres et valeur de retour). Une fois que le pointeur pointe vers une fonction, on peut appeler cette fonction :
(*pointeur_fonction)(paramètres);
/* Ou plus simplement, mais moins logique syntaxiquement */
pointeur_fonction(paramètres);
Exemple simple d'utilisation de pointeur de fonction avec retour.
On fait une comparaison de deux entiers (5 et 4) via un pointeur sur une fonction de comparaison.
int comparaison_plus_grand_que(int a, int b)
return a > b ;
int main(int argc, char * argv[])