Version imprimable
Bonjour, j'apprend la programmation en autodidacte et j'ai pas mal de difficultés avec les pointeurs de C/C++, si j'avais appris un de ces 2 langages en 1er je m'y serais surement fais à la longue... Mais voilà c'est java que je pratique depuis 1 an!:roll:
Je souhaiterai savoir si il est indispensable de maîtriser les pointers pour faire du C++ ou si dans un premier temps on peut s'en passer, voir ne jamais les utiliser ?
euhh... en java tu arrives à te passer de pointeurs complètement ?
Pour répondre directement : oui, tu peux *dasn un premier temps* te passer des pointeurs. Mais ce serait comme acheter une voiture de course pour rouler toujours à 10 km/h ....
Les pointeurs permettent des manipulations assez complexes et qui seraient très lourdes autrement (voire impossible je pense pour certaines).
Ex : tu as un objet instancié. Avec des méthodes, des propriétés, des données internes, etc... Si tu as besoin de le manipuler, de le passer à des fonctions en paramètre, etc... c'est bien plus agréable d'avoir un pointeur vers cet objet (simple variable numérique, très petite), que de manipuler une copie complète de l'objet à chaque fois.
De plus, c'est le seul moyen d'allouer dynamiquement de la mémoire ! Or il arrive quand meme fréquemment en programmation que tu ne saches pas forcément combien (ni quoi) créer pendant la compilation.
"les pointeurs", y'a que le nom qui fait peur une fois que tu as compris comment cela foctionne le code s'ecrit tout seul ...enfin presque;)
http://cpp.developpez.com/cours/polyCpp/
et au pire tu est sur le bon site si tu as des doutes ou des questions, c'est ici que je resout la majorité de mes petits soucis.
En utilisant les structures qui vont bien (std::vector<>, std::string, boost::shared_ptr<>), tu peux les masquer en grande partie.
Mais seulement en C++, pas en C.
C'est vrai qu'en java, la notion de pointeur n'existe pas. Par contre, la notion de référence existe et une référence n'est jamais qu'un pointeur qui se déguise un peu.
Je pense que dans un premier temps, on peu s'en passer mais que très vite, on se rend compte que c'est utile pour réaliser des choses un peu plus puissantes.
En fait mon plus gros soucis est que j'ai tendance à faire du C++ avec les règle du java.
exemple :je me limite par habitude à la transmission par valeur pour les types de bases (comme avec java) alors que je pourrais aussi le faire par référence !
En fait peut on faire du C++ avec les règles de Java?
Il ya a certains passages par valeurs qui coûtent très cher car il faut créer/copier un nouvel objet sur la pile avec appel des constructeur de copie et des destructeurs en final sans compter la place inutile occupée sur la pile.
Par principe, dès que je sais qu'un objet fait plus de 4 octets (c'est donc un objet relativement complexe à construire), j'essaie de la passer par référence constante.
Je ne parlerais que pour le C++.
Pour moi la réponse est mitigé.
On peut si on utilise de bon outils dès le début, s'en sortir sans trop (rien ?) connaitre aux pointeurs.
Mais il y un moment où malgré nes outils, les pointeurs sont une obligation.
Oui mais il faut comprendre les différences : Java par défaut c'est du passage par référence sauf si la fonction modifie l'objet alors se sera automatiquement par valeur. À moins bien sur que le paramètre ai été explicitement déclaré en référence bien sur*.Citation:
Envoyé par kayzra
Java fait ce genre d'optimisation automatiquement : pas C++.
En C++ on doit toujours explicitement passer nos objets en référence constantes (C'est une bonne habitude). Sauf en cas de manipulation des valeurs dans l'environnement local -> passage par valeur et de manipulation de l'objet dans l'environnement extérieur -> passage par référence.
Le seul moment où les pointeurs doivent être utilisés c'est pour la création, la conservation et l'utilisation de mémoire réservée dynamiquement... Ensuite les fonctions appelées peuvent utiliser des références constantes sur l'objet. Tant qu'on conserve l'adresse à un endroit logique pour pouvoir la libérer. En plus, c'est sécuritaire à l'utilisation.
Dès qu'on parle de quelque chose instancié ou utilisé dynamiquement on a besoin des pointeurs (ex. polymorphisme)
Merci pour toute vos réponses elles m'éclairent beaucoup sur les principes du C++ comparais à java. :ccool:
j'aurais une autre question, C++ étant plus souple au sens des règles d'écritures et à de la possibilité d'atteindre beaucoup + facilement le système qu'avec une machine virtuelle, y a -t-il des règles de base à respecter ou des choses à éviter ?:roll:
Quoi ?Citation:
Envoyé par MatteX
Java ne connait qu'un seul passage de paramètre, c'est par valeur -- ecrivez donc un swap en Java.
Le truc est que les références sont passées par valeur. Les références du java sont des sortes de super-pointeur, alors que celles du C++ ne sont que des alias.
Bref, en Java, c'est exactement comme en C, pour les passages de paramètres.
(Bon, maintenant, des choses ont pu changer depuis Java 5, j'ai moins bien suivi)
Sinon, oui, il y a énormément de choses à savoir. En faire la liste ... là, comme ça ? Non.
Commence par jeter un oeil à la FAQ, puis aux (More) Effective C++ et (More) eXceptional C++ (www.gotw.ca/gotw/). Quand tu auras assimilé tout cela, cela sera déjà pas mal.
Salut,
Pour répondre à ta première question, je dirais que, si tu décide d'utiliser les classes de la S(T)L telles que les std::string ou les std::vector en codant "à la manière C" (comprend: en considérant tous les types personnalisés comme étant des structure de données, sans intention de travailler en "orienté objet"), il y a de fortes chances que tu n'aie pour ainsi dire jamais besoin des pointeurs.
Seulement, le revers de la médaille, c'est que du même coup, tu vas passer à côté de toutes les capacités fournies par les langages orienté objets, dont, entre autres, tout ce qui peut avoir trait à l'utilisation d'objets polymorphes.
En effet, l'utilisation d'objet polymorphes est le domaine par excellence dans lequel tu auras besoin de pointeurs.
Et comme on peut estimer qu'après avoir développé pendant un an en java, il y a de fortes chances pour que tu te sois habitué au confort que représente la POO... il est à craindre que cette approche restrictive du C++ ne te laisse vraiment sur ta faim :P
Par contre, il est fort vraisemblable que tu puisse le plus souvent te passer de tout ce qui est "arithmétique des pointeurs", car, sous réserve d'utiliser les classes de la S(T)L ou d'autres bibliothèques "classiques" (telles que boost, par exemple), tu pourra te contenter de l'allocation dynamique pour un seul élément polymorhpe sous une forme proche de
voir, pourquoi pas d'unCode:Personnage *lui=new Marsien();
et, la seule chose à laquelle il te faudra songer, ce sera de libérer toi-même cette mémoire avant de perdre toute trace de l'endroit où elle se trouve. (autrement dit: de sortir de la portée de lui, ou, pour le deuxième exemple, au plus tard dans le destructeur de la classe à laquelle appartient tab).Code:
2
3
Et puis, finalement, à bien y réfléchir, il est aussi fortement probable que, si tu éprouve du mal avec les pointeurs, c'est sans doute que tu n'as jamais trouvé le texte, ou la manière de t'expliquer qui t'aurais permis de "percuter" dessus...
Personnellement, j'ai eu "l'illumination" qui m'a permis de tout comprendre "d'un seul coup" sur les pointeurs en relisant pour la énieme fois mon cours dans le train, le jour où je présentais mon examen... de C sur les pointeurs :P
Pour répondre à la deuxième question, comme on peut considérer que tu as déjà un bagage certain en POO, il n'y aura vraisemblablement qu'une série d'ajustements à effectuer, certains importants, d'autres beaucoup moins, et quelques horizons à explorer ;)
Bon sang mais c'est quoi toutes ces bétises que j'entends sur le Java???
En Java tout est passé par réfèrence, mais cela n'a rien à voir avec les réfèrences du C++, il s'agit de réfèrences au sens d'un garbage collector. On peut donc considérer qu'une variable xxx en Java est l'équivalent d'un shared_ptr<xxx> en C++ (moins le problème des réfèrences cycliques). Néanmoins gardez à l'esprit que, bien qu'il soit utilisé par le Java et plusieurs autres langages très connus, le comptage de réfèrence n'est pas l'unique moyen d'implémenter un garbage collector.
Ca c'est à n'y rien comprendre, tu confonds peut-être avec les objets non mutables? En tout cas ça n'a rien à voir.Citation:
Envoyé par MatteX
Le seul cas où le Java utilise du passage par valeur, c'est pour les types de base. Et encore, il existe des alias objet pour tous ces types au cas où on aurait besoin d'utiliser le même mode de fonctionnement que pour les objets.
Que nenni.
Par référence tu disais ....? Pourquoi cela ne marche pas alors ?Code:
2
3
4
5
6
7
Tout, et absolument tout, est passé par valeur en Java. Parce que la référence est un type au même titre que les pointeurs en C. Les pointeurs sont passés par valeur en C, les références sont passées par valeur en Java. C'est tout.
dans mes projets C++ je le résume comme ça:
1) Pas de pointeurs
( pour une donnée membre par exemple, pas besoin de faire un new dans le constructeur et un delete dans le destructeur quand tout peut être géré automatiquement )
2) Utiliser les références ( passage de paramètres etc.. )
3) Si vraiment on doit utiliser les pointeurs ( polymorphisme, etc.. ):
utiliser des smart pointers ( boost::shared_ptr )
( évidemment il y a toujours des cas où tu as besoin de pointeurs à bas niveau, ce n'est pas rigide )
La difficulté de parler du passage d'argument en Java quand on vient du C++ vient pour moi (qui ne m'y connais pas vraiment en Java) du fait que Java mélange deux concepts : Le pointeur, et l'objet pointé.
Quand on passe un argument de fonction, on passe le pointeur par copie (donc d'une certaine manière, on passe l'objet pointé par référence).
Quand on appelle une fonction membre, c'est l'objet pointé qui est concerné.
Quand on appelle l'opérateur =, c'est le pointeur et non pas l'objet pointé qui est concerné.
Donc, un swap en Java s'écrirait :
Code:
2
3
4
5
6
En effet, ce que Java appelle "référence" n'a rien à voir avec le passage par référence.
En .Net, on a les deux:
- On a la distinction entre type valeur et type référence:
- Un type valeur est comme les types primitifs de Java, comme int ou float (mais en .Net, on peut créer de nouveaux types valeur, ce qui est impossible en Java).
- Un type référence est comme les classes de Java: On ne peut le créer que sur le tas (avec new), et on ne peut le manipuler que par des "références", d'où le nom.
- Et on a aussi le passage de paramètres par référence, comme en C# avec les mots-clé ref et out.
En C#, la signification d'une variable d'un certain type dépend selon que ce soit un type valeur ou un type référence:
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
La distinction se voit mieux en C++/CLI, où les "références" .net sont appelées "handles managés" (à ne pas confondre avec les HANDLE de Windows: On manque de mots, donc on se retrouve à les réutiliser)
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Avec les bons outils, tu n'en as jamais besoin. (Et c'est même bien de les éviter)Citation:
Je souhaiterai savoir si il est indispensable de maîtriser les pointers pour faire du C++ ou si dans un premier temps on peut s'en passer, voir ne jamais les utiliser ?
Loufoque >> Je suis d'accord avec toi. Avec de bon outils, on peut s'en passer . Mais il faut au moins les connaitres car si on doit maintenir un code qui en utilise, on est dans la loose :D
Qu'est ce que vous appelez "les bon outils", un IDE?:roll:
Salut,
Pour moi les bons outils c'est plus ce qu'on appelle 'pointeurs intelligents' (std::auto_ptr et boost::shared_ptr en tête).Citation:
Envoyé par kayzra
Il ne faut jamais manipuler des pointeurs à mains nues en C++, c'est bien trop dangereux !
MAT.
Boost te fournit un nombre concéquent d'outils très bien fait pour éviter de manipuler des pointeurs. Je te le laisse de te documenter.
Je dirais qu'il faut savoir ce que l'on fait. Si on sait ce que l'on fait il n'y aucun problème.Après pour un novice, oui ca peut faire très mal.Citation:
il ne faut jamais manipuler des pointeurs à mains nues en C++, c'est bien trop dangereux !
Oula, ce que tu es en train de dire c'est que les réfèrences GC-style sont passées par valeur et non pas par réfèrence C++-style (ou VB-style, ou PL/SQL-style,...). En ce sens je ne peux que te dire que tu as raison. Mais c'est dévier dangereusement du contexte, et la forme tend à favoriser l'incompréhension.Citation:
Envoyé par Luc Hermitte
Il n'est pas question de passer des réfèrences en argument en Java, on passe des objets en argument (et, en l'occurence, par réfèrence).
Sinon, pour en revenir un peu au sujet initial, je dirais qu'il est nécessaire de connaitre le fonctionnement des pointeurs en C++. Vraiment. Néanmoins, aussi étrange que ça puisse paraitre, il faut les connaitre pour ne jamais avoir à les utiliser en pratique (smart pointers powaa!).
Je suis contre cette formulation: On ne manipule jamais directement un objet en java, uniquement des références d'objet, et ce, par valeur.
La preuve, c'est un objet ne peut jamais contenir un autre objet non plus: Il ne peut contenir qu'une référence vers cet objet.
Comme je l'ai dit plus tôt, le problème est qu'on manque de mots, et qu'on utilise deux mots (pointeur, référence) pour désigner trois choses (pointeur, passage par référence, et "référence GC") (ou trois mots pour désigner quatre choses, en .Net).
Le fait est qu'en Java on est tellement habitué à ce mode de fonctionnement systèmatique qu'on dira bien souvent qu'un objet en contient un autre même si c'est bien entendu impossible. Autre langage, autre jargon.Citation:
Envoyé par Médinoc
Je ne crois pas que ce soit très sain d'essayer de comparer le C++, langage avec des outils de haut niveau mais avec un mode de fonctionnement de bas niveau, et un quelconque langage de haut niveau, le raisonnement n'est pas le même. Autant en C++ les pros vont parfois pratiquement jusqu'à compiler un programme dans leur tête pour voir ce que ça fait en assembleur, autant dans la plupart des langages pur objet on se concentre presque uniquement sur l'aspect conceptuel.
1/ J'ai du mal a voir comment me passer de pointeurs en C++ sans utiliser une definition tres restrictive de ceux-ci (la mienne est "designateur d'objet non necessairement nomme"). Oui, on peut les cacher plus ou moins dans des classes, mais ces classes sont tres rarement plus que des habillages enforcant une politique de gestion des pointeur donnees.
2/ Dans la meme veine, je ne vois pas de difference conceptuelles fondamentales entre les references de Java et les pointeurs de C++. Il y a quelques details, mais rien d'important.
Reprennons.
Il y a deux formes de passage d'arguments :
- "par valeur" où on manipule généralement un copie de l'expression reçue : en général on ne spécifie pas grand chose (excepté le [in] en Ada),
- "par adresse" ou "par référence" où l'on manipule directement la variable reçue : là, il y a un petit truc en plus dans les langages qui le supportent : "var" en Pascal, "[out]/[inout] en Ada", "&" en C++. C qui émule cela en passant des pointeurs par valeur n'a jamais eu (que je sache) la prétention de supporter le passage de paramètres par adresse/référence.
(tout ça pour dire que mon point de départ n'est pas le C++, mais bien les langage pas de bas niveau que sont le Pascal et l'Ada)
Dans le second cas, le compilo s'occupe pour nous de donner un accès modifiant à la variable réellement passée en paramètre.
Quoiqu'on en dise en Java, la variable est la référence et non l'objet -- sans, c'est dans les specs java! je n'inventre rien. Dans le cas contraire, on n'aurait pas eu l'affectation qui permet de les réattacher.
Le fait que Java utilise "référence" pour désigner un élément du langage me semble entretenir la confusion.
Et puis bon, c'est pas comme si je contredisais Sun après tout ...
http://java.sun.com/docs/books/tutor...arguments.html :P (Ils en parlaient aussi, en clair, dans la spec du langage, mais je n'ai pas retrouvé où)
s/deux/au moins quatre/Citation:
Envoyé par Luc Hermitte
- par valeur/resultat, en gros une combinaison d'un passage par valeur et de resultat de fonction. Peut aussi s'emuler en C++ avecCitation:
- "par valeur" où on manipule généralement un copie de l'expression reçue : en général on ne spécifie pas grand chose (excepté le [in] en Ada),
- "par adresse" ou "par référence" où l'on manipule directement la variable reçue :
C'est courant en Ada pour certains types (entier par exemple) passe par in out ou par out (auquel cas, la partie initialisation de pi n'existe meme pas). Ada garanti le passage par reference de certains autres types (limited, tagged si j'ai bonne memoire).Code:
2
3
4
5
- par nom cher a Algol... ca correspond a passer une fonction qui evalue l'argument (et qui retourne une reference si possible) Voir http://en.wikipedia.org/wiki/Jensen%27s_Device pour un exemple.
J'ai bien spécifié qu'on parlait de réfèrence non pas en Java mais dans tout ce qui concerne les garbages collectors. Et de quand date le premier garbage collector? Approximativement 1958, année d'invention du lisp si je ne me trompe. De toutes façon, la définition exacte d'une réfèrence serait plutot "n'importe quoi qui pointe sur une donnée", dixit wikipedia http://en.wikipedia.org/wiki/Referen...mputer_science). En ce sens les pointeurs sont aussi des réfèrences.Citation:
Envoyé par Luc Hermitte
Et non je n'en démordais pas, déclarer qu'on passe des réfèrence (gc-style) par valeur en Java est aussi futile que de dire qu'on passe des réfèrence (C++-style) par valeur en C++, vu que celles-ci ne sont jamais que des pointeurs immuables (sauf optims d'inlining etc...). Rien de tout cela n'est faux mais ça n'a tout simplement aucun interet, ce qui nous interresse c'est le mode de transfert des données utiles: les objets.
Pas d'intérêt hum ... jusqu'au jour où l'on en a besoin sur le type officiel selon la terminologie java (cf spec), i.e. les object references.
Parfois l'objet n'est pas toujours la donnée utile, cf les contournements nécessaires qui doivent être opérés: http://javadude.com/articles/passbyvalue.htm
?? La disgression part de l'assertion "Le seul cas où le Java utilise du passage par valeur, c'est pour les types de base" qui est fausse.Citation:
J'ai bien spécifié qu'on parlait de réfèrence non pas en Java mais dans tout ce qui concerne les garbages collectors
Si on commence à changer les contextes, on ne va pas s'en sortir: "un passage par référence" n'a aucun rapport direct avec "une référence-gc". Soit, parlons de "passage par adresse" et de "handle-gc", cela ne changera rien à la situation -> Java ne supporte que le passage par valeur, et émule plus ou moins facilement le passage par adresse.
qui n'a aucun sens : ce ne sont pas des vraies variables, mais des alias ou des pointeurs dans le contexte de variables, et exactement la même chose que les paramètres var du Pascal dans le cas des paramètres vu que ce qui est passé en paramètre est une variable.Citation:
est aussi futile que de dire qu'on passe des réfèrence (C++-style) par valeur en C++
C'est difficilement comparable au type object reference du Java.
(Mais j'accorde la phrase (au "futile" près) en remplaçant "référence" par "pointeur", et "C++" par "C")
J'aurais peut être une autre question sur C++, je voudrais savoir si il existe un équivalent à la documentation java pour la SL & STL C++ ?
Disons que c'est éparpillé : chaque fournisseur de SL a sa propre doc.
Regarde dans la FAQ, les meilleurs liens y sont donnés.
http://www.sgi.com/tech/stl/ mais c'est pas du tout didactique.Citation:
Envoyé par kayzra
Regarde sur le site y'a des tutos.
Pour en revenir à la question initiale c'est un peu difficile de se passer des pointeurs,y'a des fonctions comme celles systèmes et notamment win32 qui utilisent des pointeurs.
Si tu travailles sur un projet avec Visual C++ par exemple tu seras obligé d'en gérer.
Je ne parlerais pas des choses atroces comme C.O.M. :mouarf::mrgreen:
Si tu veux avoir des cauchemars, documentes-toi sur COM mais COM est plutot réservé aux personnes ayant une bonne maitrise de C++ :mrgreen:
il y a aussi www.cppreference.com
Tu sais, on peut aussi utiliser des Smart Pointers avec COM, hein...Citation:
Envoyé par Mat.M
Même si ceux fournis par Microsoft nécessitent ATL, il est assez facile de se faire sa propre version.
Par contre, si l'on veut développer un composant COM au lieu d'un simple client, les choses se compliquent... :mouarf:
Essayez Corba. COM, c'est le paradis à côté.
Je ne savais pas que pratiquer les pointers avec C++ ça pouvait rendre sadomasochiste :lol: si j'y prend goût, j'essaierai Corba et C.O.M, :aie:
Mais là, je rame avec les bases du langage. J'ai remarqué suite à une erreur que l'on pouvait faire en C++ des trucs dont je ne vois pas à mon niveau l'intérêt immédiat mais ça viendra surement : exemple :
Pour moi le fait de pouvoir utiliser l'opérateur d'affectation ici est et sera une source d'erreur possible et surtout je ne voit pas encore l'intérêt d'un if sans condition explicite , ou traduit par si x non null . Sans parler non plus des conversions implicites, Le C++ est quand même extrêmement permissif et parfois peut lisible , c'est ce qui en fait peut être sa complexité ?Code:
2
C'est un problème hérité du C qui possède quelques cas d'applications pseudo-utiles (quand pas proscrit par les règles qualité de sa société)
Il y a quelques moyens de s'en préserver:
- customiser son éditeur de texte pour qu'il révèle ce genre d'erreurs d'innattention (j'ai ça sous le coude pour les vimmers)
- ne jamais oublier de flagger une variable immuable comme telle (-> "const") quand on sait qu'elle n'est pas sensée évoluer après sa construction ; et autres exploitations de "const"
- Profiter de son compilo qui sait prévenir quand il voit de tels abus -- cela dépend des compilos
- Passer des outils d'analyse statique de code qui savent reconnaitre ce genre de choses.
Les conversions implicites, c'est encore autre chose. Et pareil, il y a des choses à savoir pour nos types à nous (-> explicit, opérateurs de conversion, ...)
Et ... ce n'est pas ça qui fait la complexité du langage. Cela y participe, mais assez peu AMHA.
Kayzra, pour répondre à tes questions successives:
- ne t'inquiètes pas trop pour les pointeurs. Leur principe est utile, leur utilisation brute est un peu dangereuse, mais de nombreux outils existent pour les utiliser sans risque (les fameux "habillages enforcant une politique de gestion des pointeur donnees." de Jean-Marc.Bourguet). Hélas, ces outils ne sont pas franchement plus abordables pour les débutants que les pointeurs bruts. Donc, dans un premier temps, un bon conseil est de ne pas utiliser new ou delete. Les conteneurs de la STL sont très efficaces pour la plupart des besoins. Ensuite: passer aux classes qui gèrent leur mémoire à titre d'exercice, avec new/delete en constructeur / destructeur, gestion des opérateurs de copie et d'affectation. Bien identifier les pièges, puis ensuite passer à des librairies pas forcément faciles à appréhender comme Boost, pour utiliser leurs outils de gestion de pointeurs. Au bout de quelques années de pratique, tu auras un new ou delete toutes les 10k lignes au pire.
- les outils de gestion des pointeurs sont les classes d'aide (l'IDE n'aide pas...). Malheureusement, std::auto_ptr n'est pas une très bonne classe pour bien encapsuler les pointeurs dans le cas général, car il y a une sémantique de déplacement lors des affectations. Boost propose des choses bien plus intéressantes, mais est aussi bien plus difficile à appréhender. Je pense qu'il vaut mieux être déjà assez familier avec le langage avant de se cogner Boost. Donc si le besoin de pointeur est du à l'héritage, il n'y a pas de moyen à la fois simple et sûr, il faut bien s'attaquer plus ou moins de front aux pointeurs. En revanche, pour ce qui est de la gestion de mémoire des conteneurs, la STL est à la fois bien plus sûre que l'utilisation directe de pointeurs, tout en restant assez simple à utiliser.
- La documentation de la STL est honteuse dans les compilateurs Codegear (un simple manuel de référence abscons sans exemple) et même Visual Studio (lien cassés, exemple miteux, navigation hasardeuse, confusion avec la partie C++/CLI...). Je suis donc d'accord avec coyote507 pour recommander http://www.cppreference.com/ car au moins les informations sont complètes et correctes. Pour ce qui est d'un tutoriel, je n'ai pas de bon site à recommander :(
- les affectations dans les tests de conditions font partie du folklore ancestral d'un certain héritage des programmeurs revenus au stade foetal du C. Ils trouvent amusant de baver des trucs dans le genre "while(*p++);" et bien pire. Quant ils passent au C++, ils font des concours sur les plus gros messages d'erreurs par template... <mode_vieux_con> Il faut voir ça comme les djeunes qui font du tuning sur des R5 GTL. ça passe </mode_vieux_con> En résumé: même plus tard, il n'y a AUCUN intérêt à cette pratique ("if (x=y).."). C'est comme le saut à l'élastique.
D'une manière générale, C++ n'est pas un langage très sympathique pour les débutants, les pointeurs n'étant qu'un aspect du problème. Le prochain standard C++09 autorisera des écritures beaucoup plus agréables et naturelles, ainsi qu'une bien plus grande palette d'outils standards, y compris pour la gestion des pointeurs.