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

Question

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

Test* test = new Test;
//and
Test* test = new Test();

Answer 1

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 "Vieux Chose de Nouveau" de 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 et par défaut
• En C++2003 une 3ème type d'initialisation, la valeur d'initialisation a été ajouté.

Supposons:

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:

• nouvelle une valeur indéterminée

• new A() - zéro-initialiser

• nouveau B - défaut de construire (B::m est non initialisée)

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

• nouveau C - 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:

• nouvelle une valeur indéterminée

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

• nouveau B - 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.

• 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.

Ainsi, dans toutes les versions de C++ il y a une différence entre "new A" et "new A()" parce que 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.

Answer 2

new Thing(); est explicite que vous voulez un constructeur appelé alors qu' 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; };) alors new Thing; , c'est comme malloc(sizeof(Thing)); alors qu' new Thing(); , c'est comme calloc(sizeof(Thing)); - il est initialisé à zéro.

Le piège réside dans l'entre-deux:

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

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

Answer 3

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.

suivant le 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...

Answer 4

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.