Discussion :

[zancrows]

Bonjour,

j'ai décidé depuis peu de me remettre au C++ que j'ai vu en BTS il y à quelques années. je suis un tuto pour me mettre à jour et découvrir le C++ moderne.
La ou je me pose une question c'est sur l'initialisation des variables:

Code :

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

1
2
3
 
int a = 2;
int b {2};

Ma question c'est quelle est la différence, ou ce qu'apporte la syntaxe d'initialisation avec les {}.
en cherchant un peu j'ai vu qu'elle permettait d'indiquer avec des warnings ce genre de chose:

Code :

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

1
2
 
char a = 999;

mais y a-t-il d'autres raisons ? et faut-il tout le temps utiliser cette syntaxe ?

[Grool]

La syntaxe int a = 2; a le mérite d'être compatible avec le C historique.
Pour un type de base, je la trouve aussi un peu plus lisible que la nouvelle, puisqu'elle montre bien qu'on affecte explicitement une valeur initiale lors de la définition de la variable.

La nouvelle syntaxe a tout de même des avantages majeurs. Elle est unifiée, permet l'initialisation de vecteurs, et lève certaines ambiguïtés.
Si tu regardes les expressions suivantes :

Code :

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

1
2
3
4
5
//  std::vector<int> v01 = 5;   // interdit (ce n'est pas un appel à une affectation, mais à un constructeur explicite)
    std::vector<int> v02(5);    // crée un vecteur de cinq entiers initialisés à zéro
    std::vector<int> v03{5};    // crée un vecteur de un seul entier égal à 5.
    std::vector<int> v05(5,4);  // crée un vecteur de cinq entiers initialisés à 4
    std::vector<int> v04{5, 4}; // crée un vecteur de deux entiers initialisés à 5 et 4

Avec des types personnalisés :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Objet à sémantique de valeur
class MonObjet{
	int i;
public:
        // constructeur par défaut
	MonObjet(){
		i = 0;
	};
        // constructeur surchargé
	MonObjet(int j){
		i = j;
	};
        // constructeur par copie
	MonObjet(const MonObjet & ref){
		i = ref.i;
	};
        // Opérateur d'affectation
	MonObjet& operator= (const MonObjet & ref){
		i = ref.i;
	};
	~MonObjet(){};
};

Dans le code suivant, il est facile de croire qu'on utilise l'opérateur d'affectation alors qu'on utilise toujours des constructeurs.

Code :

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

1
2
3
4
5
6
7
8
9
   MonObjet o01; // appel au constructeur par défaut
 
    MonObjet o02 = 5;     // appel au constructeur surchargé
    MonObjet o03 (5);     // appel au constructeur surchargé
    MonObjet o04 { 5 };   // appel au constructeur surchargé
 
    MonObjet o05 = o01;   // appel au constructeur par copie
    MonObjet o06 ( o01 ); // appel au constructeur par copie
    MonObjet o07 { o01 }; // appel au constructeur par copie

Si on ajoute le mot clé explicit devant le constructeur surchargé, la ligne MonObjet o02 = 5; provoque une erreur.
Si on ajoute le mot clé explicit devant le constructeur par copie, la ligne MonObjet o05 = o01; provoque une erreur.

[Luc Hermitte]

L'unicorn syntax (jeu de mots volontaire) part d'une volonté d'uniformiser et simplifier des choses, mais au final on rajoute de nouveaux cas particuliers pas forcément bien venus.

Typiquement

Code C++ :

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

1
2
3
4
5
 
int a {} ; // initialisation forcée avec le constructeur par défaut, qui initialise à 0 sur les scalaires
 
std::vector<int> v1 {5, 6}; // vecteur de 2 éléments: 5 et 6
std::vector<int> v1 (5, 6); // vecteur de 5 éléments: tous des 6

Sur beaucoup de types qui en gros ne sont pas des collections, cette distinction n'existera pas et les accolades finiront par appeler les constructeurs avec même nombre d'éléments que de paramètres (compatibles)

[zancrows]

Merci pour ces explications, si je comprend bien sur les types primitifs ça n'a que peu d'incidence.

[jo_link_noir]

Sur les types primitifs, à part la vérification des bornes, non, ça ne change rien. Mais la vérification peut aussi se faire sans mettre en dur une valeur: mettre une variable de type long long dans un int va aussi donner une erreur.

Code :

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

1
2
3
4
void foo(long long x)
{
  int y {x}; // erreur
}

La syntaxe {} permet aussi d'initialiser les membres sans devoir mettre un constructeur:

Code :

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

1
2
struct Vec2 { int x,y; };
Vec2 vec2 {1,2};

[Pyramidev]

mettre une variable de type long long dans un int va aussi donner une erreur.

Code :

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

1
2
3
4
void foo(long long x)
{
  int y {x}; // erreur
}

Avec GCC 8.2.0, j'ai un avertissement quand -Wnarrowing est actif, mais pas d'erreur de compilation.
Dans la page direct initialization de en.cppreference.com, je n'ai pas vu de règle spéciale qui différenciait T object ( arg ); et T object { arg }; dans le cas où T n'était ni un type de tableau, ni une classe.

[jo_link_noir]

à mon avis, c'est plus un non-respect du standard par gcc qu'autre chose pour compiler facilement d'ancien code qui initialise directement des structures C, et c'est toujours mieux qu'aucun avertissement. Il faudrait vérifier s'il doit y avoir un diagnostic ou une erreur. Je penche pour la seconde d'après https://en.cppreference.com/w/cpp/la...nitialization:

Otherwise (if T is not a class type), if the braced-init-list has only one element and either T isn't a reference type or is a reference type that is compatible with the type of the element, T is direct-initialized (in direct-list-initialization) or copy-initialized (in copy-list-initialization), except that narrowing conversions are not allowed.

(Note: avec clang c'est une erreur)

[Pyramidev]

En effet, après avoir recherché dans N4659 (C++17 final draft), dans la section 11.6.4 List-initialization, je suis tombé sur :

Otherwise, if the initializer list has a single element of type E and either T is not a reference type or its referenced type is reference-related to E, the object or reference is initialized from that element (by copy-initialization for copy-list-initialization, or by direct-initialization for direct-list-initialization); if a narrowing conversion (see below) is required to convert the element to T, the program is ill-formed.
[ Example:

Code :

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

1
2
int x1 {2}; // OK
int x2 {2.0}; // error: narrowing

— end example ]