Version imprimable
Bonjour à tous,
J'ai déjà fait des développement assez conséquent en C et en Java, mais je découvre le développement en C++.
Je pense avoir cerné à peu près toute les différences, j'aimerais préciser le coté passage d'objet. J'aimerais savoir si un programme est beaucouo ralenti si on passe les objet par valeur. Où si il faut privilégier le passage d'objet par référence ?
bonjour,
oui il vaut mieux faire du passage par reference ou par pointeur ici on copie coup sur coup 4octets, alors que par un passage d'objet provoque une recopie aléatoire selon sa propre taille.
Plus ton objet est gros plus la recopie sera longue, son alocation sur le tas...
Mais bon on ne va pas faire un pointeur ou une variable de classe pour pouvoir rendre sa reference (il reste l'option de l'argument comme variable de retour certes) si ?
enfin pour repondre a ta question oui c'est plus rapide.
Whouaa j'ai même pas eu le réflexe :-)
Mon message est donc à délester.
Même les différences qui vont au délà des aspects syntaxiques ?Citation:
Envoyé par jeje99
En vrac des sujets qu'ils abordent complètement différemment: support de la sémantique de valeur, libération déterministe de ressources, héritage de réutilisation de code (par opposition à l'héritage en vue d'être utilisé en place de, cf le LSP ; et cf aussi la composition), ...
Je passe sur des aspects plus poussés et sans comparaison immédiate comme la programmation générique et la meta-programmation plus-ou-moins-vs la réfléxivité, la programmation par contrats, ...
A ouais quand même, merci pour tout ces mots clefs ça m'a permis de faire quelque petites recherches très intéressante, je te répond pour chaque termes :
- libération déterministe de ressources : ça c'est en fonction de l'OS et non du langage. Mais le concept est assimilé, j'ai fait du C et je peut te dire que les free faut pas les oublier et bien les placer.
- programmation générique : c'est implémenté en Java (il ont bien copié) depuis la version 1.5, je connais !
- méta - programation : je n'ai jamais utilisé mais comme les enum et template on été ajouté en Java 1.5, je pense que l'équivalent se fait aussi. Mais j'ai l'impression que ce n'est pas très bon pour la compréhension du code, mais c'est vrai que ça permet par exemple de générer des constante statique très facilement. Je pense donc que c'est à utiliser avec modération, c'est toujours bon de savoir que ça exite.
- la réflexivite : je n'en ai pas besoin je ne m'y suis donc pas attardé sur son application en c++(on ne peut pas tout connaître)
- héritage de réutilisation de code, composition : je ne vois pas la différence entre java et c++, peux tu me la donner.
- programmation par contrats : si j'ai bien compris c'est une méthode de programation plutot qu'une spécificité du C++. C'est vrai que j'ai pas l'habitude de l'utilisé...
Voila pour la petite liste, et pendant que j'y suis, j'aimerais savoir si il y a des outils de tests unitaires aussi puissant que JUnit en c++ ?
Je crois que Luc faisait allusion au fait que les destructeurs en C++ sont executes a des moments determines (et donc qu'on peut s'en servir pour liberer des ressources) tandis que les finaliseurs en Java sont executes au bon vouloir du GC apres qu'il ait remarque que l'objet n'etait plus utilise.Citation:
Envoyé par jeje99
A ma connaissance -- je connais mal Java et j'avais regarde ce qui ete propose pour la genericite, je ne pense pas avoir regarde ce qui a ete accepte -- il y a pas mal de differences entre Java et C++ la dessus. Le modele de genericite du C++ est plus acces sur l'expansion de code et permet pas mal de choses amusantes.Citation:
- programmation générique : c'est implémenté en Java (il ont bien copié) depuis la version 1.5, je connais !
Je ne me souviens pas que ce (la meta-programmation par template *) fut possible en Java dans les propositions que j'ai vue. Il manque la possibilite d'une specialisation explicite pour arreter les recursions infinies.Citation:
- méta - programation : je n'ai jamais utilisé mais comme les enum et template on été ajouté en Java 1.5, je pense que l'équivalent se fait aussi. Mais j'ai l'impression que ce n'est pas très bon pour la compréhension du code, mais c'est vrai que ça permet par exemple de générer des constante statique très facilement. Je pense donc que c'est à utiliser avec modération, c'est toujours bon de savoir que ça exite.
(*) La metaprogrammation est la generation de code; on peut en faire avec des macros (en particulier en lisp, mais c'est possible meme en C et en C++, voir boost) ou un langage externe.
Il n'y a pas de reflexivite en C++; Luc disait qu'on l'utilisait en Java pour arriver plus ou moins a des choses qu'on fait avec la programmation generique et le meta-programmation par template en C++.Citation:
- la réflexivite : je n'en ai pas besoin je ne m'y suis donc pas attardé sur son application en c++(on ne peut pas tout connaître)
Quand tu passes par valeur, tu fais une copie de l'objet. (je rappelle aussi que chaque objet peut définir son comportement en tant que copie, ce qui peut être particulièrement coûteux)
Ne pas faire de copie est donc mieux, oui. On utilise aussi souvent const avec la passage par référence (enfin ce n'est pas du vrai passage par référence, mais passons) si on ne modifie pas le paramètre dans la fonction.
Les pointeurs, de façon générale, sont à éviter en C++.Citation:
il vaut mieux faire du passage par reference ou par pointeur
Je suppose que Luc Hermitte faisait référence au concept qu'on appelle en anglais avec un joli acronyme RAII.Citation:
- libération déterministe de ressources : ça c'est en fonction de l'OS et non du langage. Mais le concept est assimilé, j'ai fait du C et je peut te dire que les free faut pas les oublier et bien les placer.
Il s'agit justement de ne pas avoir à faire de libération de mémoire manuelle grâce aux destructeurs.
Le gros morceau de C++ ce sont les templates.
Et je peux te dire qu'ils sont bien plus compliqués qu'en Java.
bonjour,
juste en pacant
je suis pas tout a fait d'accordCitation:
Envoyé par loufoque
pour ne pas se prendre la tete, oui mais bien géré y a pas mieux
Concernant la libération déterministe de ressources,
* l'OS ne peut rien pour nous. Durant le fil de l'exécution, il ne peut pas savoir si on a encore besoin ou non d'une ressources. Après l'exécution, il ne sait gérer qu'un nombre limité et bien précis de types de ressource. P.ex. il sera bien infichu de réclamer des pots de peintures qui ont été alloués à une chaine automatisée via une API dédiée, couper une arrivée d'eau, ...
* Chaque langage propose un ensemble de facilités qui lui sont propres pour nous aider dans cette tâche
- en C, pas grand chose
- en C++, le RAII
- En Java et dans bien d'autres langages try-finally (aka le dispose pattern) pour toutes les ressources qui ne sont pas de la mémoire, et le GC pour la mémoire (mais là, sans certitude quant à l'instant de la libération même)
- C# -> try-finally, mais aussi une directive using
La généricité du Java 1.5 est un sucre syntaxique, ressemblant fortement à celui du C#, et qui est à rapprocher de la généricité de l'Ada (p.ex.) que l'on applique aux types abstraits. Les templates du C++ donnent également droit à ce sucre syntaxique, mais aussi à un paradigme que certains nomment (/commencent à nommer ?) "Generative (meta-?)Programming". Là, Java ne sait pas faire. On va probalement (je ne suis pas un pro du Java, je suppute donc) pouvoir obtenir des fonctionnalités approchées avec de la précompilation (avec un outil quelconque) ou probablement à coup de réflexivité.
Réflexivité que C++ ne supporte nativement pas. On trouve des frameworks qui s'interessent à rajouter la réflexivité au C++.
Pour en revenir à la meta-prog en C++, c'est un axe supplémentaire (à l'OO p.e.x) qui nous est offert lors de la conception. cf. p.ex. Multiparadigm Design in C++ par Jim Coplien (chez Addisson Wesley) qui traite de design en C++ en tenant compte de tous les paradigmes offerts (ce n'est pas un bouquin sur le langage qui montre les tours de passe-passe qui nous sont possibles avec la syntaxe, mais bel et bien un bouquin pour "architectes")
Concernant l'héritage et la réutilisation de code. Dans la famille des carrés qui ne sont pas des rectangles (une conséquence d'un principe que je touve très important dans les langages OO (fortement?) typés), on a aussi : "comment définir une classe liste triée à partir d'une classe liste?". En Java, seule la composition est une solution correcte sur le plan OO. En c++, l'héritage privé est une autre solution valable -- avec ses avantages et ses défauts.
La prog par contrat est une chose possible nativement (aussi verbeuse soit-elle) en C++. En Java, elle ne l'est que si:
- on passe par un pré-compilateur qui analyse les tag @pre et @post de la javadoc
- ou si on se limite à définir des objets qui n'implétent qu'une seule interface au maximum, ou plus exactement, une seule classe abstraite.
Pour les test unitaires, j'utilise CxxTests au boulot et j'en suis très content. Il nécéssite la présence d'un interpréteur perl sur la machine de développement. Il y avait eu une série évaluations de divers outils sur : Games from Within.
J'ai probablement passé sous silence bien d'autres différences, dont des plus connues et débattues en long, en large, et en travers.
Qu'entends-tu par "sucre syntaxique"? C'est generalement utilise pour des choses qui ne sont que des transformations locales sans effet sematique. La genericite en Ada a des effets semantiques et permets des choses qui ne sont pas possibles avec les templates en C++ sans artifices (mais les templates en C++ permettent des choses qui ne sont pas possible en Ada, meme avec des artifices).Citation:
Envoyé par Luc Hermitte
Si j'ai bien suivi, la genericite en Java (comme en C#, ML, Eiffel, Modula) exige une implementation partagee. Ce n'est pas le cas de celle d'Ada qui permet l'approche generative comme l'approche partagee (bien qu'a ma connaissance tous les compilateurs Ada95 utilise
une approche generative, des compilateurs Ada83 ont utilise l'approche partagee, au moins un permettait de choisir).
Generative Programming, c'est la generation automatique de code. On peut presque considerer que la compilation en est (du point de vue d'un programmeur en assembleur). L'idee est loin d'etre neuve, les macros dans les langages de compilation sont faites pour cela (voir ce qui ce fait ou ce qui c'est fait en assembleur, en lisp ou en forth -- les mots immediats), mais des choses comme lex, yacc, les generateurs de tri ou de fft en sont. Il y a donc une longue histoire derriere cela.Citation:
Les templates du C++ donnent également droit à ce sucre syntaxique, mais aussi à un paradigme que certains nomment (/commencent à nommer ?) "Generative (meta-?)Programming".
Le plus interessant, c'est la maniere lisp ou forth ou le "meta" langage utilise est le langage meme. Dans la plupart des autres approches, on se retrouve avec un autre langage (les macro du C++ ou meme des choses completement exterieure). L'utilisation des templates en C++ est intermediaire: on n'a pas tout le langage, mais un sous-ensemble.
Les pointeurs impliquent de la gestion de mémoire manuelle.Citation:
je suis pas tout a fait d'accord
C'est donc dangereux, surtout qu'en cas d'erreur ils peuvent ne pas être libérés.
Ah. Oui je vois. Effectivement.Citation:
Envoyé par Jean-Marc.Bourguet
Je pensais au départ au fait que la généricité Java était juste une encapsulation permettant d'éviter de faire nos downcastings à la main sur les types abstraits comme p.ex. des collections. Par "partagé", j'imagine que tu entendais qu'en interne un downcasting est réalisé de façon transparente ?
Mes souvenirs d'Ada concernent la version 83 je crois bien. L'approche était générative et je l'avais vue essentiellement dans le cadre de la définition de types abstraits. Que conceptuellement et applicativement (hors détails d'implémentation) j'associe volontier avec la généricité Java.Citation:
La genericite en Ada a des effets semantiques et permet des choses qui ne sont pas possibles avec les templates en C++ sans artifices (mais les templates en C++ permettent des choses qui ne sont pas possible en Ada, meme avec des artifices).
Tu pensais à quoi en parlant des effets sémantiques de l'Ada requiérant des artifices en C++ ? (Mes souvenirs ont un peu pris la poussière :roll:)
Ada83 comme Ada95 permet les deux. Le compilateur Ada83 de DEC par exemple avait un pragma permettant de choisir (instantiation par instantiation si j'ai bonne memoire).Citation:
Envoyé par Luc Hermitte
Je ne vais pas ecrire du code parce que mes souvenirs sont aussi un peu poussiereux sur les details, mais il y a d'une part la verification de contraintes sur les parametres templates et d'autre part le fait que les generiques sont instancies explicitement, ce qui permet d'en instancier un plusieurs fois avec les memes parametres mais sans partager ce qui aurait ete des membres statiques en C++ (l'artifice a faire en C++ est d'ajouter un parametre supplementaire utilise uniquement pour differentier les instantiations).Citation:
Envoyé par Luc Hermitte