Probleme de pointeur(langageC)

[deyni]

Bonjour,

je n'arrive pas à faire quelque chose:
Si j'ai un tableau tab:
tab[i] = *(tab + i)

tab[] = {"bonjour"};
*tab = "bonjour"

Mais si j'ai un tableau qui contient des mots, par exemple:

tab[][] = {{5, 2,8 }, {7, 4, 8, 9}

Comment faire pour la mettre sous forme de pointeur?
Un trcu du genre
**tab = ????


Deuxieme problème:
J'ai un tableau, et chaque case du tableau contient une chaine de caractere. Par exemple la 1ere case contient: Bonjour, la deuxieme: ordinateur.....

je devais coompter le nombre de mot de ce tableau, mais j'ai essayé et ce fut un echec:

#include <stdio.h>

int main() {
    char *chaine = {"motun", "deuxiememot", "trosieme", "quatriememot", "etlecinquieme"};
    int i = 0;
   
   while (  **( chaine + i ) ) {
       i++;
    }
  printf("%d", i);
  
  return 0;
}

Mais ça ne marche pas.
Pourtant, **(tab + 1) =d
**(tab + 2) = t
....


Merci bien
-----

[kwariz]

Bonjour,

je vais répondre à ce post et pas à l'autre ...

Tu confonds pointeurs et tableaux (remarque c'est un des pièges du c).

tab[] = {"bonjour"};
*tab = "bonjour"

Dans le premier cas tab est un tableau de char*, tu le déclares ainsi :

char *tab[]={"bonjour"};

Concrètement le compilateur va créer un tableau de 1 élément et stocker l'adresse de la chaine "bonjour" dans cet élément.

Dans le second cas tab est simplement une chaine de caractère :

char* tab="bonjour"

tab est un pointeur qui contient l'adresse de "bonjour"

Attention, si tu utilises :

char tab[]="bonjour"

tab est un tableau, le compilateur l'initialise avec le contenu de la chaine "bonjour" : il s'agit d'une copie.

Mais si j'ai un tableau qui contient des mots, par exemple:

tab[][] = {{5, 2,8 }, {7, 4, 8, 9}

Comment faire pour la mettre sous forme de pointeur?
Un trcu du genre
**tab = ????

Si je comprends tu désirerais déclarer un pointeur sur un pointeur sur char et l'initialiser statiquement ?

Un autre message suit pour ton second problème.

[kwariz]

Deuxieme problème:
J'ai un tableau, et chaque case du tableau contient une chaine de caractere. Par exemple la 1ere case contient: Bonjour, la deuxieme: ordinateur.....

je devais coompter le nombre de mot de ce tableau, mais j'ai essayé et ce fut un echec:

#include <stdio.h>

int main() {
    char *chaine = {"motun", "deuxiememot", "trosieme", "quatriememot", "etlecinquieme"};
    int i = 0;
   
   while (  **( chaine + i ) ) {
       i++;
    }
  printf("%d", i);
  
  return 0;
}

Mais ça ne marche pas.
Pourtant, **(tab + 1) =d
**(tab + 2) = t
....


Merci bien

Si tu as compilé ce code alors ton compilateur a dû émettre quelques warnings, non ?

Pour commencer regarde la ligne en rouge, d'un côté tu dis que chaine est un char* (un pointeur sur un caratère = une chaine de caractères) et de l'autre côté tu essayes de l'initialiser avec un tableau de chaines de caractères ??? il y a un problème.

Si tu veux que chaine soit un tableau de chaines de caractères il faut déclarer chaine comme :

char *chaine[]={"motun", ...};

Ensuite il va falloir revoir comment sont géré les tableaux en C ... mais j'ai l'impression que la confusion se situe plus au niveau de chaine de caractères (qui en un sens sont des tableaux de caractères) et tableau de chaines de caractères ...

Comment sais-tu que tu est à la fin de ton tableau chaine ?

[deyni]

Bonjour, et merci une fois de plus kwariz.

excusez-moi pour les doubles messages, mais l'ordinateur bug lorsque j'edite mon message.

merci pour ces explications.
Lorsque le tableau est à une dimension, je n'ai aucun problème.
je cherche l'equivalence de

char  tab[] = {"bonjour} //identique à
char*tab = "bonjour"

avec:

char tab[][] = {{bonjour, bonsoir}, {jour, soir}}
**tab = ????

Pour ma deuxieme question, j'ai eu des warnings, et sans trop comprendre ce que j'ai fais, je suis tombé sur la bonne réponse:

#include <stdio.h>

int main() {
	char *chaine[] = {"mot1", "et", "mot2", "et", "mot3"};
	
	int i = 0;
	
	while(*(chaine +i)){ //surprenant!!!
			//printf("%c", *(chaine + 3));
		i++;
		}
	
	
	
	printf("%d\n", i);

	
	return 0;
}

La fin du tableau étant marqué par '\0', j'ai fais le: while (chaine[i])

Mais contre toute attente, je m'attendais à while(*chaine[i]). Ce que je ne comprends pas.

Merci bien.

[A voir en vidéo sur Futura]

[kwariz]

Bonjour,

Premier point : tableau et pointeur sont deux objets différents en C.
Même si souvent il semble qu'on peut utiliser l'un à la place de l'autre ce n'est pas tout le temps le cas.

Deuxième point : quand tu initialises une variable lors de sa déclaration tu ne peux le faire qu'avec une constante dont la valeur est connue lors de la compilation. Cette initialisation est différente d'une assignation. La constante soit avoir le même type type que la variable que tu initialises.

Troisième point : une chaine littérale comme "bonjour" est un pointeur sur caractères (char*) et non un tableau de caractères (char[]).

Quatrième point : tu ne peux, en général, connaître le nombre d'éléments d'un tableau qu'en en gardant la valeur dans une autre variable. Une alternative consisste à utiliser un élément spécial qui marque la fin du tableau. C n'impose aucune méthode particulière, tu es libre de choisir celle qui convient le mieux.

---

Tu ne peux pas écrire

char tab[]={ "bonjour" };

sans avoir des warnings. En effet du côté gauche tu déclares tab comme étant de type tableau de char, mais du côté droit tu donnes un constante qui est un tableau ( les {} le disent, mais elles serviront aussi pour les enregistrements = structures) qui contient un pointeur sur char.
Tu aurais pu utiliser une constante tableau de char comme {'b', 'o', 'n', 'j', 'o', 'u', 'r', 0}, mais aussi mettre directement "bonjour", car quand tu fais un intialisation statique le compilo va copier le contenu de droite à gauche car il y a de la place. Le compilateur sait qu'il va falloir 8 octets pour tout stocker, il l'alloue et y copie ce que tu demandes.
Il peut copier une chaine c comme "bonjour" dans un tableau de caractères. L'inverse est impossible : tu ne peux pas faire

char* ptr={'b', 'o', 'n', 'j', 'o', 'u', 'r', 0}

car l'espace alloué est fait pour un pointeur et pas pour ce qui est pointé : il ne sait pas où copier.
En revanche dans une expression comme :

char* ptr_string="bonjour"

tu lui demandes d;initialiser un pointeur sur char avec ... un pointeur sur char : donc ça fonctionne (mêmes types à gauche et à droite) mais il n'y a aucune copie. "bonjour" est un pointeur qui pointe vers un zone mémoire qui contient la chaine "bonjour" et ptr_string sera aussi un pointeur qui pointera au même endroit.
En passant : en général cet endroit est une zone mémoire en lecture seule, tu ne pourras donc pas modifier la chaine (ptr_string[1]='a' va planter).

Donc pour manipuler des tableaux de chaines il vaut mieux commencer par utiliser quelque chose comme :

char* mes_chaines[] = { "un", "deux", "trois", "quatre" }

plutôt que

char** mes_chaines

qui devra être initialisé dynamiquement.

---

Ensuite pour parcourir un tableau il est important de pas essayer d'accéder à des éléments en dehors du tableau. Par exemple avec :

char* mes_chaines[] = { "un", "deux", "trois", "quatre" }

accéder à mes_chaines[4] est une erreur. C ne fait aucun check par défaut et ne t'avertira pas si ton code contient cette erreur.
Il faut toujours quand tu parcours un tableau de pas en dépasser les limites. Pour ça tu as deux solutions :

1. garder dans une variable la taille du tableau
   

   int nbr_chaines =4

   tu peux également la calculer en utilisant sizeof. Malheureusement sizeof va te renvoyer la taille du tableau = le nombre d'octets utilisés. Il faut donc passer par une formule : nomre d'éléments = taille du tableau / taille d'un élément ce qui se traduit par :
   

   nbr_chaines = sizeof(mes_chaines) / sizeof(mes_chaines[0]);

   Ensuite pour parcourir le tableau un simple boucle for suffit :
   

   for(i=0; i<nbr_chaines;++i) { ... }

   C'est ce qui est le plus simple.
   
2. utiliser un élément spécial qui va marquer la fin du tableau. C'est ce qui est utilisé par la libc pour les chaines de caractères qui sont des tableaux de char dont la fin est marquée par le caractère nul (noté '\0' ou 0)
   Dans l'exemple des tableau de chaines on pourra utiliser le pointeur NULL pour indiquer la fin du tableau :
   

   char* mes_chaines[] = {"un", "deux", "trois", "quatre", NULL};

   Pour parcourir un tableau de ce genre on va passer par un pointeur qui pointer vers un des éléments du tableau. Si ce pointeur pointe vers NULL alors cela indiquera que nous sommes en fin de tableau. En général on passe par une boucle while
   

   char** ptr= &(mes_chaines[0]); // on fait pointer le pointeur sur la première chaine
   while ( *ptr != NULL ) { // tant que le ptr ne pointe pas sur la chaine NULL
     ....
     ++ptr; // on passe à la chaine suivante
   }

   Ce qu'on peut aussi coder avec un for :
   

   for(ptr=&(mes_chaines[0]);*ptr!=NULL;++ptr) {...}

Il va falloir revoir un peu les tutos sur les types, les pointeurs et les tableaux.

[kwariz]

je devais coompter le nombre de mot de ce tableau, mais j'ai essayé et ce fut un echec:

Tu as un énoncé plus précis ou est-ce juste un exo que tu as imaginé ?

[deyni]

Bonjour, et merci de votre réponse, de vos coneils et rappels.

Je ne comprends pas pourquoi, sur mon pc(environnement linux):

char test[] = {"bonjour};

affiche aucun warning, alors que je compile avec -Wall et -Wextra( merci au passage pour m'avoir appris ces trucs, (cf mes precedentes questions)).

Néamoins il n'accepte pas:

char* ptr={'b', 'o', 'n', 'j', 'o', 'u', 'r', 0}

Pour:

char* mes_chaines[] = { "un", "deux", "trois", "quatre" }

Ca compile, mais ça me met un "segmentation fault", et j'ai résolu ce problème.
Ce qui me pose problème c'est l'initialisation du **ptr. J'ai essayé un truc comme:

int main() {
	int **ptr;
	int taille1 = 5;
	int taille2 = 5;
	int i;
	int tableau[3];
	tableau[0] = 0;
	tableau[1] = 1;
	tableau[2] = 2;
	tableau[3] = '\0';
	
	
	ptr = malloc( taille1 * sizeof( *ptr ) );	
	
	for ( i = 0; i <= taille1; i++){
		ptr[i] = malloc( taille2 * sizeof( **ptr ) );
		
	}
	
	//ptr[5][5] = {"mot1", "et", "mot2", "et", "mot3"};  
	strcpy( ptr[0], "mot1");
	strcpy( ptr[1], "et");
	strcpy( ptr[2], "mot2");
	strcpy( ptr[3], "et");
	strcpy( ptr[4], "mot3");
	
	printf("%c", ptr[0][1]);
	
	for(i=0 ; i < taille1 ; i++){
    	free(ptr[i]);
	}
	free(ptr);
	ptr = NULL;


	return 0;
}

Mais rien du tout.


Je comprends l'idée de

char* mes_chaines[] = {"un", "deux", "trois", "quatre", NULL};
char** ptr= &(mes_chaines[0]); // on fait pointer le pointeur sur la première chaine
while ( *ptr != NULL ) { // tant que le ptr ne pointe pas sur la chaine NULL
  ....
  ++ptr; // on passe à la chaine suivante
}

Mais je ne comprends pas pourquoi on fait un
char **ptr =&(mes_chaines[0]);
et pourquoi:
char *ptr = &'mes_chaines[0]) est faux.

L'enoncé je ne l'ai pas inventé il fallait le faire, differement.
Moi je l'ai fais avec un main, mais l'énoncé disais qu'il fallait créer une fonction de signature:
int compter_mots( char **ptab)


Merci

[kwariz]

Bonjour, et merci de votre réponse, de vos coneils et rappels.

Je ne comprends pas pourquoi, sur mon pc(environnement linux):

char test[] = {"bonjour};

affiche aucun warning, alors que je compile avec -Wall et -Wextra( merci au passage pour m'avoir appris ces trucs, (cf mes precedentes questions)).

Effectivement, c'est une initialisation valide (j'en apprends tous les jours finalement ). La norme précise (en abrégé) que les accolades sont optionnelles s'il n'y a qu'un élément pour les types scalaires. Cela signifie que

int entier = {5};

est tout à fait valide et fait ce qu'on en attend.
J'ai tellement pris l'habitude de n'utiliser les accolades que dans les cas d'initialisation de tableau ou de structure que je les ai associées aux types composés ... comme quoi.

Néamoins il n'accepte pas:

char* ptr={'b', 'o', 'n', 'j', 'o', 'u', 'r', 0}

Parce qu'une variable de type pointeur est une variable qui ne peut contenir qu'une adresse. Or tu l'initialises avec quelque chose qui n'est pas une adresse (c'est un tableau) -> erreur.
Cela fonctionne avec

char* ptr="bonjour"

car "bonjour" est un pointeur (anonyme en un sens), "bonjour" représente donc une adresse -> tu peux initialiser un pointer avec.

Pour:

char* mes_chaines[] = { "un", "deux", "trois", "quatre" }

Ca compile, mais ça me met un "segmentation fault", et j'ai résolu ce problème.
Ce qui me pose problème c'est l'initialisation du **ptr. J'ai essayé un truc comme:
[...]
Mais rien du tout.

Bon, le plus simple va être que je te montre comment faire plutôt que de pointer les erreurs dans ton code. Je le fais dans le post suivant.

Je comprends l'idée de

char* mes_chaines[] = {"un", "deux", "trois", "quatre", NULL};
char** ptr= &(mes_chaines[0]); // on fait pointer le pointeur sur la première chaine
while ( *ptr != NULL ) { // tant que le ptr ne pointe pas sur la chaine NULL
  ....
  ++ptr; // on passe à la chaine suivante
}

Mais je ne comprends pas pourquoi on fait un
char **ptr =&(mes_chaines[0]);
et pourquoi:
char *ptr = &'mes_chaines[0]) est faux.

Il faut raisonner avec les types.
mes_chaines est un tableau de pointeurs sur char (char* [])
mes_chaines[0] est donc un pointeur sur char (char*)
&(mes_chaines[0]) est un pointeur sur un pointeur sur char (char**)
Si une variable doit contenir la valeur de &(mes_chaines[0]) alors elle devra avoir le type char**.

L'enoncé je ne l'ai pas inventé il fallait le faire, differement.
Moi je l'ai fais avec un main, mais l'énoncé disais qu'il fallait créer une fonction de signature:
int compter_mots( char **ptab)


Merci

On va s'en occuper dans le post suivant.

[kwariz]

On suppose dans toute la suite que nos tableaux de chaines sont des tableaux contenant des chaines et que le dernier élément du tableau est le pointeur NULL.
Nous allons créer une fonction compter_mots qui va compter le nombre de mots d'un tel tableau.
Ce qu'il faut savoir en C, c'est que dès que tu passes un tableau en paramètre à une fonction, d'une manière transparente pour toi, le compilateur va passer non pas le tableau en entier (ça pourrait être trop gros) mais juste un pointeur sur le premier élément du tableau : c'est la cause principale de la confusion entre tableau et pointeur.
Le code de la fonction est relativement simple et reprend ce dont nous avons déjà parlé :

int compter_mots(char** tab_chaines)
{
  int compte; // contient le nombre de mots                                         
  char** ptr; // pointeur pour parcourir le                                         
              // tableau de chaines                                                 
  compte=0;
  ptr=tab_chaines; // le paramètre est un pointeur                                  
                   // sur le premier élément                                        

  // Tant que ce qui est pointé est une chaine valide                               
  while(*ptr!=NULL ){
    ++compte; // on incrémente le nombre de mots trouvés                            
    ++ptr;    // on passe à la chaine suivante en utilisant                         
              // l'arithmétique des pointeurs                                       
  }

  return compte;
}

Il y a un moyen simple pour tester cette fonction : en utilisant le fait que la ligne de commande est passée en second argument à la fonction main :

/ argc contient le nombre d'arguments                                              
// argv est un tableau contenant argc éléments                                      
//      et est terminé par un pointeur NULL                                         
// argv[0] est toujours valide et contient                                          
// une représentation du nom de l'exécutable                                        
// qui dépend de l'os.                                                              
int main(int argc,char* argv[])
{
 printf("Nombre d'arguments %d\n", compter_mots(argv));

  return0;
}

Tu compiles, et si tu exécutes tu obtiendras :

> ./str 
Nombre d'arguments 1

> ./str 2 3 4 5 6 7 8 9
Nombre d'arguments 9

> ./str bonjour le monde
Nombre d'arguments 4

Et voilà un programme qui compte le nombre de mots de la ligne de commande.

Tu comprends ce qui a été fait ? Des questions sur le comment je l'ai fait ?

Si c'est OK, je te propose pour le post suivant de voir comment on peut construire un char** avec des mallocs et tout le toutim.

[deyni]

Bonjour,

merci de votre réponse.
J'ai un petit problème avec les tableaux:

#include<stdio.h>

int main() {
      int tab[5] = {1, 2, 3, 4}
      int i = 0;
      
      while(tab[i]) {
             i++;
      }

      printf("Il y a : %d element dans le tableau", i

      return 0;
}

Il affiche 4. Mais là:

#include<stdio.h>

int main() {
      int tab[5] = {0, 1, 0, 1}
      int i = 0;
      
      while(tab[i]) {
             i++;
      }

      printf("Il y a : %d element dans le tableau", i

      return 0;
}

Là il affiche 0 elements, et lorsque je fais des printfs, ça n'affiche rien. C'est comme si les 0 étaient pris pour des '\0'. Comment mettre des 0?

Pour le coup du **ptr:
mes_chaines est un tableau de pointeurs sur char (char* []) //C'est un tableau contenant des chaines de caractères, ok
mes_chaines[0] est donc un pointeur sur char (char*) //Oui, c'est le 1er élement du tableau. Donc il pointe sur mes_chaine[0]
&(mes_chaines[0]) est un pointeur sur un pointeur sur char (char**) //Là je ne comprends pas
Si une variable doit contenir la valeur de &(mes_chaines[0]) alors elle devra avoir le type char**.
Et comment avez-vous pensé à une tel astuce (passer par un pointeur de pointeur)?

Je suis très peu habitué à mettre des arguments dans le main.

Sinon, pour l'exercice, je ne comprends pas pourquoi mon programme ne fonctionne pas:

#include <stdio.h>

int compte_mots( char ** tab_chaine) {

           int compte; // contient le nombre de mots                                         
           char* ptr; // pointeur pour parcourir le tableau                                        
                                                             
           compte=0;
           ptr=tab_chaines; // le paramètre est un pointeur  sur le premier élément                                        
                           
           while(*ptr!=NULL ){ //tant que le contenu pointé par ptr est different de '\0'
           ++compte; // on incrémente le nombre de mots trouvés                            
           ++ptr;    // on passe à la chaine suivante en utilisant                         
           }

            return compte;
}



int main(){
               int **ptr = "essai", "fonctionne"
               int nombre;
               
               compte_mot(&&nombre);
               printf("il y a %d elements dans le tableau", nombre

               return 0
}

Merci

[kwariz]

Il faut absolument comprendre un truc :

Quand on te donne un tableau c'est à toi de faire gaffe de ne pas dépasser les limites du tableau. Il n'y a pas de moyen de savoir quand tu en as atteint la fin.

Tu connais la taille de ton tableau car tu l'as fixé au départ :
Soit avec un #define

#define N 5

int main()
{
  int tab[N]={0,1,2,3,4};
...

Soit en utilisant les sizeof

int main()
{
  int tab[]={0,1,2,3,4};
  int N = sizeof(tab)/sizeof(tab[0]);
  ...

Et quand tu as besoin de parcourir le tableau tu donnes non seulement le tableau mais également le nombre d'éléments :

...
  for(i=0; i<N; ++i)
    on manipule tab[i]

C n'offre aucun mécanisme standard (au contraire d'autres langages) pour faire une boucle qui traduirait :

tant que element_suivant(tableau) existe faire
  manipuler élément
fin tant que

ou

pour tous les éléments e de tableau tab faire
  manipuler e
fin pour

---

Pour le code que tu as posté, il faut se rappeler que les booléens ça n'existe pas en C. C utilise simplement les entiers en posant que faux sera représenté par n'importe quel type entier dont la valeur est 0, et vrai est représenté par n'importe quel type entier dont la valeur est différent de 0 (-1,1,123,...).

Ton premier code : ça fonctionne mais c'est un coup de bol. Ton programme est tombé en marche par hasard.
En effet la conditionnelle de ton while s'évalue à vrai tant que ton élément n'est pas 0. Avec ton premier tableau tu as de la chance qu'en mémoire le premier entier qui suit la fin de ton tableau vaut 0, dans le second cas tu n'as pas de chance car ton premier élément vaut 0 i.e. ton while(tab[i]) est en fait un while(0) et comme 0 c'est faux il ne rentre pas dans la boucle.

Maintenant, tu peux prendre la convention de dire que tes tableaux d'entiers sont des tableaux d'entiers positifs et que si jamais on tombe sur une valeur égale à -1 alors cela signifiera que c'est la fin du tableau. C'est une alternative pour ne pas se trimballer la taille du tableau (ou pour ne pas utiliser tout l'espace disponible).

Pour la dernière partie du message ... compter_mot est une fonction qui prend un tableau en paramètre et renvoie un entier qui est le nombre de mots du tableau. Lui passer comme paramètre un pointeur sur un pointeur sur int n'est pas bon : il faut lui passer le tableau en paramètre.
Pour récupérer la valeur c'est une simple affectation nombre=compter_mot(ptr)

Si tu veux déclarer un tableau de mots essaye plutôt char* ptr[]={"essai", "fonctionne"}.

[deyni]

Bonsoir, et merci une fois de plus.

Je ne me ferai plus avoir avec ce genre de truc(les tableaux).

Merci aussi pour l'astuce du -1. En fait on defini notre propre fin de tableau. Je n'avais pas du tout pensé au while(0)


Ce que je ne comprends pas c'est qu'un pointeur sur pointeur, ou un tableau de pointeur c'est la même chose (voire presque).
J'ai néamoins reussi par votre aide, à finir cet exercice.

Je vais faire la 2nd, qui est identique à la 1ere, sauf qu'on manipule du malloc de char**.
while ( tab[i] != - 1) {....}

[kwariz]

Bonsoir,

Dans une très grande majorité des cas, tu n''utiliseras les tableaux qu'avec une variable auxilliaire qui contiendra la taille. Tu ne rencontreras des marqueurs de fin que lorsque tu utilises des chaines (une chaine finit par le caractère 0 qu'on note aussi '\0') car le caractère 0 n'a aucune autre utilité, ou lorsque tu as une liste de pointeurs avec comme marqueur le pointeur NULL (qui est (en gros) prévu pour ça car NULL ne peut pas être un pointeur valide). L'exemple le plus marquant est, même si tu ne l'as pas encore utilisé, la fonction main que tu peux définir ainsi :

int main(int argc, char* argv[])

argv est un tableau de chaines et ce tableau a pour longueur argc (même si dans les faits c'est un chouia plus compliqué).
C'est compliqué de trouver un bon marqueur de fin pour un tableau d'entier car à priori tu ne peux pas en choisir un en général.
Pour comprendre ce qu'est un pointeur, pfff ... en fait c'est aussi simple à manipuler quand tu as compris que difficile à expliquer. Tu as du tomber sur des images du genre :

Avec une explication du genre : chaque variable possède une adresse mémoire, par exemple ptr est à l'adresse mémoire 0x4399 (0x signifie que le nombre qui suit est écrit en hexadécimal) et vaut 0x0123, la variable entier est à l'adresse mémoire 0x0123 et contient la valeur 12. Si tu fait un printf("%d", entier) alors tu vas afficher 12 (%d = j'affiche la valeur d'un entieren décimal), alors qu'un printf("%p", ptr) t'afficheras 0x0123 (%p = j'affiche la valeur d'un pointeur sous forme hexadécimale). Alors utiliser *p revient simplement à : je prends la valeur de p (0x0123) et je renvoie la valeur que je trouve à cette adresse comme à l'adresse 0x0123 se trouve 12 je renvoie 12.

Cette notion là te semble claire ?

[deyni]

Bonjour, merci de votre reponse.

Je ferai attenttion pour les tableaux merci.

Pour les pointeurs, c'est exactement ça. On nous a expliqué que le pointeur est une variable qui contient une adresse.
Cela me m'est clair(enfin, ce que je crois).