C构造函数：完美的转发和过载

因此,选择了这个重载：

template<typename... Args>
B(Args&&... args) : A(std::forward<Args>(args)...) {}

其中Args是const char(&)[7]

所以它变成：

B(const char (&&args_0) [7],int&& args_1)

转发给A的2参数构造函数…它不存在.

The wanted behavior is that if you construct a B with a constructor that works for A then the “…Args constructor” of B is called,otherwise another constructor of B gets called,otherwise it fails with “no appropriate constructor for B found”.

像这样的东西……

#include <utility>
#include <string>

struct A {
    A(std::string a) : name(std::move(a)) {}
    A(){}
    virtual ~A(){}

    std::string name;
};

template<class...T> struct can_construct_A
{
    template<class...Args> static auto test(Args&&...args)
    -> decltype(A(std::declval<Args>()...),void(),std::true_type());

    template<class...Args> static auto test(...) -> std::false_type;

    using type = decltype(test(std::declval<T>()...));
    static constexpr bool value = decltype(test(std::declval<T>()...))::value;
};

struct B : public A {

    template<class...Args>
    B(std::true_type a_constructable,Args&&...args)
    : A(std::forward<Args>(args)...)
    {}

    template<class Arg1,class Arg2>
    B(std::false_type a_constructable,Arg1&& a1,Arg2&& a2)
    : A(std::forward<Arg1>(a1)),p(std::forward<Arg2>(a2))
    {
    }

    template<typename... Args>
    B(Args&&... args)
    : B(typename can_construct_A<Args&&...>::type(),std::forward<Args>(args)...) {}

    int p = 0;
};

int main()
{
    B b1("foo");
    B b2("foobar",1);
}

After seeing that A doesn’t have a matching constructor,why doesn’t it go back and continue looking for other constructors of B that might match? Are there technical reasons?

简而言之(并且非常简单地说),当发生重载解析时,编译器会执行以下操作：

>展开所有可能与给定参数匹配的模板化重载.将它们添加到列表中(权重指示到达此处所涉及的专业化级别).
>将任何具体的重载添加到列表中,通过合法地将转换运算符应用于参数,并使用权重指示将提供的参数转换为函数参数类型所需的转换次数.
>通过提升“工作”或重量对列表进行排序.
>选择需要最少工作的人.如果有一个最好的领带,错误.

编译器得到了一个.这不是递归搜索.

我向我们中的纯粹主义者道歉,他们会发现这种幼稚的解释令人反感:-)