LUT!
J'ai actuellement un bon livre sur le C++, de la ressource internet etc... et j'ai beau lire tout ce qui concerne les pointeurs, ca me parait trés jolli mais... a quoi ca sert? Quand est-ce qu'on les utilises le + souvent? Parce que j'ai bien vu des endroits ou je pouvais m'en servir mais ou ca ne changer rien et ce n'était pas plus court alors....  
Ps: je rappel que je suis débutant!!!

Hé bien, plutot que de faire un long discours, je dirais juste  que lorsque tu en auras vraiment besoin, tu le verras tout seul. Tant que tu peux t'en passer, passe toi z'en.

ok ok !!! "chaque chose en son temps"  
mici

Les listes chaînées par exemple.

qd tu en auras besoin, pense que les pointeurs intelligents existent (std::auto_ptr, boost::shared_ptr, ...)

Déjà, ça sert à créer dynamiquement des objets, ça sert au polymorphisme, ...

 
Comment achever un débutant, tome 1
laisse lui le tps, crediou

à quoi ça sert ? très simple.
 
tu me fais une fonction qui retourne le plus grand et le plus petit élément d'un tableau passé en param. tu verras bien ou est le problème
 
edit : entre autre hein, y'a pas que ça

 
Vas y Taz, défoule toi, c'était juste pour la déconne  

 
bool plusgrandpluspetit(const std::vector<int> tab, int &plusgrand, int &pluspetit);
 
un truc du genre (merci de pas me jeter des pierres)
 
y a pas de pointeurs, non ?

normal, le passage par reference permet justement de les eviter en c++, tout les exemples de passage en parametre ne valent que pour le c  il me semble

mais si je veux la plus petite valeur ou la plus grand je fais un ptit algorithme qui me les trouves,en quoi les pointeurs m'aide spécialement???

le problème, c'est que tu veux une méthode qui trouve à la fois le plus petit et le plus grand, mais qu'une méthode ne peut renvoyer qu'une seule chose...
 
La solution est donc de passer à la méthode les deux adresses où elle doit stocker le min et max, en plus d elui passer le tableau :
 
void MinMax(int s, float * tab, float * min, float * max)
{
  .......
  *min = ....
  *max = ....
}

ah oui c vrai que ca peut servir!!!

y a le passage par référence pour éviter ça Cf mon post précédent

les pointeurs ça ne sert.. à rien  
 
Mais en meme temps on peut rien faire sans eux..
 
Étonnant n'est-ce pas?

moi je vois bien un pointeur dans ton exemple

tab ?

ben oui

Ca veut dire que je progresse dans mon apprentissage alors, youpi  
 

t'as procédé par élimination. si je t'avais pas dit qu'il y en avait un, tu l'aurais pas trouvé

Même pas j'ai tout de suite regardé ce tab...  

bon ok tab c un pointeur mais bon je parlais surtt de tous les trucs avec &, * et compagnie, parce que sinon c sure les tableau je les utilises tout le temps!
et puis le fait de dire que avec les pointeurs on peut faire une fonction renvoyant plusieurs valeurs c vrai que c la meme chose avec le passage par référence!

oui. mais un référence est "une sorte de" pointeur. donc on parle plus ou moins de la même chose.
 
merci de pas troller.

ah oui ok, mais donc sinon je reformule ma question : a quoi servent les pointeurs comme int* ???
en fait je vois a quoi sa sert avec les chaines de characteres car bcp de fonctions demande la taille donc ca peut servir mais sinon
ps: ca veut dire quoi troller?

http://www.commentcamarche.net/c/cpoint.php3

Imagine que tu aies une liste d'objets du meme type, type comportant un attribut "taille" et un attribut "masse". Comment ferais-tu pour avoir deux classements de ces objets ( un selon chaque attribut ) sans pour autant dupliquer les objets?

Ca sert aussi a faire des listes chainées
Comment achever un débutant, tome 1, premier chapitre  

Ca sert aussi a faire de l'allocation dynamique de mémoire

oh il est trop bien le lien, merci jagstang!!!

je sais
 
Mais les pointeurs, c'est plus fun

 

bon, celle là je la quote, ça pourra servir de preuve plus tard, quand le C sera mort...
ils ne nous croiront jamais.

ahaha ... faut pas tout confondre. les pointeurs sont une notion fondamentale. avoir la possibilité de les faire pointer n'importe ou (ou plutot ne pas exercer de controle dessus our des raisons d'efficacité et d'implémentation) est une chose différente

Taz notre maître tout puissant, guidez-nous vers la voie de la sagesse. Amen !

 
On sera morts avant

 
parfois ce ne sont pas "des pointeurs" hein  

 
ca se voit !  
 
et ca sert partout. je vais pas prendre un objet mais une structure. disons que tu as un fichier avec des enregistrements. donc la structure est de la forme  
 
 
typedef tadresse struct {
char nom[30]:
char prenom[30]:
char adresse[100]:
// et autres informations...
...
};
 
et par exemple on a un tableau d'adresse
 
tadresse clientsRam [1024];  
 
ensuite dans une fonction tu veux passer le tableau pour faire des traitements dessus donc logiquement tu ferais  
 
int proc_client (tadresse tab) {
// et pas mal de trucs....
 
}
 
ca dépends du compilo que tu as, mais il risque de te charger toutes les 1024 adresses dans la pile. autant dire que c'est un coup à tout planter.  
 
mais alors comment on fait pour traiter notre fichier d'adresse sans bleuir l'ecran de notre client. Et bien on va prendre un pointeur sur le tableau d'adresse.  
 
don notre fonction devient  
 
int proc_client_quivamieux (tadresse *pt) {
// des trucs qui ont des chances de s'executer.
}
 
 
ce qui va se passer c'est que l'on va pas mettre directement les données dans les parametres, mais on va indiquer l'emplacement de ces données en mémoire.  
 
alors pour avoir le 3eme enregistrement il te faut avoir quoi ?  
 
et bien *(pt+2) et alors pt += 2; fait que le contenu de pt dit *pt; pointe maintenant sur le 3eme élément.  
 
 
les pointeurs ca sert à faire des liaisons entre des elements. par exemple dans des listes chainées.  
 
tu as alors  
 
typedef tligne_commande struct {
int codeproduit;  
double prix;
int qte;
 
// chainage vers la suivante
tligne_commande *pt_suivant;  
// retour vers le précédent;
tligne_commande *pt_précédent;  
// le premier
tligne_commande *pt_debut;
 
// chainage sur l'entete de la commande
// nomclient, date, codecommande.  
tentete_commande *pt_entete;
}
 
ca permet de faire des tableau de dimensions infinies ou plutot de dimensions non connues.  
 

c'est du C. merci de sortir. c'est d'ailleurs du C qui ne compile pas.

ton tableau clientsRam peut résider dans la pile ou dans le segment de données non-iniatilisé selon l'emplacement de sa déclaration. quand à ta fonction : elle passe __une__ structure par copie.

t'auras beau essayer tu n'arriveras jamais à passer un tableau par copie. cette version de ta fonction ne permet de passer en paramètre qu' __une__ structure. pour modification ou paramètre de sortie. pour passer un tableau, il faut un paramètre additionnel 'size_t n' qui est le nombre d'éléments du tableau.
 
ce qui va se passer c'est que l'on va pas mettre directement les données dans les parametres, mais on va indiquer l'emplacement de ces données en mémoire.  

tu t'es déjà assez enfoncé comme ça, pas la peine de faire le warrior des pointeurs. pt[2] est très bien.
 

rien à voir. c'est à cause de la nature dynamique de la liste

encore du mauvais C

une lioste n'est pas un tableau.

Non mais lol!!!
bon donc apparement ca devient plutot obligatoire avec les listes chainés, donc quand j y serai je les utiliserais!!!cool!