Pourquoi l'héritage des constructeurs n'est-il pas pris en charge par TOUS les compilateurs C++ existants?

Question

Pour l'instant, G++ et VC++ 2010 ne prennent pas en charge l'héritage des constructeurs.

Cependant, je pense que c'est l'une des fonctionnalités les plus belles de C++0x. Et je pense que ce devrait être assez facile à implémenter par le compilateur.

Pourquoi les compilateurs ne sont-ils pas intéressés par cette fonctionnalité?

Supposons que je veuille concevoir ma propre classe de chaîne en héritant de std::string comme ceci :

class MyString : public std::string
{
public:
// Je dois redéfinir de nombreux constructeurs surchargés ici et transmettre leurs arguments aux
// constructeurs de std::string. Que cela sera fastidieux !!!
};

Un bel exemple de code :

struct B1 
{
   B1(char);
};

struct B2 
{
   B2(double);
   B2(int);
};

struct D1 : B1, B2 
{
   using B1::B1; //  D1(char)
   using B2::B2;  // D1(double), D1(int)
};

D1 d('c'); //OK, invoque D1(char)

Answer 1

Il y a beaucoup de nouveaux éléments dans C++0x, et il semble que les bénévoles travaillant sur gcc ont trouvé d'autres changements plus intéressants à travailler en premier lieu.

En ce qui concerne VC++, il y a non seulement la priorisation du travail, mais également des coûts supplémentaires (souvent mentionnés sur les blogs des responsables de produits Microsoft) liés aux exigences, à la documentation et à des tests très approfondis, qui sont des parties nécessaires d'un produit qui est vendu, au-delà de simplement le faire fonctionner.

Enfin, il semble qu'il y ait eu récemment une discussion parmi le comité C++0x concernant la suppression de cette fonctionnalité, car environ 95% des cas d'utilisation ont des solutions de contournement simples.

En combinant tout cela, je ne suis pas surpris que les ingénieurs du compilateur gardent ceci pour plus tard.

Answer 2

Je ne pense pas que vous allez trouver une raison spécifique pour laquelle ils n'ont pas encore ajouté cette fonctionnalité. Le principe général est le suivant : il existe de nombreuses autres choses dans C++0x, et les développeurs de compilateurs sont généralement beaucoup plus désireux de mettre en œuvre des fonctionnalités de bibliothèque que des fonctionnalités du langage, en particulier lorsque la norme n'est pas encore finalisée et que les fonctionnalités du langage pourraient changer.

Answer 3

1. C++0x n'est pas encore une norme.
2. Ils n'ont pas assez de temps pour le mettre en œuvre.
3. Ce n'est pas aussi simple que vous le pensez. Il ne suffit pas d'appeler ces constructeurs. Le compilateur doit générer des constructeurs appropriés dans la classe dérivée afin d'initialiser les membres de la classe dérivée.

Answer 4

Il est mars 2012 et toujours aucun compilateur ne prend en charge cela.

Un constructeur de modèle variadique peut envelopper joliment les constructeurs de classe de base et vous permettrait également de substituer certains constructeurs à la volée. Cela peut ne pas bien fonctionner pour votre exemple d'héritage multiple.

class MyString: public std::string
{
public:
    template
    MyString(Args... args): std::string(args...){}
};

Answer 5

Les compilateurs implémenteront uniquement les fonctionnalités d'une version spécifique du langage. Si un compilateur prétend prendre en charge C++0x et ne prend pas en charge toutes ses fonctionnalités, alors c'est la faute du compilateur, utilisez un meilleur compilateur.

Je ne pense pas que C++0x soit encore implémenté dans les compilateurs que vous avez mentionnés.