2009-10-05 5 views
3

Je voulais Quel est le métier de constructeur fourni par compilateur? Est-ce que ce constructeur fait l'allocation de mémoire et toutes les choses nécessaires pour créer un objet.Que se passe-t-il dans le code du constructeur que le compilateur exécute et fournit le constructeur par défaut?

Je ne pose pas cette question du point de vue de l'initialisation de la variable membre. Je veux savoir ce qui se passe dans le constructeur de code par défaut que le compilateur exécute et fournit le constructeur par défaut

Répondre

5

Un constructeur par défaut est un constructeur qui n'a pas de paramètres, ou s'il a des paramètres, tous les paramètres ont des valeurs par défaut.

Si aucun constructeur défini par l'utilisateur n'existe pour une classe A et qu'une seule est nécessaire, le compilateur déclare implicitement un constructeur par défaut sans paramètre A :: A(). Ce constructeur est un membre public en ligne de sa classe. Le compilateur définira implicitement A :: A() lorsque le compilateur utilise ce constructeur pour créer un objet de type A. Le constructeur n'aura pas d'initialiseur de constructeur et un corps nul. Le compilateur définit d'abord implicitement les constructeurs déclarés implicitement des classes de base et des membres de données non statiques d'une classe A avant de définir le constructeur implicitement déclaré de A. Aucun constructeur par défaut n'est créé pour une classe ayant des membres de type constante ou référence .

Un constructeur d'une classe A est trivial si toutes les conditions suivantes sont remplies:

* It is implicitly defined 
* A has no virtual functions and no virtual base classes 
* All the direct base classes of A have trivial constructors 
* The classes of all the nonstatic data members of A have trivial constructors 

Si de ce qui précède sont fausses, le constructeur est non négligeable. Un membre d'union ne peut pas être d'un type de classe qui a un constructeur non trivial.

Comme toutes les fonctions, un constructeur peut avoir des arguments par défaut. Ils sont utilisés pour initialiser les objets membres. Si des valeurs par défaut sont fournies, les arguments de fin peuvent être omis dans la liste d'expressions du constructeur. Notez que si un constructeur a des arguments qui n'ont pas de valeur par défaut, ce n'est pas un constructeur par défaut.

Lire

Default constructors (C++ only)

+0

phoenix, merci pour la réponse quelques-uns de ce qui précède sont nouveaux pour moi:) ... mais je voulais savoir pendant la construction de l'objet ... quels sont les trucs que le compilateur fait avant que l'objet complet est créé. votre réponse est après la construction de l'objet. – mahesh

+1

Bien que les références IBM soient généralement bonnes, ce n'est pas une bonne définition: –

+0

Ce constructeur est un membre public en ligne de sa classe Même si cela est vrai (et je devrais avoir une citation de la norme pour me convaincre) ce n'est pas vraiment pertinent. –

1

quelles sont les étoffes que compilateur ne devant un objet complet est créé

Le constructeur par défaut fourni par le compilateur va effectuer les opérations suivantes:

  • Appel du constructeur par défaut du classe de base (s'il existe une classe de base)
  • Appel du constructeur par défaut pour chacun des membres de données de la classe (pour chaque membre de données ayant un constructeur, ce qui signifie pas de types primitifs) ... et si une exception est lancé par l'un d'eux, puis invoque le destructeur pour tous les membres de données déjà créés précédemment.

« un constructeur est pas tout à fait une fonction ordinaire. En particulier, il interagit avec des routines de gestion de mémoire de manière fonctions membres ordinaires ne sont pas. » : Ce type de réponse que je cherche .. si quelqu'un sait plus .. s'il vous plaît laissez-moi savoir?:)

Si vous ...

Something* something = new Something(); 

... puis qui appelle « nouvel opérateur » (et l'opérateur par défaut nouvelle va allouer de la mémoire du tas), et invoque alors le constructeur sur la mémoire nouvellement allouée. Si vous faites En variante:

Something something; 

... alors que Alloue (ou réserves) de la mémoire sur la pile, et appelle ensuite le constructeur sur le nouveau alloué/mémoire réservée. Il est similaire à toutes les autres méthodes non statiques (y compris le destructeur) dans le fait qu'il existe un pointeur "this": la différence est que lorsque le constructeur est appelé, la mémoire qui va contenir "this" a vient d'être alloué mais n'a pas encore été initialisé (ce que fait le constructeur: il initialise "this").

+0

ChrisW, Bonne réponse ...je voulais savoir ce qui se passe dans le code du constructeur qui produit le constructeur par défaut – mahesh

+0

Je ne sais pas si j'ai répondu à votre question. – ChrisW

2

Un constructeur par défaut.

Il a des paramètres zéro (ou tous ses paramètres par défaut ont), de sorte qu'un objet peut être construite sans aucun paramètre.

Si vous ne définissez pas constructeurs le compilateur va générer un constructeur par défaut pour vous.
Le compilateur généré constructeur par défaut fait (dans l'ordre suivant)

  • Appelez le constructeur par défaut de toutes les classes de base (le cas échéant, mais dans l'ordre).
  • Appelez le constructeur par défaut de chaque membre (dans l'ordre ils sont déclarés dans la classe).
    • Si le membre est un int/flotteur/char etc est indéfini.
    • Si le membre est un pointeur, il n'est pas défini.

Le constructeur de copie:

Si vous ne définissez pas un constructeur de copie alors le compilateur génère un constructeur de copie par défaut. Le compilateur
constructeur de copie générer fait (dans l'ordre suivant)

  • Appelez le constructeur de copie de toutes les classes de base (le cas échéant, mais dans l'ordre).
  • Appelez le constructeur de copie de chaque membre (dans l'ordre dans lequel ils sont déclarés dans la classe).
    • Chaque élément est passé à l'élément correspondant de l'objet en cours de copie.
    • Remarque pour les pointeurs cela signifie simplement copier la valeur du pointeur.
      C'est pourquoi nous obtenons le problème de la copie superficielle lorsque la classe contient un pointeur RAW que l'objet gère.

Bien que pas un constructeur. Il est important de noter que le compilateur générera automatiquement l'opérateur d'assignation quand celui-ci n'est pas défini.
Le compilateur généré opérateur d'affectation fait (dans l'ordre suivant)

  • Appelez le opérateur d'affectation de chaque classe de base (le cas échéant, mais dans l'ordre).
  • Appelez l'opérateur d'affectation de chaque membre (dans l'ordre où ils sont déclarés dans la classe).
    • Chaque élément est passé à l'élément correspondant de l'objet en cours de copie.
    • Remarque pour les pointeurs cela signifie simplement copier la valeur du pointeur.
      C'est pourquoi nous obtenons le problème de la copie superficielle lorsque la classe contient un pointeur RAW que l'objet gère.

Le Destructeur par défaut:
La plupart des gens pensent que le destructor est trivial ou non. Mais il est important de noter ce que fait la version par défaut (c'est légèrement plus que rien).

  • Chaque membre a son destructor appelé (en inverse ordre de déclaration)
  • Remarque int/flotteur/pointeurs ne sont pas si Destructeurs est rien fait explicite.
  • Chaque destructeur de classe de base est appelé dans l'ordre inverse.

Si vous définissez un destructeur, le comportement ne change pas. Mais le code que vous définissez dans le cadre du destructeur est exécuté avant le comportement défini ci-dessus. Donc en affect il y a toujours un destructeur juste le code est un bloc vide.

Remarque: Il existe des considérations spéciales lorsque des classes de base virtuelles sont utilisées. Mais c'est une autre question. Par conséquent, même si vous définissez une classe vide.

Le compilateur génère toujours quatre méthodes pour vous.

class X: public Z 
{ 
    int a; 
    Y b; 
    Z* c; 
}; 

// Compiler generated methods will look like this: 
X::X() 
    :Z() // Construct base class. 
    //,a?? The default construction of an int does nothing the value is undefined. 
    ,b() 
    //,c?? The default construction of a pointer does nothing, 
{} 
X::~X() 
{} // Note members are destoyed here 
    // ~c: Does nothing it is a pointer. 
    // ~b: destroyes b via Y::~Y() 
    // ~a: Does nothing as POD has not destructr. 
    // ~Z(): Destory base class. 
X::(X const& rhs) 
    :Z(rhs) 
    ,a(rhs.a) 
    ,b(rhs.b) 
    ,c(rhs.c) 
{} 
X& operator=(X const& rhs) 
{ 
    Z::operator=(rhs); 
    a = rhs.a; 
    b = rhs.b; 
    c = rhs.c; 
    return *this; 
} 
0

Voici ce que je suis arrivé de Stroustrup Livre

« un constructeur n'est pas tout à fait une fonction ordinaire En particulier, il interagit avec des routines de gestion de la mémoire en moyens des fonctions membres ordinaires ne pas. " : Ce type de réponse que je cherche .. si quelqu'un sait plus .. s'il vous plaît laissez-moi savoir? :)

+0

J'ai ajouté à ma réponse pour essayer de répondre à cela. – ChrisW

+0

Martin York et ChrisW les deux réponses semblent impressionnantes. +1 pour les deux. Mais je ne peux pas accepter à la fois la réponse que je suis censé faire – mahesh

Questions connexes