Aide C++ pointeur
Résolu
Bonjour,silvouplait aidez moi je suis un jeune apreuneur de C++ mais malheureusement je me bloque sur un chapitre qui s'appele les pointeurs.le probleme c'est a quoi sa sert et comment sa marche
J'apprends le C++ depuis se site https://openclassrooms.com/fr/courses
je vous le demande aidez moi
J'apprends le C++ depuis se site https://openclassrooms.com/fr/courses
je vous le demande aidez moi
A voir également:
- Aide C++ pointeur
- Pointeur souris - Guide
- Curseur Windows 10 : comment bien voir la souris à l'écran - Guide
- Le pointeur de mon pc portable ne marche plus - Guide
- Pointeur laser publicitaire ✓ - Forum Loisirs / Divertissements
- Pointeur souris avec rond de chargement qui clignote sans arrêts ✓ - Forum Windows
10 réponses
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
--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
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)
++
--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
--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
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...
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 :) ;
--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
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
