приоритет конструктора класса с вариативным конструктором шаблона для оболочки значения

Не существует такой вещи, как «правила приоритета конструктора», в конструкторах нет ничего особенного с точки зрения приоритета.

Два проблемных случая имеют одно и то же основное правило, объясняющее их:

wrapper<std::string> w0{s0};            // emplace constructor (?)
wrapper<std::string> w3{w0};            // compilation error (?)

Для w0 у нас есть два кандидата: конструктор копирования значений (который принимает std::string const&) и конструктор emplace (который принимает std::string&). Последнее лучше подходит, потому что его ссылка менее квалифицирована cv, чем ссылка конструктора копии значения (в частности, [over.ics.rank]/3). Более короткая версия этого:

template <typename T> void foo(T&&); // #1
void foo(int const&);                // #2

int i;
foo(i); // calls #1

Точно так же для w3 у нас есть два кандидата: конструктор emplace (который принимает wrapper&) и конструктор копирования (который принимает wrapper const&). Опять же, из-за того же правила предпочтительнее использовать конструктор emplace. Это приводит к ошибке компиляции, потому что value на самом деле не может быть построено из wrapper<std::string>.

Вот почему вы должны быть осторожны с пересылкой ссылок и ограничивать свои шаблоны функций! Это пункт 26 ("Избегайте перегрузки универсальных ссылок") и пункт 27 ("Ознакомьтесь с альтернативами перегрузке универсальных ссылок") в Effective Modern C++. Минимум будет:

template <typename... As,
    std::enable_if_t<std::is_constructible<T, As...>::value, int> = 0>
wrapper(As&&...);

Это позволяет w3, потому что теперь есть только один кандидат. Тот факт, что w0 размещает вместо копий, не должен иметь значения, конечный результат тот же. На самом деле, конструктор копирования значения в любом случае ничего не делает - вы должны просто удалить его.

Я бы рекомендовал этот набор конструкторов:

wrapper() = default;
wrapper(wrapper const&) = default;
wrapper(wrapper&&) = default;

// if you really want emplace, this way
template <typename A=T, typename... Args,
    std::enable_if_t<
        std::is_constructible<T, A, As...>::value &&
        !std::is_same<std::decay_t<A>, wrapper>::value
        , int> = 0>
wrapper(A&& a0, Args&&... args)
  : value(std::forward<A>(a0), std::forward<Args>(args)...)
{ }

// otherwise, just take the sink
wrapper(T v)
  : value(std::move(v))
{ }

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

Как предложил ОП, поместив мой комментарий в качестве ответа с некоторыми уточнениями.

Из-за того, как выполняется разрешение перегрузки и сопоставляются типы, тип конструктора с переменной прямой ссылкой часто выбирается как наилучшее совпадение. Это произойдет, потому что все квалификация const будет разрешена правильно и сформирует идеальное совпадение - например, при привязке ссылки const к неконстантному lvalue и тому подобному - как в вашем примере.

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

Я лично предпочитаю подход на основе тегов и использую тип тега в качестве первого аргумента для вариационного конструктора. В то время как любая структура тегов будет работать, я склонен (лениво) красть тип из С++ 17 - std::in_place. Теперь код становится:

template<class... ARGS>
Constructor(std::in_place_t, ARGS&&... args)

И чем называется

Constructor ctr(std::in_place, /* arguments */);

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

Как сказано в комментарии, проблема заключается в том, что конструктор шаблона с переменным числом аргументов принимает аргумент путем пересылки ссылки, поэтому он лучше подходит для копирования неконстантного значения lvalue или копирования константного значения rvalue.

Есть много способов отключить его, один из эффективных способов - всегда использовать тег in_place_t, как это было предложено SergeyA в его ответе. Другой способ — отключить конструктор шаблонов, когда он соответствует сигнатуре конструктора копирования, как это предлагается в известных книгах по эффективному C++.

В этом случае я предпочитаю объявлять все возможные подписи для конструкторов копирования/перемещения (а также присваивание копирования/перемещения). Таким образом, какой бы новый конструктор я ни добавил в класс, мне не придется думать о том, чтобы избежать создания копирования, это короткие 2 строки кода, легко читаемые и не загрязняющие интерфейс других конструкторов:

template <typename T>
struct wrapper
 {
   //...
   wrapper (wrapper& w0) : wrapper(as_const(w0)){}
   wrapper (const wrapper && w0) : wrapper(w0){}

 };

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

• размер объекта меньше 16 байт (или 8 байт для MSVC ABI),
• все подобъекты-члены тривиально копируются,
• эта оболочка будет передана функциям, где особое внимание уделяется случаю, когда аргумент имеет тривиально копируемый тип и его размер ниже предыдущего порога, потому что в этом случае аргумент может быть передан в регистр (или два) путем передачи аргумента по значению!

Если все эти требования выполнены, то вы можете подумать о реализации менее ремонтопригодного (подверженного ошибкам -> в следующий раз, когда вы измените код) или решения, загрязняющего интерфейс клиента!