Les pointeurs, aie aie...

Salut !
Comme promis, je refais un p'tit topic sur les pointeurs, parce que la confusion règne ! J'ai compris la base de chez base pour les pointeurs, mais dans certains cas, je pige plus rien... Bon, par exemple, ca :

Code:

int *p = a;

Ca va faire quoi ? Erreur ? Contenir adresse de a ? Contenir valeur de a ?
et ça :

Code:

int *p =&a;
p++
cout <<*p <<endl;  // ???? Affiche 2293680
cout << p <<endl ;

Quand j'incrémente un pointeur, qu'est-ce-qui s'incrément ? La valeur sur le quoi il pointe, ou l'adresse ? Est-ce-que le fragment de code que j'ai mis plus haut est egale à ca :

Code:

int *p =&a;
*p++ // ici le changement, j'ai rajouté l'étoile
cout <<*p <<endl;  // ???? Affiche 2293680
cout << p <<endl ;

(J'ai rajouté l'étoile). Alors, ca va changé qq chose ?

Si tu pouvais répondre correctement à toutes mes questions, ca m'éclerait. Parce que j'ai une "étude" des fragmentés sur les pointeurs, je sais plus quoi pensé ! Je reviendrai surement apporter de nouvelles questions et fragments de codes... J'espère que tu apporteras tes réponses !

PS : En faite, c'est utile que j'apprenne les pointeurs au moins (en c++). Parce que, j'ai pas trop l'impresion que ca me sert pour le moment !

Merci d'avance !

Les pointeurs sont toujours utiles un moment ou un autre
Comme tu l'as remarqué (ou le remarquera), SDL par exemple manipule des pointeurs vers des SDL_Surface.
Bref

Alors soyons clair sur ton exemple, tu n'as pas défini a (ou alors tu ne l'as pas mis)
Disons que je pose, avant ce que tu as mis :

Code:

int a = 5;

Je te conseille d'initialiser a ! si tu ne le fais pas, il peut avoir n'importe quelle valeur (y compris 2293680)

Un peu comme si tu fais :

Code:

int a;
cout << a << endl;

qu'est ce que ça te donne ? si le compilo est gentil, ça te donne 0, mais ce n'est pas garanti, et si tu compiles en release (pour aller vite), alors la, attends toi a avoir un nombre exotique !

Bref, reprenons :

Code:

int *p = a;

A priori, le compilateur va gueuler (certains vont refuser catégoriquement de compiler : tu assignes un pointeur a un int).
Si le compilo est gentil (...), il va prendre la valeur du int comme adresse. Autrement dit, si le a vaut 5, il va mettre 5 dans le pointeur, donc le pointeur pointera sur l'adresse 5.
Mais en tous les cas, je te déconseille cette écriture : ne donne pas de int a un pointeur.

Ensuite :

Code:

int *p =&a;
p++;
cout <<*p <<endl;
cout << p <<endl ;

c'est correct, le pointeur p pointe sur l'adresse de a.
Donc la ligne cout << *p te donnera 5
(car j'ai initialisé a à 5 ! si tu n'as pas initialisé a, alors tu peux avoir une valeur exotique en effet)
la ligne cout << p va te donner un nombre a dormir dehors : c'est l'adresse de a : l'endroit en mémoire ou a est gardé

le p++ va décaler le pointeur vers la droite !
C'est a dire que si tu fais :

Code:

int t[5];  // garantie 5 int contigus en mémoire
t[0] = 3;
t[1] = 17;
int* p = &t[0];
cout << *p << endl;  // te donne 3 (car t[0] vaut 3)
p++; // décale d'un int vers la droite, et le int a droite de t[0], c'est t[1]
cout << *p << endl;  // te donne 17 (car t[0] vaut 3)

Enfin, pour ton dernier bout de code :
le :

Code:

*p++;

Je te déconseille cette écriture.
Tout d'abord, il me faut un petit temps pour trouver ce que ça fait ! Et sache que nombreux programmeur ne le savent pas ! C'est ambigu, et bien que reconnu par la norme, cette écriture est faite pour emmerder ceux qui vont te relire

Je te conseille vivement donc de faire :

Code:

*(p++);

ou

Code:

(*p)++;

voir meme de décomposer ça en plusieurs lignes

note : comme tu mets *p tout seul sur une ligne, la valeur renvoyée n'est pas utilisée.
Elle le serait si tu mettais :

Code:

int a = *p;

Mille fois merci ! Voilà qui m'éclaire quelque peu !
C'est quand même vachement complexe les pointeurs

complexe... hum !

Je n'emploierai pas ce mot, je dirais que seuls peuvent les utiliser les gens rigoureux : une erreur et le plantage est presque assuré.

Mais d'un autre coté, c'est extremement puissant et surtout tres tres rapide (tous les langages qui camouflent les pointeurs voir amputent les pointeurs (Java par exemple) peuvent subir un contrecoup de performance en sortie...)

En faite, je me suis renseigné via un bouquin, et

Code:

cout <<*p++

correspond à

Code:

cout <<*p;
p++

Et dis moi, tu disais que int *p = a; n'est pas bon (en admettant que a est déclaré), est-ce-que ce bout de code l'est ?

Code:

int a[30];
int* p = a;

Ca change qq chose si c'est un tableau ?
Merci d'avance !

*p++ correspond a *p, puis p++, il est vrai
cependant, moi je te conseille, pour des soucis de clarté, de l'écrire en 2 lignes

Code:

int a[30];
int* p = a;

Ce code marchera : le compilateur saura faire. (ça dépend des cas : des fois tu te prendra un "cannot convert int [] en int* "

mon conseil est d'éviter aussi et de mettre plutot :

Code:

int a[30];
int* p = &a[0];

Désolé pour mon temps de réponse ^^
Merci beaucoup pour l'aide fournie ! Maintenant, je comprends vachement mieux les pointeurs (me suis un peu documenté aussi ^^) !

Aller, je me met à SDL, fini la catégorie débutant en C++ ^^...

++

je sais pas si je vais dire une connerie mais tu peux comparer les pointeurs a des raccourcis bureaux par exemple

Bonjour,

J' aimerais avoir des renseignement sur le pointeur FILE* car je le pije pas le moins du monde.

merci d' avance,

++

countag > on peut comparer un pointeur a un raccourci : tout a fait
également a un lien internet si tu veux

En gros, c'est une petite information qui te montre un autre endroit
un raccourci te montre le programme
un lien internet te montre un site

sn00bino > un pointeur FILE* est un pointeur qui pointe sur FILE : c'est a dire une structure identificateur de fichier.
Dedans, tu as plein d'infos : le nom du fichier, sa taille, la position du "curseur" de lecture, etc etc !

Un FILE* te permet d'accéder a un fichier sur disque, tout simplement !

Pour appuyer un peu plus la remarque de FVIRTMAN, effectuer un clic droit sur un lien et faire "enregistrer la cible sous" c'est exactement comme faire

int a = *p;

par exemple !

Ok merci.