salut.
comme vous savez la notion de ponteur est un peut compliquer et difficile par rapport au debutant au programmation [en langage C] .
y a t il quelqu'un qui peut me donner une explication claire et efficace de cette notion .
et merci a tout le monde...
Salut,
Un pointeur est une adresse dans la mémoire. Ca permet de désigner les choses n'ont pas par leur valeur (qui peut changer), mais par leur adresse.
Que dire de plus?
Sur les pointeurs il n'y a pas grand chose à savoir, le tout est de pas faire de gaffe quand on programme après.
Tiens une question comme ça, pour me faire un avis, pourquoi apprends tu le C?
Bonjour,Envoyé par xaviii
salut.
comme vous savez la notion de ponteur est un peut compliquer et difficile par rapport au debutant au programmation [en langage C] .
y a t il quelqu'un qui peut me donner une explication claire et efficace de cette notion .
et merci a tout le monde...
Pour être plus terre à terre que notre canard préféré...
La mémoire est divisée en "cases" numérotées. Un pointeur, ou l'adresse d'une variable, ce n'est rien d'autre que le numéro de la case où la variable est stockée. Enfin, en gros, car une "grosse" variable peut occuper plisieurs cases, mais pour l'instant on s'en fiche. Et comme un numéro, cen'est finalement pas vraiment différent d'un entier, on peut faire de l'arithmétique avec les pointeurs (ou les adresses, ce qui est pareil).
Par exemple:
int i, j ; // deux variables entières
int *p ; // un pointeur sur un entier
p = &i ; // p "pointe" sur i, càd contient l'adresse de i
printf ("addr(i) = %x\n", (int) p) ; // afficher l'adrese de i
p = &j ; // on fait pareil avec j
printf ("addr(j) = %x\n", p) ;
Tu verras alors que addr(i) et addr(j) ne sont pas consécutives (il y a probablement 4 unités d'écart entre les deux): c'est parce qu'un entier occupe 4 octets ("cases") en mémoire (ou des fois seulement 2 mais c'est de plus en plus rare).
C'est pourquoi on doit faire la différence entre un pointeur sur entier (int *p) et un pointeur sur autre chose (char *pc par exemple): avec seulement le numéro de la case on ne peut pas savoir a priori ce qui est stocké à cet endroit, ce n'est qu'un ramassis d'octets en vrac. Seule la connaissance du type d'objet pointé permet d'interpréter correctement.
Ça devrait suffire pour le moment, une autre fois on pourra voir l'arithmétique de pointeurs plus en détail (pourquoi p++ ajoute 4 à p, au lieu de 1, si p est un pointeur sur int?)
Bonne cogitation!
-- françois
bonjour a tous,
tu trouvera ici un site ou tout est tres bien explique, et qui s'adresse aux debutants.
bonne continuation
Re : language C
slt a tous.
a propos des pointeurs,g essayé ce truc p++ et sa ajoute un 1 a r (p et un pointeur vers r) sa ajoute pas 4 fderwelt px tu mexpliquer ton point de vue.
voici un site qui explique bien les pointeurs et aussi tous le langage c++ pour les debutants.
http://www.linux-kheops.com/doc/ansi-c/node1.htm
j'ajoute aussi que j'ai un probleme a propos des pointeurs :je sais pas quand on doit donner le * au pointeur et quand on doit pas j'ai essayé de faire des tests pour conclure une regle qui definie quand on les met et quand on met pas mais j'ai pas trouvé.
p++ ajoute 1, mais quand p est un entier, p se déplace de 4 octets pour donner le prochain entier.
Pour avoir l'obet vers quoi pointe le pointeur, il faut mettre *pointeur.
Comme les pointeurs sont souvents utilisés avec des enregistrements, on n'est pas obligé de mettre *pointeur.champ, on peut mettre pointeur->champ.
Pole.
Le plus simle c'est de distinguer déclaration et utilisation:
Je veux déclarer un pointeur d'entier:
int *i;
Ceci pourrait s'écrire:
int (*i);
ainsi on dit: "(*i) est un entier"
Par contre on a bien déclaré et alloué un pointeur... c'est pour ça que:
int (*i) = NULL;
initialise le pointeur à NULL et pas l'entier pointé...
Tu veux dééclarer un pointeur de fonction retournant un pointeur de charactère?
char * toto(void); /*toto is function*/
char *(*toto)(void); /*toto is function ptr*/
Autrement dit on remplace nom par (*nom)
Pour l'utilisation:
Soit on manipule l'adresse, soit ce qu'il y a à l'addresse, dans le premier cas on met pas * et dans le deuxième on le met.
Bonjour,
Tout dépend de comment tu as déclaré ton pointeur! Ce n'est pas pareil si tu as mis "int *p" ou "char *p" (voir les autres posts, et les sites indiqués).
Maintenant, quand je dis que "p++" ajoute 4 à p, c'est assez crado, ce n'est vrai que si les int font effectivement 4 octets et si on interprète p comme un entier... ce qui n'est précisément pas à recommander! Conceptuellement, (et si p est bien un pointeur sur int), il faut se dire que p++ veut dire "p va pointer sur l'int suivant" (quelle qu soit la taille d'un int). On peut d'ailleurs écrire aussi p += 1 avec le même résultat.
Moralité: les pointeurs ne sont pas des entiers. On ne peut les voir comme ça que dans un but "pédagogique" qui s'adresse aux gens qui ont quelques connaissances sur la tripaillerie interne d'une bécane.
J'espère ne pas avoir introduit trop de confusion. Sinon, c'est moi qui suis confus...
-- françois
P.S. - Il existe en C "moderne" le spécificateur "%p" pour fficher la valeur hexa des pointeurs avec printf, avant on était obligé de faire un "%d" ou "%ld" (ou "%x" ou "%lx"). Mais à mon avis ça ne devrait servir qu'au débogage, parce qu'en principe on se contrefiche de la "vraie" valeur d'un pointeur.
merci pour cette explication,bon moi ce que je connais cetais vrai et jai ajouté des infos je veu les verifier:
un pointeur c une variable dont la valeur est ladresse dune autre variable,et un tableau en c++ c juste plusieurs variable se nommant successivement 0 1 2.....
chaqune deux contient ladresse dune autre variables (les element du tableau)et alors c pour sa kan on fé t[0]++ sa veu dire on ajoute a la variable 0 1 alors c la variable 1 le deuxieme element du tableau;
nest ce pas?
Bonjour snakemetalgear!
Je n'ai pas très bien compris ce que tu voulais dire, mais si c'est ce que j'ai compris c'est faux...
Un tableau c'est une suite de variables rangées consécutivement en mémoire. Si le premier élément du tableau, celui qui s'écrit T[0], est à l'adresse A, le suivant, celui qui s'écrit T[1] est à l'adresse A+1, et ainsi de suite.
Si le tableau T est déclaré par exemple comme int T[10], alors l'adresse A pourrait être déclarée comme int *A (pointeur sur entier). Et il est parfaitement légal d'écrire A = T, parce que T (sans indice entre crochets) est l'adresse du premier élément, c'est-à-dire un pointeur.
De même il est parfaitement légal d'écrire A[2] par exemple, parce qu'on peut appliquer l'opérateur "crochet" à n'importe quel pointeur. En fait, T[i] est exactement équivalent à *(T + i).
Donc quand tu fais T[0]++, c'est bien la première variable du tableau qui est augmentée de 1, et ça ne change rien ni à T ni aux autres variables du tableau.
En résumé: un tableau T[N] contient directement les variables repérées par un indice de 0 à (N-1). Pas les adresses de ces variables.
Bien sûr, il est possible de faire un tableau de pointeurs si on veut obtenir exactement ça, on déclare alors par exemple int *T[N], mais là c'est une autre histoire (et même la syntaxe n'est pas très claire, personnellement je préfère utiliser des typedef pour ne pas avoir à me rappeler la différence de priorité entre * et []).
Je ne sais pas si c'est très clair, mais depuis que je programme en C je ne me pose plus trop de questions, ça fait toujours du bien d'essayer d'expliquer clairement à quelqu'un qui débute...
-- françois
En fait il y a bien une logique très claire là dessous, quand on déclare un tableau on met:
TYPE nom[taille];
Or on sait que le type d'une variable se trouve en enlevant le nom de la déclaration, donc:
int *A; --> int *
Ainsi il est naturel d'avoir l'opérateur [] prioritaire, car il permet d'écrire:
TYPE nom[taille] sans parenthèses autour de TYPE quelque soit le type d'élément dans le tableau (et en plus des parenthèses ça donnerait une syntaxe à la cast).
Bonjour overmind,
Bien d'accord, en fait la logique (qui est aussi celle du compilo) est bien qu'en écrivant int *p on ne dit pas autre chose que "*p est un int". On peut d'ailleurs mettre des parenthèses: int (*p).
Mais à force de programmer en C++, j'ai pris une mauvaise habitude: celle d'écrire int* p, comme si int* était un type dérivé de int. Syntaxiquement ça ne change rien, mais ça encourage sournoisement à écrire des choses comme int* p, q là où on devrait écrire int *p, *q.
C'est pour ça que j'utilise pas mal les typedef, par exemple:typedef int *intptr ;Mais ça n'arrange pas forcément la lisibilité.
intptr p, q ;
-- françois
