La programmation en C++ moderne

Salut !

Ce début de cours est franchement encourageant je trouve. J'ai cependant une petite remarque : pourquoi mettre le chapitre sur "comment lire la doc" (chapitre utile s'il en est) avant d'expliquer ce qu'est une fonction ? Je l'aurais plus vu après la première partie sur les fonctions, ce qui permet ensuite dans les bonnes pratiques d'insister sur le fait qu'une fonction s définit par son cahier des charges et sa doc, et que l'implémentation est secondaire

Je suis tout à fait d'accord avec mehdidou99 : on est bien plus souvent utilisateur de fonction/méthode que créateur. Sans compter que dans le processus d'apprentissage, il est bien plus cohérent de faire un lien entre ce qu'on vient d'apprendre et ce qu'on va apprendre.

Ce n'est pas une remarque de boulet. C'est au contraire une réflexion intéressante. Il est toujours intéressant de comprendre pourquoi un auteur fait tel ou tel choix.

Bon, ben merci

Je suis un peu de près ce cours et celui de GBdivers, parce que j'ai un ami dev Java / Perl qui aimerait se mettre au C++, et j'aimerais mieux lui conseiller un truc directement en C++ moderne. D'autant plus qu'il a une haine viscérale des pointeurs en C, donc partir directement avec une gestion des ressources automatisées, ce serait plus sympa

Du coup j'attends avec impatience la suite de la rédaction, et je n'hésiterai pas à proposer des remarques au fur et à mesure

Plop !

Bon, j'ai lu les chapitres 2 et 3 de la partie II en mode "lecture critique", et je vous partage le fruit de mes réflexions. Cela dit, même si je fais beaucoup de remarques (que j'espère constructives) il y a un déjà travail important de proposé et ça mérite d'être souligné L'essentiel du contenu est là, je propose seulement quelques points supplémentaires.

Chapitre 2 : Littérales

Quelques types de littérales

(proposition) remplacer "R.A.S" par "rien à signaler"

Opérations

(proposition) j'ajouterais la concaténation de chaînes avec +

Lire la doc

(typo) dépend de comment la fonction EST implémentée

(remarque) finalement, après lecture plus attentive, c'est bien amené et placé je trouve

Chapitre 3 : Variables

Globalement, je pense que comme c'est un concept-clé, ça vaudrait le coup de s'attarder sur des exemples concrets pour donner une idée réelle de comment ça s'utilise, pas juste comment marche la syntaxe

Intro

(typo) c'est sympa, pas c' est sympa

Définir une variable :

(proposition) il me semble qu'on passe très vite sur ce qu'est une variable, et vu qu'on ne s'en sert pas encore de façon concrète, ça reste assez abstrait. Peut-être qu'il faudrait donner quelques exemples de ce qu'on peut contenir et pourquoi ça pourrait changer au cours du programme. Voici des exemples qui me viennent en tête, de différents types :

• unsigned int : un compteur de vies/munitions dans un jeu vidéo, qui peut augmenter ou diminuer ;
• unsigned int : la largeur d'une fenêtre, qu'on peut redimensionner ;
• int : le score dans un jeu de tarot ;
• unsigned double : des montants dans un logiciel de comptabilité ;
• double : des coordonnées dans un logiciel de dessin ;
• std::string : le nom d'un dossier dans un navigateur de fichiers ;
• std::string : l'url en cours de visite dans un navgateur web ;
• bool : l'état sauvegardé / non sauvegardé d'un traitement de texte, tableur, éditeur

On pourrait d'ailleurs présenter ces exemples ensuite plutôt que des "maVariable" …

Retour sur les littérales

(??) tu n'as pas menti il me semble, donc la tournure est bizarre…

(remarque) parler du suffixe c'est pas mal, mais quasiment jamais utile (sauf avec auto) : je pense qu'il faudrait préciser que si on écrit int compteur {10}, le compilateur comprendra très bien qu'il doit prendre 10 comme un int et pas un unsigned int ou un float, et que si on écrit double abcisse {0.42} il prendra pas un float…

(remarque) parler de bonnes pratiques au sens large, pas seulement pour les noms de variables, c'est bien, j'aime

Modifier la valeur d'une variable

(proposition) plus expliquer le coup du variable = variable + 1 avant de passer aux raccourcis; d'expérience, c'est vraiment un truc qui coince avec les débutants. On peut donner des exemples, si je repioche dans mes idées du dessus ça peut être vie = vie -1 ou depenses = depenses + loyer (avec loyer défini avant)

Les constantes

(remarque) noter la constante c_i alors qu'on a dit qu'on évitait les underscores dans les noms, ça mérite une remarque je pense (genre "on s'autorise c_ pour dire dans le nom que c'est une constante")

(proposition) donner des exemples concrets (nbreJoueurs au morpion, viesMax dans un jeu, hauteurMax pour une fenêtre…)

(proposition) on peut introduire le terme cv-qualifiers ici, puisqu'on l'utilise après

Les références

À mon sens, il y en a soit trop, soit pas assez. C'est-à-dire que présenté comme ça, on comprend pas trop, et ce pour une simple raison : on a pas été encouragé à affecter des variables à partir d'autres variables. Il faudrait donc au moins un exemple du type :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int i1 {2};
int i2 {5};
std::cout << i1 << "," << i2 << std::endl;  // affiche 2,5
i1 = i2;  // on affecte à la variable i1 le contenu de la variable i2, mais i1 reste indépendante
std::cout << i1 << "," << i2 << std::endl;  // affiche 5,5
i2 = 8;   // comme i1 et i2 sont des variables indépendantes, ça ne modifie pas i1
std::cout << i1 << "," << i2 << std::endl;  // affiche 5,8
int& ref1 {i1};  //créé un alias de i1
std::cout << i1 << "," << ref1 << std::endl;  // affiche 5,5
i1 = 1;  // change i1, mais comme ref1 est une étiquette sur i1, ça le change aussi
std::cout << i1 << "," << ref1 << std::endl;  // affiche 1,1

(proposition) Peut-être proposer des exos dont un dans ce genre-là (genre un code à trous où on met en commentaire les affichages attendus et l'élève doit déterminer où il doit rajouter des & dans les déclarations)

(proposition) je pense que le coup des références constantes, ça mérite aussi un exemple (concret si possible). C'est assez brouillon comme ça je trouve.

Inférence de type

(chieur Python) en Python une variable ne change pas de type dynamiquement, parce qu'on ne manipule jamais les variables. On peut juste faire pointer une référence vers une nouvelle variable d'un nouveau type, mais l'ancienne variable vers laquelle on a plus de référence existe toujours et garde son type. C'est d'ailleurs pour ça qu'on distingue variable mutable et non mutable, et qu'on peut s'arracher les cheveux avec ça. Bon, après, la pertinence de ce genre de détails dans un cours débutant de C++, voilà quoi

(remarque) parler de cv-qualifiers ok, mais il faut définir le terme dans la partie sur const alors

(remarque) je comprends mieux le fait d'avoir insisté sur les suffixes maintenant, mais dans ce cas il faut faire apparaître les suffixes dans les exemples (et pas seulement en remarque)

(proposition) on peut aussi dire qu'on verra plus tard des types très compliqués comme std::list<std::unique_ptr<std::string>>::const_iterator et quand dans ce cas, auto peut simplement simplifier l'écriture puisque le type est non ambigu

Le mot de la fin

Voilà, j'espère que certaines idées seront utiles. Une fois de plus, il ne s'agit pas de taper sur les auteurs qui se sont attelés à un énorme travail, mais d'essayer de critiquer constructivement