Débuter en C++

1) oui, par défaut, toujours préférer les accolades.

Pour aller un peu plus loin : il y a en fait (je pense) qu'un seul cas ou il ne faut pas utiliser les accolades : lorsque l'on ne veut pas "forcer" l'initialisation d'une variable. Par exemple un tableau de données important, dont les valeurs seront directement modifiées sans être lue (et donc que les valeurs aléatoires que le tableau contiendrait ne sera pas problématiques). Bien sur, comme toujours quand on parle d'optimisation, après avoir profiler/benchmarker tout cela pour montrer que cela a un impact significatif sur les perfs.

Et pour le pointeur : a éviter (je ferais un chapitre dessus, il y a beaucoup a dire. Et même si c'est pas du C++ "moderne", ca serait casse gueule de ne pas en parler, au moins pour savoir les problèmes que cela pose)

2) pas sur de comprendre de quoi tu parles. Si tu parles de :

1
2

const auto s { v.size() };  // const ici ou pas ?
for (decltype(s) i {}; i < s; ++i) ...

En fait, il n'est pas nécessaire de déclarer une variable en dehors du for. Premièrement, cela créée une variable qui a une portée plus large que ce dont on a besoin. Deuxièmement, les compilos modernes savent détecter l'invariance de size() dans la boucle et optimiser cela (si la const est respectée)

Et comme toujours (cf au dessus) : profiling avant d'optimiser. (Dit autrement, tu peux déclarer une variable si tu veux… mais il faut montrer les benchmarks)

3) pas de pointeurs.

Sinon, je n'ai pas compris la question.

4) il suffit de recherche "code guideline" sur internet. Chaque logiciel a ses propres règles (parfois dérivées de règles plus commune, par exemple les "google code guideline"). En C++, pas de règles fixees, le plus commune sont (a mon avis) :

• celle de la STL et boost (minuscule, underscore, membres commencent par _, etc). A utiliser quand on fait un projet pure C++
• celle de Qt (majuscule, pas de underscore, nom des classes commencent avec une majuscule et variables avec une minuscule, membres commencent pas m_, etc)

5) C++ Primer de Lippmann.

Et moi aussi, j'aimerais en voir la fin de ce cours

Quel est vraiment l’avantage des {} ?

• Empêcher les conversions avec perte (narrowing conversion) en jetant une erreur de compilation
• Forcer l’ordre d’évaluation des expressions¹
• La généricité dans les constructions:

(Un autre tableau disponible sur le blog de Timur Doumler: https://timur.audio/initialisation-in-c17-the-matrix)

Attention par contre avec les classes qui contiennent un constructeur avec std::initializer_list ; celui-ci est prioritaire si les types sont convertibles. Exemple avec le constructeur de vector vector(std::size_t count, T value):

std::vector<int> v1{5, 3}; // v = {5, 3}
std::vector<int> v1(5, 3); // v = {3,3,3,3,3}

std::vector<std::string> v1{5, "a"}; // {"a","a","a","a","a"}
std::vector<std::string> v1(5, "a"); // {"a","a","a","a","a"}

Une subtile différence existe également avec auto entre les versions des compilateurs qui implémentent ou non c++14. Ceci vient d’une correction tardive dans la norme que les implémenteurs de compilateurs ont appliqués aussi en c++11.

auto i{0};
// gcc < 5 et clang < 3.8 : std::initializer_list<int>
// gcc >= 5 et clang >= 3.8 : int

auto l = {0}; // toujours std::initializer_list<int>

// Je ne sais pas quand Microsoft a introduit le changement dans son compilateur.
// Mais de mémoire, il est le premier à l'avoir fait.

¹ Ordre d’évaluation. Dans l’expression T value(f(ctx), g(ctx)), f(ctx) peut être exécutée après g(ctx), mais dans T value{f(ctx), g(ctx)}, f(ctx) doit être exécutée avant g(ctx).

² Certaines constructions à l’instar de T x(); sont en fait des déclarations de fonctions et non des définitions de variables. Il s’avère que T x(U());, T x(U(y)); ou encore T x(U(y), U(z)); sont aussi des déclarations de prototype. On parle de MVP pour Most Vexing Parse. Il est toutefois possible de faire une définition de variable en ajoutant une paire de parenthèses: T x((U(y)), U(z));

³ Direct initialization

struct Coord { int x,y; } // pas de constructeur

Coord c {2,5};

⁴ Designated initializers

struct Coord { int x,y; } // pas de constructeur

Coord c {.x=2, .y=5}; // nom de champ spécifié

⁵ construction sur place

void foo(T);

foo({x,y,z}); // type déduit

⁶ construction dans une condition

if (std::ifstream f{un_fichier}) {
  // blah
}
// équivalent de
{
  std::ifstream f{un_fichier};
  if (f) {
    // blah
  }
}

// l'équivalent pour la boucle while est beaucoup plus moche

// C++17 introduit comme pour `for` une partie initialisation (init-statement) dans le `if`: http://en.cppreference.com/w/cpp/language/if

Historique:

• 22/08/2021: différence sur l’ordre d’évaluation
• 11/02/2020: initialisation directe et nommée de C++20
• 05/03/2017: § pour la déduction de type avec auto
• 03/12/2016: Pour "construction dans une condition": commentaire sur le bloc d’initialisation ajouté dans le if par c++17.