Les pointeurs : aie aie !

Salut !
Je fais 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 :


int *p = a;



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


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 :



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 vous pouviez 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 vous apporterez vos 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 ! (Et si vous conaissez une bon p'tit lien pour me remettre les idées en place, pas de refus non plus)

Salut
int *p = a; // tout dépend de ce qu'est a. Si a est un int* pas de problème si a est un int je doute que ça marche.

par contre int *p=&a marchera si a est un int car tu passe dans ce cas l'adresse mémoire de a.
En fait p pointera vers la meme case que a. Donc si tu delete a il risque d'y avoir des problèmes p sera vide. Car en fait quand tu accedera à p su accedera à la case pointé par p et tu regardera le contenu de cette case.

pour p++ je sais pas désolé, mais je pense que ça risque de bugguer.

quand tu rajoutte l'etoile *p++ tu increment le contenu de la case pointée par p.

Les pointeurs sont utiles car tu peuxfaire des tableaux, alloués et supprimer quand tu le décides. Je te conseille de les apprendre. Par contre c'est source d'erreurs d'allocation ou de suppression...

donc en résumé.
En statique
int a = 3; // tu affecte 3 dans la case
cout<<a; // tu affiche la valeur
cout<<&a; //tu affiche l'adresse de a (en héxadécimal)

en dynamique (pointeurs)
int *a; //a est alors à NULL.
a = new int[];
*a=3;
cout<<*a;//affichera 3
cout<<a, // affichera l'adresse
delete a; //vide a.

pour un tableau
 int *a;
a = new int [3]; //tableau de 3 cases
a[0]=2; // tu met la valeur 2 dans la case 1 du tableau , début a 0 !!!!!!!
...
au passage un tableau à l'adresse de sa premiere case
pour le supprimer delete [] a;

voila j'espère que tu me comprends
si t'as d'autres questions n'hesite pas







 

Bon pour commencer...

int *p = a;

ça dépend de la déclaration de a si c'est un pointeur ok sinon probleme...

Ensuite p++ va incrémenter l'adresse mais pas de n'importe quel maniere ! De maniere a ce que p pointe sur le prochain élement. autrement dit si il sera incrémenter de sizeof(int) dans ce cas-ci. Et c'est bien entendu différent de *p++.

Et puis les pointeurs c'est très utile et pas juste en C++. Tient betement pour transmettre un tableau a une fonction par exemple. Dans la fonction c'est beaucoup plus simple de jouer avec le tableau via des pointeurs. Dans certain cas c'est même indispensable. Et puis c'est pas que c'est fort compliquer.

XbY

moi je te conseil ce cours de c++ qui je pense repondra a tes questions
c'est une version au format html qui est plus simple pour la navigation

http://casteyde.christian.free.fr/cpp/cours/cours_cpp-1.40.6-html.zip

alors les pointeurs sont tres utile ca evite de devoir passer des variables en parametre
je m'explique par exemple un fonction toute bete
prototype
 int mafonction( int a,int b)
{
    return (a + b);
}

mafonction( 5, 6); va renvoyer 11

 dans ce cas quand tu fais appelle a ta fonction elle creer 2 int a et b  et les met en memoire jusqu a la fin de l'execution de ta fonction pour etre detruit

maintenant avec des pointeurs

int mafonction( int* a,int* b)
{
    return (*a + *b);
}

int c=7,d=8;
mafonction(&c,&d)  va renvoyer 15

dans cette fonction les parametre sont des pointeurs donc quand tu fais appelle a ta fonction tu passe une adresse et non une variable donc la fonction ne recreer pas de variable tu ne satureras pas la memoire.

en gros ca marche comme ca mais desfois tu n'as pas le choix d'utiliser les pointeurs
par exemple quand tu creer une classe en c++ où un attribut est un objet ;

par exemple une class A qui contient une class B
si le contructeur de la classe B a des parametres alors dans ta classe A ton attribut sera forcement un pointeur vers la classe B car en c++ tu ne peux pas initialiser de variable dans ton fichier.h
class B
{
     char* nom;// et oui les chaines de caractere sont des pointeurs
     B(char* name);// contructeur de la class B
};
class A
{
    B *mon_nom;// ici tu ne peux pas faire B mon_nom("alucard") car tu ne peux pas initialiser d'objet dans un .h
};

bref lit le cours de c++ que j'ai mis en lien ca te servira
@++
Tous les chemins mènent au RHUM !!!!!!!!!!!!!!!!!!!..............................

Aie aie aie...

"dans cette fonction les parametre sont des pointeurs donc quand tu fais appelle a ta fonction tu passe une adresse et non une variable donc la fonction ne recreer pas de variable tu ne satureras pas la memoire."

Non !!! D'abord que ce soit dans un cas ou dans l'autre la fonction ne crée pas de variable. Les paramètre sont mis sur la pile et avant l'appel de fonction et celle-ci les exploites. Et pour aller encore plus loin si tu met les pointeurs en paramètre la fonction va devoir les déreference (c a d aller chercher la valeur de la variable a l'adresse indiqué par le pointeur) ce qui fait 2 accès mémoire en plus. Donc au final tu as une fonction plus lente.

De plus c'est une possibilité de bug en plus... En effet la fonction peut modifier la valeur de la variable ce qui peut-être indésirable. (c'est un peu contraire au principe de la POO)

Si tu veux réellement un code plus rapide tu as 2 possibilité :
- Tu met ta fonction inline (c'est tres utiles pour de petites fonction mais plus la fonction grossi plus le gain est négligeable et plus l'executable final sera gros)
- Tu met tes parametres dans des registres (Convient très bien pour des fonctions qui n'ont pas beaucoup de variable interne)

XbY

Pour éviter les longs discours, je te renvoie a cette adresse ou il y a un cours simple et très complet sur les pointeurs :

[ Lien ]

Shell