Aide C++ pointeur
Résolu/Fermé
didi1203
Messages postés
20
Date d'inscription
vendredi 16 mai 2008
Statut
Membre
Dernière intervention
24 janvier 2009
-
16 mai 2008 à 21:01
mamiemando Messages postés 33084 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 29 avril 2024 - 17 mai 2008 à 01:57
mamiemando Messages postés 33084 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 29 avril 2024 - 17 mai 2008 à 01:57
A voir également:
- Aide C++ pointeur
- Pointeur souris - Guide
- Pointeur souris disparu windows 10 - Guide
- Pointeur souris disparu pc portable asus - Guide
- Pointeur satellite astra gratuit - Forum TNT / Satellite / Réception
- Pointeur satellite fransat ✓ - Forum TNT / Satellite / Réception
10 réponses
mamiemando
Messages postés
33084
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
29 avril 2024
7 749
16 mai 2008 à 21:55
16 mai 2008 à 21:55
Le concept
Un pointeur est juste une adresse vers un objet. Cet objet peut être de n'importe quelle nature. Si par exemple c'est un objet de type "plop_t" le pointeur sera de type "plop_t *".
En tant qu'adresse, peu importe ce qui est pointé (int *, char *...), un pointeur est un variable qui fait toujours le même taille en mémoire (la taille d'une adresse). Par contre l'objet pointé peu être de taille variable. Typiquement un int et un char n'occupe pas la même taille en mémoire.
Un pointeur de type générique est noté void *. Cela signifie qu'on manipule une adresse mais qu'on ne précise pas la nature de l'objet situé à cette adresse.
Un pointeur peut pointer sur une adresse. Par exemple un int ** désigne l'adresse d'un int * lui même adresse d'un int.
Les opérateurs
Pour manipuler des pointeurs on a besoin de deux opérateurs uniares (ie à un paramètre). Soit p un objet de type plop_t. Alors :
- &p retourne l'adresse de l'objet p (et cette adresse devrait être stocké sous forme d'un pointeur de type plop_t *).
- *a retourne l'objet situé à l'adresse a. Si a est de type plop_t *, alors *a est a priori un objet de type plop_t. Si l'adresse a n'est pas initialisée vers une variable du programme, on provoque une erreur de segmentation.
Tu remarqueras en particulier que *&a == a.
Rien n'empêche d'appliquer plusieurs fois l'opérateur * tant que l'objet obtenu est une adresse valide. Par exemple si a est de type int ***, alors *a est de type int**, **a est de type int *, et ***a est de type int. Bien entendu pour manipuler ***a, il faut nécessairement que *a, **a n'ait pas provoqué une erreur de segmentation.
Pour les tableaux d'objets de type plop_t on peut manipuler des pointeurs de type plop_t * et utiliser l'opérateur [ ]. Typiquement quand tu manipules un char * ça désigne dans l'absolu l'adresse du caractère à cette adresse. Ainsi si a est de type char *, alors *a = a[0] et retourne le premier caractère de la chaîne. L'opérateur [ ] permet de taper les caractères suivants en se décalant d'un char à chaque fois. Ainsi s[i] signifie que je me place à l'adresse de s[0] et que je me décale de i caractères pour trouver le ième caractère de la chaîne. Cela suppose bien entendu encore une fois que s[i] a été alloué proprement, sinon on a encore une erreur de segmentation.
Les malloc et les free
Tu l'auras compris pour manipuler un pointeur sans soucis, il faut que l'adresse qu'il stocke pointe sur une zone allouer au programme (sinon erreur de segmentation !). Pour que la zone pointée soit alloué il faut :
1- soit que la zone ait déjà été alloué auparavant :
2- soit que tu alloues cette zone avec un malloc. Il faudra alors la libérer quand tu auras fini de l'utiliser avec un free. Bien entendu tu ne peux libérer une plage mémoire qu'une fois.
Si tu as besoin de compléments :
http://www.commentcamarche.net/forum/affich 1917858 pointeur c c
Si tu as bien comrpis, un exemple avec des matrices :
http://www.commentcamarche.net/forum/affich 1674769 matrices carrees
Bonne chance
Un pointeur est juste une adresse vers un objet. Cet objet peut être de n'importe quelle nature. Si par exemple c'est un objet de type "plop_t" le pointeur sera de type "plop_t *".
En tant qu'adresse, peu importe ce qui est pointé (int *, char *...), un pointeur est un variable qui fait toujours le même taille en mémoire (la taille d'une adresse). Par contre l'objet pointé peu être de taille variable. Typiquement un int et un char n'occupe pas la même taille en mémoire.
Un pointeur de type générique est noté void *. Cela signifie qu'on manipule une adresse mais qu'on ne précise pas la nature de l'objet situé à cette adresse.
Un pointeur peut pointer sur une adresse. Par exemple un int ** désigne l'adresse d'un int * lui même adresse d'un int.
Les opérateurs
Pour manipuler des pointeurs on a besoin de deux opérateurs uniares (ie à un paramètre). Soit p un objet de type plop_t. Alors :
- &p retourne l'adresse de l'objet p (et cette adresse devrait être stocké sous forme d'un pointeur de type plop_t *).
- *a retourne l'objet situé à l'adresse a. Si a est de type plop_t *, alors *a est a priori un objet de type plop_t. Si l'adresse a n'est pas initialisée vers une variable du programme, on provoque une erreur de segmentation.
Tu remarqueras en particulier que *&a == a.
Rien n'empêche d'appliquer plusieurs fois l'opérateur * tant que l'objet obtenu est une adresse valide. Par exemple si a est de type int ***, alors *a est de type int**, **a est de type int *, et ***a est de type int. Bien entendu pour manipuler ***a, il faut nécessairement que *a, **a n'ait pas provoqué une erreur de segmentation.
Pour les tableaux d'objets de type plop_t on peut manipuler des pointeurs de type plop_t * et utiliser l'opérateur [ ]. Typiquement quand tu manipules un char * ça désigne dans l'absolu l'adresse du caractère à cette adresse. Ainsi si a est de type char *, alors *a = a[0] et retourne le premier caractère de la chaîne. L'opérateur [ ] permet de taper les caractères suivants en se décalant d'un char à chaque fois. Ainsi s[i] signifie que je me place à l'adresse de s[0] et que je me décale de i caractères pour trouver le ième caractère de la chaîne. Cela suppose bien entendu encore une fois que s[i] a été alloué proprement, sinon on a encore une erreur de segmentation.
Les malloc et les free
Tu l'auras compris pour manipuler un pointeur sans soucis, il faut que l'adresse qu'il stocke pointe sur une zone allouer au programme (sinon erreur de segmentation !). Pour que la zone pointée soit alloué il faut :
1- soit que la zone ait déjà été alloué auparavant :
char c = "x";
char *p = &c;
printf("%c\n",*p); // ok
char *p2;
printf("%c\n",*p); // erreur de segmentation
2- soit que tu alloues cette zone avec un malloc. Il faudra alors la libérer quand tu auras fini de l'utiliser avec un free. Bien entendu tu ne peux libérer une plage mémoire qu'une fois.
char *p = (char *)malloc(sizeof(char)*10); // j'alloue une plage de 10 caractères; p[0] = '0'; // ok p[1] = '1'; // ok ... p[9] = '9'; // ok p[10] = '0'; // erreur de segmentation ... free(p);
Si tu as besoin de compléments :
http://www.commentcamarche.net/forum/affich 1917858 pointeur c c
Si tu as bien comrpis, un exemple avec des matrices :
http://www.commentcamarche.net/forum/affich 1674769 matrices carrees
Bonne chance
didi1203
Messages postés
20
Date d'inscription
vendredi 16 mai 2008
Statut
Membre
Dernière intervention
24 janvier 2009
16 mai 2008 à 22:14
16 mai 2008 à 22:14
--merci pour ta reponsse jy vois un peu plus clair je sais qu'il vaut mieux allouer un pointeur avec NULL au depart mais je comprends pas a quoi sa sert de faire des pointeurs on me dit comment en faire mais pas a quoi sa sert
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps
bitrate
Messages postés
439
Date d'inscription
vendredi 25 avril 2008
Statut
Membre
Dernière intervention
22 mars 2011
98
16 mai 2008 à 22:30
16 mai 2008 à 22:30
un pointeur ça pointe (c'est une adresse mémoire) :
sur une chaine, un bloc mémoire, une valeur etc...
voir sur un autre pointeur ^^
faut jouer avec les "*" et les "&" pour bien comprendre comment ça marche (en général quand ça plante ça pointe pas où il faut)
++
sur une chaine, un bloc mémoire, une valeur etc...
voir sur un autre pointeur ^^
faut jouer avec les "*" et les "&" pour bien comprendre comment ça marche (en général quand ça plante ça pointe pas où il faut)
++
didi1203
Messages postés
20
Date d'inscription
vendredi 16 mai 2008
Statut
Membre
Dernière intervention
24 janvier 2009
16 mai 2008 à 22:41
16 mai 2008 à 22:41
--daccord mais la tu me dit touours pas a quoi sa sert de pointer je sais pas eviter des plantage simplifier le code
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps et vive mes 13ans
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps et vive mes 13ans
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
didi1203
Messages postés
20
Date d'inscription
vendredi 16 mai 2008
Statut
Membre
Dernière intervention
24 janvier 2009
16 mai 2008 à 22:51
16 mai 2008 à 22:51
--ce que je voulais dire par je sais pas moi c'est je sais pas a quoi sa srt moi
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps
bitrate
Messages postés
439
Date d'inscription
vendredi 25 avril 2008
Statut
Membre
Dernière intervention
22 mars 2011
98
16 mai 2008 à 23:00
16 mai 2008 à 23:00
un pointeur ça pointe sur la mémoire
char txt[]="hello"; txt est l'adresse mémoire où sont les caractère h,e,l,l,o
char *ptxt=txt ; ptxt pointe aussi sur l'adresse mémoire txt.
le pointeur c'est la base en programmation...
char txt[]="hello"; txt est l'adresse mémoire où sont les caractère h,e,l,l,o
char *ptxt=txt ; ptxt pointe aussi sur l'adresse mémoire txt.
le pointeur c'est la base en programmation...
belhauss
Messages postés
69
Date d'inscription
dimanche 24 décembre 2006
Statut
Membre
Dernière intervention
9 février 2012
3
16 mai 2008 à 23:24
16 mai 2008 à 23:24
sa sert à quoi un pointeur ????
bah tu connais que toute fonction peut retourner une seule valeur donc si notre fonction doit retourner plusieurs valeur on la donne des adresses des valeurs et qui sont des pointeeeeeeeurs :) ;
bah tu connais que toute fonction peut retourner une seule valeur donc si notre fonction doit retourner plusieurs valeur on la donne des adresses des valeurs et qui sont des pointeeeeeeeurs :) ;
didi1203
Messages postés
20
Date d'inscription
vendredi 16 mai 2008
Statut
Membre
Dernière intervention
24 janvier 2009
16 mai 2008 à 23:55
16 mai 2008 à 23:55
--AHHHHHHHHHHHHHHHHHHH
je vous remercie tous pour votre aide jai enfain compris a quoi sa sert un pointeur als jexplique reprenner moi si j'ai faux
on utilise un pointeur si on veux renvoyer plusieurs valeurs donc si on veux faire sa on pointe sur la variables a renvoyer et ensuite il faut jouer avec les signes * et & maintenant les applaudissement.
nn je lol c'est sympa d'avoir répondu
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps
je vous remercie tous pour votre aide jai enfain compris a quoi sa sert un pointeur als jexplique reprenner moi si j'ai faux
on utilise un pointeur si on veux renvoyer plusieurs valeurs donc si on veux faire sa on pointe sur la variables a renvoyer et ensuite il faut jouer avec les signes * et & maintenant les applaudissement.
nn je lol c'est sympa d'avoir répondu
-----------------------------------------------------------------------------------------------------------------------------------------
vive le C++ et vive moi en meme temps
belhauss
Messages postés
69
Date d'inscription
dimanche 24 décembre 2006
Statut
Membre
Dernière intervention
9 février 2012
3
17 mai 2008 à 01:30
17 mai 2008 à 01:30
c'est sa loool vous êtes sympa xD ;
mamiemando
Messages postés
33084
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
29 avril 2024
7 749
17 mai 2008 à 01:57
17 mai 2008 à 01:57
Relis ce que j'ai écrit. Un pointeur c'est une variable (au même titre que tu déclares un int) qui stocke une adresse. A cette adresse il peut y avoir n'importe quoi, et donc pour s'y retrouver on "type" les pointeurs.
Si c'est l'adresse d'un int par exemple ce sera un int *.Ca peut aussi être l'adresse d'une adresse (int ** par exemple).
Quoiqu'il en soit un malloc ne fait qu'initialiser la valeur de l'adresse dans un pointeur. malloc réserve une zone de taille spécifie et retourne l'adresse d'une plage mémoire de cette taille. Dès que tu accèdes avec l'opérateur * ou [] à une zone non allouée ça plante.
Sauf traitement spécifique il est inutile d'initialiser un pointeur à NULL car si tu tentes d'accéder à *NULL ça plantera. Il faut juste initialiser ce pointeur avec l'adresse d'un objet existant (avec &), soit faire un malloc.
A chaque fois que tu fais un malloc tu es sensé faire le free correspondant quand la zone allouée n'est plus utilisée. Maintenant s'il te plaît prends le temps de lire ce que nous t'avons dit + le site du zéro + un cours. Car les questions que tu poses, on y a déjà répondu.
Bonne chance
Si c'est l'adresse d'un int par exemple ce sera un int *.Ca peut aussi être l'adresse d'une adresse (int ** par exemple).
Quoiqu'il en soit un malloc ne fait qu'initialiser la valeur de l'adresse dans un pointeur. malloc réserve une zone de taille spécifie et retourne l'adresse d'une plage mémoire de cette taille. Dès que tu accèdes avec l'opérateur * ou [] à une zone non allouée ça plante.
Sauf traitement spécifique il est inutile d'initialiser un pointeur à NULL car si tu tentes d'accéder à *NULL ça plantera. Il faut juste initialiser ce pointeur avec l'adresse d'un objet existant (avec &), soit faire un malloc.
A chaque fois que tu fais un malloc tu es sensé faire le free correspondant quand la zone allouée n'est plus utilisée. Maintenant s'il te plaît prends le temps de lire ce que nous t'avons dit + le site du zéro + un cours. Car les questions que tu poses, on y a déjà répondu.
Bonne chance
