La programmation en C++ moderne

Merci pour tes retours et encouragements.

Je pense que je vais aborder ça dans le chapitre sur les templates, avec aussi std::advance et std::prev, comme l’avait fait remarqué lmghs.

Corrigé merci.

J’ai supprimé cette partie. En y réfléchissant, le lecteur n’a pas besoin de savoir utiliser std::function, et ça ne lui sert par pour l’instant. J’ai modifié les explications.

J’y réfléchis. Effectivement, ça pourrait être une bonne idée. Ça pourrait aussi permettre d’introduire la nouvelle syntaxe pour les fonctions (trailing type).

Bonjour à tous,

Je viens suivre ce cours sur C suite à un conseil de @germinolegrand je suis débutant en C++ donc je me permets de donner mon avis !

Pour commencer je suis seulement au tout début de ce cours mais plusieurs choses mon bien plus tel que le résumé en fin de chapitre. Je trouve aussi que les phrases de l’auteur son bien formulé et agréable à lire, de plus la mise en forme est parfaite ce qui fait plaisir à mes yeux étant donnés que je vais passer plusieurs heures sur ce cours. Et pour finir je compare un peu ce cours avec le cours du C de openclassroom et le cours de C++ de @gbdivers et je trouve que les bon points de tout c’est cours on était repris.

PS: étant donné que je suis au tout début du cours, je viendrais souvent donner mon avis par la suite !

Ces tout pour moi, bonne continuation ! Enzo

Merci à toi pour ton retour Enzo. C’est très encourageant. N’hésite pas à nous faire d’autres retours au fur et à mesure.

Salut à tous,

Du coup, j’ai séparé les lambdas du chapitre sur les algorithmes, pour les mettre dans un chapitre à part. Il ne me reste plus qu’à ajouter des exercices pour ce chapitre, ainsi qu’étoffer celui des algorithmes, et le tutoriel ira officiellement en validation.

Merci d’avance pour vos commentaires.

Merci pour tous tes retours.

Effectivement, j’ai enlevé ça. Et j’ai retravaillé légèrement l’introduction, qui n’avait jamais été modifiée depuis le début de l’écriture de ce cours, avant même qu’on ne sache qui on voulait viser.

Celui qui veut apprendre C++11 ou C++14, vu que je base mon cours sur C++17, il ne pourra qu’à certaines conditions. Par exemple, l’initialisation avec les accolades n’est pas identiques en C++14 et C++17. Bon en vrai, je pense qu’il vaut mieux retirer tous les tags et juste laisser C++.

Je vais effectivement rajouter cette précision. Mais le fait est qu’il faudra bien s’y mettre un jour ou l’autre, surtout que l’anglais technique n’est pas aussi dur que l’anglais littéral.

J’avoue qu’à la relecture, ça peut faire troll. Mais certains aspects qui viennent du C sont vraiment cause de problèmes parfois. Je vais reformuler.

Effectivement, je corrige.

Je n’ai jamais utilisé cet IDE. Mais pourquoi pas.

Ça me semble bien, merci pour la suggestion.

Pareil, chapitre écrit au début sur lequel je ne suis quasiment pas revenu. Je change.

Je vais voir pour rester clair et simple.

Si si, dès lors que CMD est configuré avec une police type Consolas, et qu’on ajoute la locale FR, ça marche.

Tu parles du résumé en fin de chapitre ?

Bonjour, une partie sur les application fenêtre est elle prévus ?

Non, pas dans le cadre de ce cours. Il me reste déjà énormément à écrire, puis je ne connais que trop peu Qt pour écrire dessus. Même si j’avais les compétences, ce serait un tutoriel à part.

Je t’invite à lire les articles de @gbdivers, qui est un spécialiste du sujet.

Tu parles du résumé en fin de chapitre ?

Oui. Disons que je trouve les explications sur les instructions et les fonctions plus claires dans le résumé quand dans le texte

Salut à tous,

J’ai mis le tutoriel à jour, suivant les remarques de @gbdivers. Les changements portent donc sur l’introduction et les trois premiers chapitres.

Merci d’avance pour vos commentaires.

La suite, jusqu’au chapitre 5

Les caractères

"Tous comme les mots de la langue française sont des regroupements de lettres, les chaînes de caractères sont une agglomération de caractères simples." : bof "regroupements" et "agglomération’.

"\n qui permet d’aller à la ligne, comme std::endl." : peut etre preciser que std::endl ne fait pas que ca ? Qu’il y a une difference entre les 2

"commençant par R"( et se terminant par ")" et plus loin "définir soi-même les délimiteurs" : du coup, non. La seconde partie contredit la première.

"Attends, qu’est-ce que c’est que ça ? 9 / 2 et 9. / 2 ne donne pas la même chose ? Et c’est quoi % ?" : cela suppose que le lecteur teste le code donné. Ce qu’on attend de lui… mais qu’il ne fera pas forcement. Du coup, il faudrait peut etre afficher ce qu’affiche les codes donnés ?

"L’exemple suivant est tiré du cours de gbdivers." : ca sert a rien de donner un lien vers mon cours, le lien ne restera pas valide. Et ce n’est pas nécessaire. (Mais merci quand meme)

"C’est un concept commun à tous les langages de programmation" : je dirais non. Pas en assembleur par exemple (où le concept de variable, c’est a dire une valeur avec un nom n’existe pas vraiment dans mes souvenirs) ou dans les langages fonctionnels.

Comment créer des variables en C++ ?

"mot-clef" -> mot-clé ?

"Il ne doit pas commencer non plus par underscore _, ceci étant réservé pour le compilateur." : plutot dire que leur utilisation suit des régles spécifiques, donc c’est plus simple de ne pas les utiliser comme premier caractère.

"La valeur par défaut" : j’hésite à parler de ca dans mon cours. Tout ce qui est implicite peut poser des problèmes. Et quel est le gain d’écrire "int i {};" au lieu de "int i { 0 };" ?

"std::string phrase { };" -> std::string phrase {}; (supprimer l’espace dans {}, puisque tu n’en mets pas dans les autres)

"Ne vous tracassez pas avec tout ça si vous avez du mal à comprendre. Ce petit point est là pour la culture générale et pour voir un exemple de l’héritage du C." : j’ai justement tendance, pour un cours orienté débutant, a supprimer autant que possible tout ce qui n’est pas directement utile a l’apprentissage.

"Un peu de constance, voyons !" : tu as prévu de parler de constexpr ?

"pas importante" : du coup… pourquoi la mettre ?

AND — Tester si deux conditions sont vraies

"Les deux sont parfaitement valables et interchangeables." : en pratique, dans la vraie vie, on n’utilise pas trop and, or et not.

"Prouvez-le-moi en mettant les parenthèses au bon endroit dans ces codes piqués à gbdivers. :)" : idem, le lien ne restera pas valide. (Et merci).

Merci pour votre réponse, et es ce que j’aurais les compétences requise à la fin de ce cours pour pouvoir suivre le cours sur Qt de @gbdivers ? Ou du moins, aurai-je les compétences pour utiliser Qt ?

@gbdivers : merci pour les retours.

Je vais changer ça.

Oui, je devrais le faire. Il faut juste que je réfléchisse à ce que j’explique et à ce que je passe sous silence.

J’avoue que j’ai piqué l’idée de parler de ces chaînes de ton cours, mais que je me demande si je vais laisser cette section ou pas. Je dois peser le pour et le contre d’aborder ce sujet.

Je devrais faire ça oui, bonne suggestion. J’avoue cependant que le mode « console » qu’il y avait sur feu le Site du Zéro me manque (fond noir et police blanche).

Mes souvenirs d’ASM86 sont rouillés, mais il me semble que si, les variables existent. Mais je vais reformuler le passage.

À chaque fois, je me fais avoir.

J’aime ta formulation. Merci.

J’avoue… Je vais refaire ce passage.

Justement, je me fais aussi ces réflexions et c’était mon credo lors de la rédaction des derniers chapitres. Mais comme ceux-là ont été rédigés il y a longtemps, c’est une bonne chose que de repasser dessus.

J’ai prévu, dans le plan actuel, dans le chapitre sur les templates. J’aimerais en parler plus tôt, mais j’ai peur que le lecteur n’y voit aucun intérêt.

Je vais enlever.

Je sais. L’influence de Python, sans doute.

@ImABotnet- : si tu parles du cours de ZdS, en l’état non, tu n’auras pas toutes les connaissances pour suivre le cours Qt de @gbdivers. Il faudra compléter, avec son cours notamment.

Ok donc je vais continuer ce cours et j’approfondirais sur celui de @gbdivers

@gbdivers : y’a pas à dire, configurer Qt Creator sous Windows c’est bien galère, parce le MinGW n’est pas du tout à jour.

Salut à tous,

Pas grand chose, quelques petites modifications éparses et le début d’une section consacrée à Qt Creator.

Je n’ai pas encore pris toutes tes remarques en compte @gbdivers. Ça va ralentir un peu pour les trois prochains jours, mais ça repartira lundi.

Merci d’avance pour vos commentaires.

Qtcreator pfff. Et pourquoi pas vim, hein ?

§9.1.2 s/Pour se faire/Pour ce faire —hint: "pour faire cela"

A propos des erreurs. Peut-être renvoyer à une fiche technique externe sur quoi renvoyer depuis le main, où écrire, etc.

Typiquement, mes mains ressemblent à

int main() {
    try {
        code;
        return EXIT_SUCCESS;
    } catch (std::exception const& e) {
        std::cerr << "Erreur: " << e.what() << "\n";
    } // + autres catch...
    return EXIT_FAILURE;
}

Note: une telle fiche peut dévier sur ces choses comme

# bash, ou même $CMD sous Windows
./monprog.exe && echo "tout est OK" || echo "il y a eu un problème!"

" On peut facilement imaginer un programme qui redemande de saisir un montant valide tant qu’on rencontre une erreur. Ça fait un bon exercice d’ailleurs."

Pas sûr que cela soit un si bon exercice. S’il est nominal que les sommes saisies puissent être incorrectes, les exceptions ne sont plus forcément la bonne approche. En fait dans un tel cas, j’aurai limite:

bool peut_debiter(int const compte, uint somme);

void debiter(int &compte, uint somme) [[require: peut_debiter(compte, somme)]];

Mais on s’éloigne du sujet. Ou alors, on introduit la PpC ici (mais ce n’est pas un sujet sur lequel les débutants sont à l’aise je trouve.)

invalid_argument et domain_error sont des logic_error, et pour le coup, je partage pas mal l’avis de Sutter comme quoi nous n’aurions jamais dû avoir des logic_error: https://herbsutter.com/2018/07/02/trip-report-summer-iso-c-standards-meeting-rapperswil/ step2

En tout ça, ces erreurs changent complètement le sens de ta fonction.

"impossible en effet de transmettre un unsigned int qui vaudrait -5"

Malheureusement si. Et le compilateur ne râlera même pas. Au mieux, on a un warning.

J’ai peur que la partie sur la PpC soit trop courte pour bien comprendre. Mais bon, avec mes 3 billets, je suis un peu parti pris sur les choses à expliquer avant de pouvoir faire un tour suffisant de la question

À propos de noexcept: "Ce mot-clef est une aide pour le programmeur qui lit un code, donc n’hésitez pas à l’utiliser dès que vous le pouvez."

C’est surtout une aide pour le compilateur. Certaines fonctions sont câblées par meta-prog pour aller plus vite quand on la garantie "sans exception". De plus le compilateur peut générer des binaires plus rapides quand des grosses zones de fonctions "feuilles" sont noexcept — si on intervertit les couches ça sera le contraire.

BTW: juste dire "garantie de fonction" pour désigner ce concept peut laisser croire que cela ne concerne que ce sujet. Ce n’est pas le cas.

g/comme un utilisateur qui écrit des données erronées./s/écrit/saisit ou fournit/

On n’utilise pas invalid_argument. C’est une erreur de logique. Bouh! assert! (OK, je suis un peu extrême sur le sujet.

§ 10 les conteneurs

"Et qui dit concept de boucle, dit accès aux éléments un par un"

Si on regarde que l’on introduit le mot pour la première fois dans ce chapitre, la phrase fait bizarre. Il faudrait un liant pour introduire une définition d'itérer qui fasse intervenir (pas forcément à la première reformulation) le terme boucle.

Là, je ne suis pas hyper inspiré

Je ne parlerai pas de mémoire dans le cas des itérateurs. Typiquement les mots d’un fichier ne sont pas parcourus dans la mémoire mais dans le fichier.

Plutôt que debut_tableau, je te propose curseur_tableau.

Chipoteur que je suis, si on me dit "Si l’on part de std::end, on va se déplacer vers la droite ", je répondrai: "prends-moi pour un idiot, j’irai vers la gauche en décrémentant!".

Il faut AMA ouvrir une parenthèse de teasing sur les algorithmes et indiquer que "un grand intérêt de la SL et de ces itérateurs, c’est que le standard nous fournit ensuite des algorithmes qui parcourent (avec ++) des éléments pour faire des choses avec". Il serait dommage de devoir écrire ces algorithmes deux fois, une fois pour travailler en avançant, et une fois pour travailler en reculant. A la place, la SL offre un moyen de déguiser (d'adapter dans le jargon) les itérateurs qui avancent sur ++, en itérateur qui reculent sur ++. Ce sont ces reverse iterators que l’on obtient avec rbegin(), rend().

Une autre raison est le fait que l’on travaille usuellement sur des plages semi-ouvertes [b, e). Travailler dans l’autre sens, change subtilement initialisation et condition de fin.

"Tous les algorithmes se trouvent dans le fichier d’en-tête <algorithm>, pensez donc à l’inclure."

Certains se sont perdus dans <numeric> et ailleurs.

std::sort() Exige des conteneurs qui supportent l’accès direct. Ce peut être une bonne occasion pour prendre le lecteur par la main et lui faire lire l’information correspondante sur cppreference, et déduire que cela marchera avec vector, array, queue, et T*, mais pas list, map…

"L’algorithme va déplacer toutes les occurrences de la lettre à la fin de la chaîne"

Nope.

Iterators pointing to an element between the new logical end and the physical end of the range are still dereferenceable, but the elements themselves have unspecified values

"La très grand majorité" -> "grande"

Les prédicats et foncteurs sous forme de fonctions, cela me gêne un peu car c’est la forme la moins efficace.

"Pourquoi pas un for ou un while?".

1- parce que c’était simple à rajouter, et que l’on était à la limite de la preuve de concept/faisabilité. Et surtout pour être complets, il le fallait — même si pratiquement personne ne s’en sert jamais.

2- ça devient intéressant avec le C++17 où std::for_each est parallélisable de multiples façons différentes en standard là où les structures de contrôle passent par des standards (exemple typique: OpenMP) hors du périmètre du standard du c++ ; standards qui offrent de moins nombreuses façons de paralléliser.

"des algorithmes que nous n’avons pas encore vu"

J’accorderai bien "vu" au pluriel

"car retournant un pointeur sur, respectivement, le début et la fin d’une collection."

Si tu veux éviter le terme "itérateur", évite de trop recourir à "pointer" et "pointeur". Cela a des sens très forts. J’aurai tendance à utiliser "curseur". Et avec des dessins/des animations, on peut déplacer le curseur au fil des explications.

supprimer_espaces_gauche et droit: cela vaudrait le coup de prendre par copie pour profiter de l’élision de copie & cie. Mais cela va demander un lien qui dit: "oui j’ai fait exprès de ne pas prendre une référence constante dans ce cas précis: explications derrière ce lien"

(Je trollais pour QtCreator…)

(Parce que je ne trolle pas pour vim ? )

Ceci dit, QtCreator est probablement un des IDE gratuits les plus pertinents pour un nouveau qui ne sait pas trop quoi choisir.

§ 11 les lambdas

Intro: en fait, les fonctions ne plaisent pas trop car elles sont plus compliquées à inliner de façon sûre, et du coup ce sont les foncteurs qui sont, qui étaient, préférés. Très bonnes perfs, flexibles. Sauf que: pour exprimer un prédicat, on se cogne facilement jusqu’à 7 lignes de bruit. Autant dire que personne n’utilisait find_if()

" Par contre, si le corps de la lambda est long, complexe, ou bien si la lambda est très souvent réutilisée, alors une fonction classique est sans doute plus adaptée. "

Ou on la stocke tout simplement dans une variable avec auto.

"Du coup, si on stocke la lambda dans une variable, il n’y a plus vraiment de différence avec une fonction classique. À quoi servent-elles, du coup ?"

On a des possibilités d’optimisation supplémentaires avec les lambdas dans mes souvenirs. Car quand on va commencer à manipuler des fonctions, ce que l’on passe en paramètre des algos générique, c’est des adresses de fonction: des pointeurs. Pointeurs qui induisent donc des indirections. Les lambdas, cela reste essentiellement du sucre syntaxique pour générer des foncteurs à la volée. Et ça, c’est inline-friendly.

Type de retour des lambdas: attention qu’il y a eu des changements entre le C++11 et le C++14. Le C++14 permet aussi de prendre des paramètres auto. Pas le 11.

Pour mutable & cie. Si on voit les lambdas comme des FoncteurImprononcable::operator()(args) const, pas mal de choses commencent à s’expliquer.

Du troll. J’ai commencé à bosser dessus.