Ne les parenthèses après le nom du type de faire la différence avec les nouveaux?

Si "Test" est une classe ordinaire, quelle est la différence entre:

Test* test = new Test;

et

Test* test = new Test();
Ceci est lié à (mais non identiques) stackoverflow.com/questions/1613341/...
Juste l'utilisation d'un nouveau Test() pour vous assurer qu'il est initialisé à zéro

OriginalL'auteur David Read | 2009-03-06

  1. 906

    Let's get pédant, car il y a des différences qui peuvent effectivement affecter votre comportement du code. Beaucoup de ce qui suit est tiré des observations à un "Le vieux Chose de Nouveau" l'article.

    Parfois la mémoire renvoyée par le nouvel opérateur sera initialisé, et parfois, il ne sera pas selon que le type que vous êtes newing est un POD (plain old données), ou si c'est une classe qui contient POD membres et est à l'aide d'un générées par le compilateur par défaut du constructeur.

    • En C++1998 il y a 2 types d'initialisation: zéro par défaut et
    • En C++2003 une 3ème type d'initialisation, la valeur d'initialisation a été ajouté.

    Assumer:

    struct A { int m; }; //POD
struct B { ~B(); int m; }; //non-POD, compiler generated default ctor
struct C { C() : m() {}; ~C(); int m; }; //non-POD, default-initialising m

    En C++98 compilateur, les conditions suivantes se produisent:

    • new A - une valeur indéterminée

    • new A() - zéro-initialiser

    • new B par défaut de construire (B::m est non initialisée)

    • new B() par défaut de construire (B::m est non initialisée)

    • new C par défaut de construire (C::m est initialisé à zéro)

    • new C() par défaut de construire (C::m est initialisé à zéro)

    En C++03 conforme compilateur, les choses devraient fonctionner de la sorte:

    • new A - une valeur indéterminée

    • new A() - valeur-initialiser Un, qui est à zéro de l'initialisation puisque c'est un POD.

    • new B - par défaut-initialise (feuilles de B::m non initialisée)

    • new B() - valeur-initialise B zéro-initialise tous les domaines depuis son par défaut ctor est généré par le compilateur, plutôt que définis par l'utilisateur.

    • new C - par défaut-initialise C, qui appelle à la valeur par défaut ctor.

    • new C() - valeur-initialise C, qui appelle à la valeur par défaut ctor.

    Donc, dans toutes les versions de C++ il y a une différence entre new A et new A() parce que l'Un est une GOUSSE.

    Et il y a une différence de comportement entre C++98 et C++03 pour le cas new B().

    C'est l'un des coins poussiéreux de C++ qui peut vous rendre fou. Lors de la construction d'un objet, parfois, vous voulez/besoin parens, parfois, vous ne pouvez absolument pas, et parfois il n'a pas d'importance.

    Un() par défaut d'initialisation de l'objet en C++98, comme il le fait avec new B(), new B, new C() et new C, mais pas avec new A. C'est, d'initialisation par défaut est toujours fait en C++98 lorsque: 1) La classe est un non-POD et l'initialiseur est manquant, ou 2) L'initialiseur est (). par défaut-initialisation du zéro-initialise l'objet, si c'est un POD, mais appelle le constructeur par défaut pour les non-Gousses.
    Quelqu'un peut-il ajouter ce qui est le cas en C++11?
    Avec C++11, vous pouvez le faire dans la pile trop; B obj{}; fera la valeur de l'objet-initialisé à 0), par opposition à B obj; qui sera par défaut-initialisé (ordures ménagères).
    Eh bien, je dirais que ça dépend. Pas toutes les classes sont écrites pour la consommation extérieure où le client est certain Joe codeur qui ne savent pas; certaines classes sont écrites pour un interne de la bibliothèque de la consommation, dans de tels cas, je pense aller avec POD est mieux, mais dans les cas où il est absolument nécessaire de toujours initialiser vars dans un état particulier (et perf. n'est pas un problème) puis ctor semble être mieux.
    Autant que je sache, en faisant = par défaut; vous êtes explicitement de fournir un constructeur (même quand il est généré par le compilateur, de sorte que vous êtes dans le cas B). Si vous ne fournissez pas un constructeur, le compilateur peut implicitement générer de toute façon (vous restez dans le cas A). Le résultat est le même: nouveau A/B -> initialisation par défaut, la nouvelle A/B() -> valeur d'initialisation à zéro. Toutefois, en C++11, vous ne devriez pas envisager de Gousses, mais des agrégats...

    OriginalL'auteur Michael Burr

  2. 56

    new Thing(); est explicite que vous voulez un constructeur appelé alors que new Thing; est à dire que vous n'avez pas l'esprit si le constructeur n'est pas appelé.

    Si utilisé sur une struct/classe avec un constructeur, il n'y a pas de différence. Si elle est appelée sur un trivial struct/classe (par exemple struct Thing { int i; };) puis new Thing; est comme malloc(sizeof(Thing)); alors que new Thing(); est comme calloc(sizeof(Thing)); - il est initialisé à zéro.

    Gotcha se situe dans l'entre-deux:

    struct Thingy {
  ~Thingy(); //No-longer a trivial class
  virtual WaxOn();
  int i;
};

    Le comportement de new Thingy; vs new Thingy(); dans ce cas changé entre C++98 et C++2003. Voir Michael Burr explication du comment et du pourquoi.

    OriginalL'auteur kfsone

  3. 19

    Non, ils sont les mêmes. Mais il y a une différence entre:

    Test t;      //create a Test called t

    et

    Test t();   //declare a function called t which returns a Test

    C'est parce que de base de C++ (et C) de la règle: Si quelque chose peut éventuellement être une déclaration, puis c'est une déclaration.

    Edit: Ré initialisation des questions concernant la GOUSSE et de la non-POD de données, alors que je suis d'accord avec tout ce qui a été dit, je voudrais juste souligner que ces questions ne s'appliquent que si la chose nouvelle avait ou autrement construit n'est pas définie par l'utilisateur et le constructeur. S'il est un constructeur qu'il sera utilisé. Pour 99,99% des intelligemment conçu classes, il y aura un tel constructeur, et afin que les problèmes peuvent être ignorés.

    Notez que ceci est un point particulièrement important parce que la ligne "Test t(5);" est équivalent à "Test t = Test(5);" -- mais "Test t();" est très différent de "Test t = Test();". +1
    -1, je suis en désaccord avec votre affirmation que les questions peuvent être ignorés. Vous n'avez pas à connaître les règles de la précision, mais vous devriez être au courant d'entre eux dans le cas où vous avez à nouveau une classe sans que l'utilisateur par défaut définis par le constructeur (vous devez ensuite écrire le constructeur ou consultez les règles).
    -1 pour un réponse incorrecte. Votre Modifier ignore la présence de code écrit par d'anciens programmeurs C qui ne voulait pas comprendre/utiliser des constructeurs.
    Ce que les classes comme struct point { float v[3]; };? Pour des choses comme ça, un constructeur serait une mauvaise idée, car cela empêche toutes les belles propriétés qui viennent d'être POD et d'agrégation. Ainsi, "les questions peuvent être ignorés" est tout simplement faux, de l'omi.
    Mais ils ne sont pas les mêmes. Cette réponse est simplement faux. Il devrait être corrigés ou supprimés, parce qu'il semble avoir provoqué une certaine confusion, à en juger par le nombre élevé de votes.

    OriginalL'auteur

  4. 16

    En général, nous avons défaut d'initialisation dans le premier cas, et la valeur d'initialisation dans le second cas.

    Par exemple:
    dans le cas de l'int (type POD):

    • int* test = new int - nous avons tout d'initialisation et de la valeur de *test peut être tout.

    • int* test = new int() - *test aura la valeur 0.

    prochaine comportement dépendait de votre type de Test.
    Nous avons defferent cas: le Test en défaut constructeur, Test ont généré constructeur par défaut, Test contiennent POD membre, non POD membre...

    OriginalL'auteur bayda

  5. 10

    En supposant que le Test est une classe avec un constructeur, il n'y a pas de différence. La dernière forme le rend un peu plus clair que le Test du constructeur est en cours d'exécution, mais c'est tout.

    OriginalL'auteur Evan Shaw