Discussion :

[kayzra]

Qu'est ce que vous appelez "les bon outils", un IDE?

[Mat007]

Salut,

Qu'est ce que vous appelez "les bon outils", un IDE?

Pour moi les bons outils c'est plus ce qu'on appelle 'pointeurs intelligents' (std::auto_ptr et boost::shared_ptr en tête).
Il ne faut jamais manipuler des pointeurs à mains nues en C++, c'est bien trop dangereux !

MAT.

[Davidbrcz]

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.

il ne faut jamais manipuler des pointeurs à mains nues en C++, c'est bien trop dangereux !

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.

[zais_ethael]

Que nenni.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void f(IToto toto) {
    toto = new TotoImpl();
}
 
void swap(I a, I b) {
   T c=a; a=b; b=c;
}

Par référence tu disais ....? Pourquoi cela ne marche pas alors ?

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.

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.
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!).

[Médinoc]

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).

[zais_ethael]

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.

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.
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.

[Jean-Marc.Bourguet]

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.

[Luc Hermitte]

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 (Ils en parlaient aussi, en clair, dans la spec du langage, mais je n'ai pas retrouvé où)

[Jean-Marc.Bourguet]

Reprennons.
Il y a deux formes de passage d'arguments :

s/deux/au moins quatre/

- "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 :

- par valeur/resultat, en gros une combinaison d'un passage par valeur et de resultat de fonction. Peut aussi s'emuler en C++ avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void f(int& p) {
   int pi = p;
   // on utilise pi
   p = pi;
}

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).
- 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.

[zais_ethael]

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 (Ils en parlaient aussi, en clair, dans la spec du langage, mais je n'ai pas retrouvé où)

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.
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.

[Luc Hermitte]

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

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

?? 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.
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.

est aussi futile que de dire qu'on passe des réfèrence (C++-style) par valeur en C++

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.
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")

[kayzra]

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++ ?

[Luc Hermitte]

Disons que c'est éparpillé : chaque fournisseur de SL a sa propre doc.
Regarde dans la FAQ, les meilleurs liens y sont donnés.

[Mat.M]

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++ ?

http://www.sgi.com/tech/stl/ mais c'est pas du tout didactique.
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.
Si tu veux avoir des cauchemars, documentes-toi sur COM mais COM est plutot réservé aux personnes ayant une bonne maitrise de C++

[coyotte507]

il y a aussi www.cppreference.com

[Médinoc]

Je ne parlerais pas des choses atroces comme C.O.M.
Si tu veux avoir des cauchemars, documentes-toi sur COM mais COM est plutot réservé aux personnes ayant une bonne maitrise de C++

Tu sais, on peut aussi utiliser des Smart Pointers avec COM, hein...
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...

[Luc Hermitte]

Essayez Corba. COM, c'est le paradis à côté.

[kayzra]

Je ne savais pas que pratiquer les pointers avec C++ ça pouvait rendre sadomasochiste si j'y prend goût, j'essaierai Corba et C.O.M,
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 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
   if(x = y) ...

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é ?

[Luc Hermitte]

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.

[ac_wingless]

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.