Конструктор C++: идеальная переадресация и перегрузка

"foobar" это const char (&) [7]. Поэтому Args лучше подходит, чем const std::string&

Таким образом, эта перегрузка выбирается:

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... которого не существует.

Желаемое поведение заключается в том, что если вы создаете B с помощью конструктора, который работает для A, то вызывается «... Args конструктор» B, в противном случае вызывается другой конструктор B, в противном случае он завершается сбоем с «не найдено подходящего конструктора для B». ".

что-то вроде этого...

#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);
}

Увидев, что A не имеет соответствующего конструктора, почему бы ему не вернуться назад и не продолжить поиск других конструкторов B, которые могут совпадать? Есть ли технические причины?

В двух словах (и говоря очень просто), когда происходит разрешение перегрузки, компилятор делает следующее:

1. раскрыть все шаблонные перегрузки, которые могут соответствовать заданным аргументам. Добавьте их в список (с весом, указывающим уровень специализации, который был связан с попаданием в этот список).

2. добавьте в список любые конкретные перегрузки, которые могут быть получены путем законного применения операторов преобразования к аргументам, с весом, указывающим, сколько преобразований требуется для преобразования предоставленных аргументов в типы аргументов функции.

3. сортировать списки по возрастанию «работы» или веса.

4. выберите тот, который требует наименьшей работы. Если есть ничья, для которой лучше всего, ошибка.

Компилятор делает это один раз. Это не рекурсивный поиск.

Заранее приношу свои извинения пуристам среди нас, которым это детское объяснение покажется оскорбительным :-)

Опция 1

Наследовать конструкторы от класса A:

struct B : A 
{
    using A::A;
//  ~~~~~~~~~^

    B(const std::string& a, int b) : A(a), p(b) {}

    int p = 0;
};

Вариант №2

Сделайте вариативный конструктор B SFINAE-способным:

#include <utility>

struct B : A
{
    template <typename... Args, typename = decltype(A(std::declval<Args>()...))>
    //                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
    B(Args&&... args) : A(std::forward<Args>(args)...) {}

    B(const std::string& a, int b) : A(a), p(b) {}

    B(B& b) : B(static_cast<const B&>(b)) {}
    B(const B& b) : A(b) {}

    int p = 0;
};

Не вдаваясь в подробности, конструктор переадресации почти всегда предпочтительнее. Его даже можно предпочесть конструктору копирования.

Один из способов избежать этой двусмысленности состоит в том, чтобы заставить вызывающую сторону явно выбрать, нужен ли им конструктор пересылки, с помощью фиктивного параметра:

struct B : A
{
    enum dummy_t { forwarding };
    // ...

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

с использованием образца:

B b2("foobar", 1);
B b(B::forwarding, "foobar");

Тогда у вас даже могут быть конструкторы A и B с одинаковыми параметрами.

Альтернативным решением вашей проблемы было бы написать using A::A; в определении B. Это похоже на предоставление B набора конструкторов, соответствующих A, и они инициализируют A, вызывая соответствующий конструктор A с теми же аргументами.

Конечно, это имеет некоторые недостатки, например. вы не можете одновременно инициализировать другие элементы B. Дополнительная литература