web-dev-qa-db-fra.com

Différentes façons d'initialiser un objet en c ++

Je suis presque sûr que c'est une question en double, mais je cherche depuis un moment et je ne suis pas devenu plus intelligent.

Imaginez cette classe:

class Entity {
public:
    int x, y;

    Entity() : x(0), y(0) { }
    Entity(int x, int y) : x(x), y(y) { }
}

Et voici plusieurs façons d'initialiser la classe:

Entity ent1;
Entity ent2();
Entity ent3(1, 2);
Entity ent4 = Entity();
Entity ent5 = Entity(2, 3);

Je sais aussi que c'est possible de faire un objet sur la mémoire du tas, mais ce n'est pas un grand mystère pour moi en ce moment.

Voici ce que je pense savoir

ent1 - Utilise le constructeur par défaut, donc x = 0 et y = 0

ent2 - Utilise le constructeur par défaut, donc x = 0 et y = 0 (Pas sûr)

ent3 - Constructeur construit, donc x = 1 et y = 2

ent4 - Constructeur par défaut, donc x = 0 et y = 0

ent5 - Constructeur construit, donc x = 2 et y = 3

Corrige moi si je me trompe. Mais ma question est, quelle est la différence entre ces façons d'initialiser un objet?

Je ne sais pas lequel utiliser quand.

c++classc++11constructorinitialization
7
user6346900
Entity ent1;

Cette instruction utilise le constructeur par défaut de la classe Entity.

Entity ent2();

Cette définition sera traitée par le compilateur comme un prototype de fonction si cela est possible.

Entity ent3(1, 2);

Le constructeur défini par l'utilisateur est appelé pour ent3.

Entity ent4 = Entity();

Ceci est une version propre de ent2 Cas. Le constructeur par défaut est appelé dans le cadre de l'initialisation de la valeur. Sa forme permet d'éviter Most Vexing Parse - principe de résolution d'ambiguïté qui rend ent2 Incorrect.

Entity ent5 = Entity(2, 3);

Une version du boîtier ent3. Constructeur défini par l'utilisateur appelé dans le cadre de l'initialisation de la valeur.

Votre question est étiquetée comme C++ 11 et C++ 11 permet une syntaxe d'initialisation uniforme:

Entity ent12{};     // This is a legal alternative of ent2 case
Entity ent13{1, 2};
Entity ent14 = {};
Entity ent15 = Entity{2, 3};

Notez que la syntaxe d'initialisation uniforme a une mise en garde. Par exemple. cette ligne

std::vector<int> v(10);

déclare un vecteur de 10 éléments. Mais celui-ci

std::vector<int> v{10};

déclare un vecteur initialisé avec un seul élément de type int avec la valeur 10. Cela se produit parce que std::vector a un constructeur avec la signature suivante définie:

vector( std::initializer_list<T> init, const Allocator& alloc = Allocator() );

Dans le cas où vous ne pouvez pas utiliser ni () sans déclencher MVP ni {} sans invoquer un constructeur indésirable, la syntaxe d'affectation d'initialisation de valeur permet de résoudre le problème.

12
Swift - Friday Pie