Les paramètres par défaut en C++ constructeurs

Question

C'est bien pratique d'avoir un constructeur de la classe qui utilise les paramètres par défaut, ou devrais-je utiliser des constructeurs surchargés? Par exemple:

// Use this...
class foo  
{
private:
    std::string name_;
    unsigned int age_;
public:
    foo(const std::string& name = "", const unsigned int age = 0) :
        name_(name),
        age_(age)
    {
        ...
    }
};

// Or this?
class foo  
{
private:
    std::string name_;
    unsigned int age_;
public:
    foo() :
    name_(""),
    age_(0)
{
}

foo(const std::string& name, const unsigned int age) :
        name_(name),
        age_(age)
    {
        ...
    }
};

La version semble fonctionner, par exemple:

foo f1;
foo f2("Name", 30);

Quel style préférez-vous ou de recommander et pourquoi?

Answer 1

Certainement une question de style. Je préfère les constructeurs avec paramètres par défaut, tant que les paramètres de sens. Classes dans l'utilisation normale aussi bien, qui parle en leur faveur.

Une chose à surveiller est que si vous avez par défaut pour tous, mais un seul paramètre, votre classe peut être implicitement converti à partir de ce type de paramètre. Découvrez ce fil pour plus d'info.

Answer 2

J'irais avec la valeur par défaut des arguments, en particulier depuis le C++ n'est pas vous laisser la chaîne de constructeurs (si vous finissez par avoir à dupliquer les initialiser la liste, et peut-être plus, pour chaque surcharge).

Cela dit, il y a quelques pièges avec des arguments par défaut, y compris le fait que les constantes peuvent être inline (et ainsi devenir une partie de votre classe binary interface). Un autre à regarder dehors pour est que l'ajout d'arguments par défaut peut tourner un explicite multi-argument du constructeur dans l'implicite d'un argument du constructeur:

class Vehicle {
public:
  Vehicle(int wheels, std::string name = "Mini");
};

Vehicle x = 5;  // this compiles just fine... did you really want it to?

Answer 3

Cette discussion s'appliquent à la fois aux constructeurs, mais aussi les méthodes et les fonctions.

Utilisant les paramètres par défaut?

La bonne chose est que vous n'aurez pas besoin de surcharger les constructeurs/méthodes/fonctions pour chaque cas:

// Header
void doSomething(int i = 25) ;

// Source
void doSomething(int i)
{
   // Do something with i
}

La mauvaise chose est que vous devez déclarer votre défaut dans l'en-tête, de sorte que vous avez masqué dépendance: Comme lorsque vous modifiez le code d'une fonction inline, si vous modifiez la valeur par défaut dans votre tête, vous aurez besoin de recompiler toutes les sources à l'aide de cet en-tête pour être sûr qu'ils vont utiliser la nouvelle valeur par défaut.

Si vous ne le faites pas, les sources de toujours utiliser l'ancienne valeur par défaut.

à l'aide de constructeurs surchargés/méthodes/fonctions?

La bonne chose est que si vos fonctions ne sont pas inline, vous contrôlez ensuite la valeur par défaut dans la source en choisissant comment une fonction va se comporter. Par exemple:

// Header
void doSomething() ;
void doSomething(int i) ;

// Source

void doSomething()
{
   doSomething(25) ;
}

void doSomething(int i)
{
   // Do something with i
}

Le problème, c'est que vous avez à gérer plusieurs constructeurs/méthodes/fonctions, et de leurs expéditions.

Answer 4

Dans mon expérience, les paramètres par défaut semblent cool à la fois et de faire ma paresse facteur heureux, mais je suis en utilisant la classe et je suis surpris quand la valeur par défaut est activé. Donc je ne pense pas vraiment que c'est une bonne idée, mieux vaut avoir un nom de classe::classe() et puis un className::init(arglist). Juste pour que la maintenabilité du bord.

Answer 5

Sam réponse donne la raison que les arguments par défaut sont préférables pour les constructeurs plutôt que de surcharger. Je veux juste ajouter que le langage C++0x permettra à la délégation d'un constructeur à l'autre, éliminant ainsi la nécessité pour les valeurs par défaut.