Sont les constructeurs variadique censés cacher ceux générés implicitement?

Question

sont des constructeurs variadique censés cacher ceux générés implicitement, à savoir le constructeur par défaut et le constructeur de copie?

struct Foo
{
    template<typename... Args> Foo(Args&&... x)
    {
        std::cout << "inside the variadic constructor\n";
    }
};

int main()
{
    Foo a;
    Foo b(a);
}

D'une certaine façon je me attendais à ce pour imprimer rien après avoir lu cette réponse, mais il imprime inside the variadic constructor deux fois sur g ++ 4.5.0 :( Est-ce un comportement correct?

---

Il arrive aussi sans modèles variadique:

struct Foo
{
    Foo()
    {
        std::cout << "inside the nullary constructor\n";
    }

    template<typename A> Foo(A&& x)
    {
        std::cout << "inside the unary constructor\n";
    }
};

int main()
{
    Foo a;
    Foo b(a);
}

Encore une fois, les deux lignes sont imprimées.

Answer 1

Déclaration du constructeur de copie est déclarée implicitement pas, en fait, être supprimé. Il est tout simplement pas être appelé en raison des règles de résolution de surcharge.

Le constructeur de copie implicitement déclaré a la forme Foo(const Foo&). La partie importante est que cela prend une référence const. Votre modèle de constructeur prend une référence non-const.

a n'est pas const, de sorte que le modèle de constructeur déclaré utilisateur non-const est préféré au constructeur de copie implicitement déclarée. Pour appeler le constructeur de copie implicitement déclarée, vous pouvez faire a const:

const Foo a;
Foo b(a);

ou vous pouvez utiliser static_cast pour obtenir une référence const à a:

Foo a;
Foo b(static_cast<const Foo&>(a));

Les règles de résolution de surcharge qui décrivent ce se trouvent principalement dans §13.3.3.2 / 3 du C ++ 0x FCD. Ce scénario particulier, avec une combinaison de références lvalue et rvalue, est en quelque sorte décrit par les différents exemples à la page 303.

---

Un modèle constructeur variadique supprimera le constructeur par défaut déclaré implicitement parce qu'un modèle de constructeur variadique est déclaré par l'utilisateur et le constructeur par défaut déclaré implicitement est prévu que s'il n'y a pas de constructeurs déclarés par l'utilisateur (C ++ 0x FCD §12.1 / 5 ):

S'il n'y a pas de constructeur déclaré par l'utilisateur pour X de classe, un constructeur ayant aucun paramètre est implicitement déclaré en défaut.

Un modèle constructeur variadic ne sera pas supprimer le constructeur de copie déclaré implicitement donné que seul un constructeur non-modèle peut être un constructeur de copie (C ++ 0x FCD §12.8 / 2, 3 et 8):

Un constructeur non-modèle pour X de classe est un constructeur de copie si son fi premier paramètre est de type X&, const X&, volatile X& ou const volatile X&, et soit il n'y a pas d'autres paramètres ou bien tous les autres paramètres ont des arguments par défaut.

Un constructeur non-modèle pour X de classe est un constructeur de déplacement si son fi premier paramètre est de type X&&, const X&&, volatile X&& ou const volatile X&&, et soit il n'y a pas d'autres paramètres ou bien tous les autres paramètres ont des arguments par défaut.

Si la classe de définition fi ne déclare pas explicitement un constructeur de copie et il n'y a pas de constructeur de déplacement déclaré par l'utilisateur, un constructeur de copie est implicitement déclarée en défaut.