Блог

Если я пишу универсальную функцию, которая пересылает аргументы в конструктор, есть ли способ определить, является ли это конструктором копирования? По сути, я хочу сделать:

 template <typename T, typename... Args>
void CreateTAndDoSomething(Argsamp;amp;... args) {
  // Special case: if this is copy construction, do something different.
  if constexpr (...) { ... }

  // Otherwise do something else.
  ...
}
  

Лучшее, что я придумал, — это проверка sizeof...(args) == 1 , а затем просмотр std::is_same_v<Args..., const Tamp;> || std::is_same_v<Args..., Tamp;> . Но я думаю, что это упускает крайние случаи, такие как входные данные с изменяемыми параметрами и вещи, которые неявно конвертируются T .

Честно говоря, я не совсем уверен, что этот вопрос четко определен, поэтому не стесняйтесь сказать мне, что это не так (и почему). Если это поможет, вы можете предположить, что единственными конструкторами с одним аргументом для T являются T(const Tamp;) и T(Tamp;amp;) .

Если я прав, что это не определено четко, потому что конструктор копирования не является вещью, то, возможно, это можно сделать более точным, сказав: «как я могу определить T(std::forward<Args>(args)...) , выбирает ли выражение перегрузку, которая принимает const Tamp; ?

Вы можете использовать remove_cv_t:

 #include <type_traits>

template <typename T, typename... Args>
void CreateTAndDoSomething(Argsamp;amp;... args) {
  // Special case: if this is copy construction, do something different.
  if constexpr (sizeof...(Args) == 1 amp;amp; is_same_v<Tamp;, remove_cv_t<Args...> >) { ... }

  // Otherwise do something else.
  ...
}
  

Это охватывает все «конструкторы копирования», определенные стандартом, не учитывая возможные аргументы по умолчанию (трудно определить, является ли данный параметр функции — для функции, которая будет вызвана с учетом этих параметров — по умолчанию или нет).

У вас была правильная идея. Все, что необходимо, закодировано в выведенном типе Args . Хотя, если вы хотите учесть все случаи, указанные в резюме, вам придется многое пройти. Давайте сначала рассмотрим различные случаи, которые могут возникнуть:

1. Построение (неявные преобразования — это построение)
2. Построение копирования (обычно T(const Tamp;) )
3. Перемещение конструкции (обычно T(Tamp;amp;) )
4. Нарезка (вызов Base(const Baseamp;) или Base(Baseamp;amp;) с Derived помощью)

Если странные конструкторы перемещения или копирования не рассматриваются (с параметрами по умолчанию), случаи 2-4 могут произойти только при передаче одного аргумента, все остальное является конструкцией. Следовательно, разумно обеспечить перегрузку для случая с одним аргументом. Попытка выполнить все эти случаи в шаблоне variadic будет некрасивой, так как вам нужно использовать выражения fold или что-то в этом роде std::conjuction/std::disjuction , чтобы if операторы были действительными.

Мы также узнаем, что распознавание перемещения и копирования по отдельности в каждом отдельном случае невозможно. Если нет необходимости рассматривать копии и перемещения отдельно, решение простое. Но если эти случаи необходимо разделить, можно только сделать хорошее предположение, которое должно работать почти всегда.

Что касается нарезки, я бы, вероятно, предпочел отключить ее с помощью a static_assert .

Комбинированное перемещение и копирование

Вот решение, использующее перегрузку одного аргумента. Давайте рассмотрим это подробно далее.

 #include <utility>
#include <type_trait>
#include <iostream>


// Multi-argument case is almost always construction
template<typename T, typename... Args>
void CreateTAndDoSomething(Argsamp;amp;... args)
{   
    std::cout << "Constructed" << 'n';
    T val(std::forward<Args>(args)...);
}

template<typename T, typename U>
void CreateTAndDoSomething(Uamp;amp; arg)
{
    // U without references and cv-qualifiers
    // std::remove_cvref_t in C  20
    using StrippedU = std::remove_cv_t<std::remove_reference_t<U>>;

    // Extra check is needed because T is a base for itself
    static_assert(
        std::is_same_v<StrippedU, T> || !std::is_base_of_v<T, StrippedU>, 
        "Attempting to slice"
    );
    
    if constexpr (std::is_same_v<StrippedU, T>)
    {
        std::cout << "Copied or moved" << 'n';
    }
    else
    {
        std::cout << "Constructed" << 'n';
    }
    
    T val(std::forward<U>(arg));
}
  

Здесь мы используем тот факт, что Uamp;amp; (и Argsamp;amp; ) является ссылкой пересылки. При пересылке ссылок выводимый аргумент шаблона U отличается в зависимости от категории передаваемого значения arg . Учитывая arg тип T , U выводится так, что:

• Если arg было значение lvalue, выводится U Tamp; значение (включая cv-квалификаторы).
• Если arg это было значение rvalue, выводится U T значение (включая cv-квалификаторы).

ПРИМЕЧАНИЕ: U может привести к ссылке, соответствующей cv (например. ). удаляет только const Fooamp; std::remove_cv cv-квалификаторы верхнего уровня, а ссылки не могут иметь cv-квалификаторы верхнего уровня. Вот почему std::remove_cv необходимо применять к не ссылочному типу. Если бы std::remove_cv использовался только, шаблон не смог бы распознать случаи, когда U было бы const Tamp; , volatile Tamp; или const volatile Tamp; .

 template<typename T, typename U>
void CreateTAndDoSomething(Uamp;amp; arg)
{
    // U without references and cv-qualifiers
    // std::remove_cvref_t in C  20
    using StrippedU = std::remove_cv_t<std::remove_reference_t<U>>;

    // Extra check is needed because T is a base for itself
    static_assert(
        std::is_same_v<StrippedU, T> || !std::is_base_of_v<T, StrippedU>, 
        "Attempting to slice"
    );
    
    if constexpr (std::is_same_v<Tamp;, U> 
        || std::is_same_v<const Tamp;, U>
        || std::is_same_v<volatile Tamp;, U>
        || std::is_same_v<const volatile Tamp;, U>)
    {
        std::cout << "Copied" << 'n';
    }
    else
    {
        std::cout << "Constructed" << 'n';
    }
    
    T val(std::forward<U>(arg));
}
  

 template<typename T, typename U>
void CreateTAndDoSomething(Uamp;amp; arg)
{
    // U without references and cv-qualifiers
    using StrippedU = std::remove_cv_t<std::remove_reference_t<U>>;
    
    // Extra check is needed because T is a base for itself
    static_assert(
        std::is_same_v<StrippedU, T> || !std::is_base_of_v<T, StrippedU>, 
        "Attempting to slice"
    );
    
    if constexpr (std::is_same_v<std::remove_volatile_t<U>, T>)
    {
        std::cout << "Moved (usually)" << 'n';
    }
    else if constexpr (std::is_same_v<StrippedU, T>)
    {
        std::cout << "Copied (usually)" << 'n';
    }
    else
    {
        std::cout << "Constructed" << 'n';
    }
    
    T val(std::forward<U>(arg));
}