键入用于复制cv引用限定符的trait

我还没有遇到任何需要类似类型特征的用例，我也不知道有任何建议。因此，我只能提供一个更紧凑、IMHO更易于理解的实现：

template<typename T,typename U>
struct copy_cv_reference
{
private:
    using R = std::remove_reference_t<T>;
    using U1 = std::conditional_t<std::is_const<R>::value, std::add_const_t<U>, U>;
    using U2 = std::conditional_t<std::is_volatile<R>::value, std::add_volatile_t<U1>, U1>;
    using U3 = std::conditional_t<std::is_lvalue_reference<T>::value, std::add_lvalue_reference_t<U2>, U2>;
    using U4 = std::conditional_t<std::is_rvalue_reference<T>::value, std::add_rvalue_reference_t<U3>, U3>;
public:
    using type = U4;
};
template<typename T,typename U>
using copy_cv_reference_t = typename copy_cv_reference<T,U>::type;

实时示例

你是否觉得这是一种进步是主观的。

我建议您将特性/元函数分解为两部分。首先，它很好地分离了关注点：传播cv限定符和传播ref限定符这两项任务确实不同。我有时也会单独使用这两者。例如，指针qualifying_cv_of_t<A, B>*不时出现，在这种情况下，我们绝对不希望指向引用的指针无效。（我的性状被命名为qualifying_*_of_t<A, B>，可以理解为"A的相关性质符合B的相关性质"。）

其次，后一个特点是相当棘手。也许你想机械地复制顶级引用（如果有的话），在这种情况下就没有什么好说的了

[…]某种展开（例如，对于变量、可选、元组等）[…]

这无疑是我使用它的场景之一。我决定的一件事是，它实际上不是我关心的引用，而是价值类别。也就是说，qualifying_t<X, Y>（传播一切的那个）在概念上表示decltype(expr.member)†，其中expr具有类型

struct X { Y member; };

可能简历合格。这种特性使写成为可能

template<typename T> qualifying_t<T, U> foo(T&& t)
{ return std::forward<T>(t).u; }

正确地（假设u确实具有类型U），即使例如U是参考类型。那么，这有多棘手？好吧，就连标准委员会也还没有弄清楚C++14的所有细节→C++1z转换以修复C++11中引入的错误→C++14转换。我不会详细说明解决方案，因为我不认为一刀切：例如，std::tuple_element_t和std::get形成了一个非常相似的特征/功能模板对，它的作用与我上面概述的不同。

好的一面是，你可以根据需要写尽可能多的特质，并将其与你的qualifying_cv_of相结合，你就可以继续了（事实上，我自己也有两个这样的特质！）。所以，也许真正的答案不是把特质一分为二，而是你需要多少。

†：敏锐的眼睛可能注意到了这里的一些东西，反而会认为是decltype( (expr.member) )。至于哪一个更可取，或者为什么，我还没有一个令人满意的答案。

这里是一个boost::hana风格的系统，用于限定符，而不是引用。

enum class qualifier:unsigned char {
  none,
  is_const = 1<<1,
  is_volatile = 1<<2,
};
constexpr inline qualifier operator|(qualifier lhs,qualifier rhs){
  return qualifier( unsigned(lhs)|unsigned(rhs) );
}
constexpr inline bool operator&(qualifier lhs,qualifier rhs){
  return unsigned(lhs)&unsigned(rhs);
}
// not a simple alias to make operator overloading work right:
template<qualifier q>
struct qual_t:std::integral_constant<qualifier,q> {};
template<qualifier lhs, qualifier rhs>
constexpr qual_t<lhs|rhs> operator|(qual_t<lhs>,qual_t<rhs>){return {};}

template<class T>struct tag{using type=T;};
template<class Tag>using type_t=typename Tag::type;
template<class T>
constexpr qual_t<
  (std::is_const<T>{}?qualifier::is_const:qualifier::none)
 |(std::is_volatile<T>{}?qualifier::is_volatile:qualifier::none)
> qual(tag<T>={}){ return {}; }
template<class B, qualifier q,
  class Step1=std::conditional_t<q&qualifier::is_const,const B,B>,
  class R=std::conditional_t<q&qualifier::is_volatile,volatile Step1, Step1>
>
constexpr tag<R> add_qual( tag<B>={}, qual_t<q>={} ){ return {}; }
template<class T,qualifier Q>
auto operator+( tag<T> t, qual_t<Q> q ){
  return add_qual(t,q);
}
template<class B, qualifier q>
using add_qual_t=type_t<decltype(tag<B>{}+qual_t<q>{})>;

使用以上内容，您可以使用tag<T>类型或原始类型。

将参考资料从限定词中分离出来对我来说很有意义。

想看副本吗？

template<class From, class To>
constexpr auto copy_qual(tag<From> from={}, tag<To> to={}){
  return to + qual(from);
}

可以转换为以下类型：

template<class From, class To>
using copy_qual_t=type_t<decltype(copy_qual<From,To>())>;

有点难看。

我们可以用参考做完全相同的事情

enum class ref_qualifier:unsigned char {
  none,
  rvalue,
  lvalue
};

包括参考折叠

constexpr inline ref_qualfier operator|(ref_qualifier lhs, ref_qualifier rhs){
  return ((unsigned)lhs>(unsigned)rhs)?lhs:rhs;
}
constexpr inline ref_qualfier operator&(ref_qualifier lhs, ref_qualifier rhs){
  return ((unsigned)lhs>(unsigned)rhs)?rhs:lhs;
}

等等。（左值和右值限定符都以左值结尾）

我们可以写add_ref_qual和sub_ref_qual，用tag s过载+和-。

template<class From, class To>
constexpr auto copy_ref_and_quals( tag<From> from, tag<To> to ) {
  auto from_ref = ref_qual(from);
  auto from_cv = qual(from-from_ref);
  auto to_ref = ref_qual(to);
  return (to-to_ref)+from_cv+to_ref+from_ref;
}

其中，我们将ref资格剥离到，然后添加from的cv资格，然后添加回from和to的ref资格。

以下是您的问题的即插即用解决方案：

#include<type_traits>
#include<cstddef>
static const std::size_t N = 42;
template<std::size_t N>
struct choice: choice<N-1> {};
template<>
struct choice<0> {};
template<typename T, typename U>
struct types {
    using basic = T;
    using decorated = U;
};
template<typename T, typename U>
auto f(choice<0>) { return types<T, U>{}; }
template<typename T, typename U, typename = std::enable_if_t<std::is_lvalue_reference<T>::value>>
auto f(choice<1>) {
    auto t = f<std::remove_reference_t<T>, U>(choice<N>{});
    using B = typename decltype(t)::basic;
    using D = typename decltype(t)::decorated;
    return types<B, std::add_lvalue_reference_t<D>>{};
}
template<typename T, typename U, typename = std::enable_if_t<std::is_rvalue_reference<T>::value>>
auto f(choice<2>) {
    auto t = f<std::remove_reference_t<T>, U>(choice<N>{});
    using B = typename decltype(t)::basic;
    using D = typename decltype(t)::decorated;
    return types<B, std::add_rvalue_reference_t<D>>{};
}
template<typename T, typename U, typename = std::enable_if_t<std::is_const<T>::value>>
auto f(choice<3>) {
    auto t = f<std::remove_const_t<T>, U>(choice<N>{});
    using B = typename decltype(t)::basic;
    using D = typename decltype(t)::decorated;
    return types<B, std::add_const_t<D>>{};
}
template<typename T, typename U, typename = std::enable_if_t<std::is_volatile<T>::value>>
auto f(choice<4>) {
    auto t = f<std::remove_volatile_t<T>, U>(choice<N>{});
    using B = typename decltype(t)::basic;
    using D = typename decltype(t)::decorated;
    return types<B, std::add_volatile_t<D>>{};
}
template<typename T, typename U>
auto f() {
    return f<T, U>(choice<N>{});
}
template<typename T, typename U = char>
using copy_cv_reference_t = typename decltype(f<T, U>())::decorated;
struct A;
struct B;
int main() {
    static_assert(std::is_same< copy_cv_reference_t<          A         , B >,          B          >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t<          A const   , B >,          B const    >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t< volatile A         , B >, volatile B          >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t< volatile A const   , B >, volatile B const    >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t<          A        &, B >,          B        & >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t<          A const  &, B >,          B const  & >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t< volatile A        &, B >, volatile B        & >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t< volatile A const  &, B >, volatile B const  & >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t<          A       &&, B >,          B       && >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t<          A const &&, B >,          B const && >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t< volatile A       &&, B >, volatile B       && >{}, "!");
    static_assert(std::is_same< copy_cv_reference_t< volatile A const &&, B >, volatile B const && >{}, "!");
}

实现这一点的一种简洁方法是使用一个小助手实用程序，该实用程序基于某些条件应用元函数：

template <template <typename...> class MFn, bool condition, typename T>
using apply_if_t = std::conditional_t<condition, MFn<T>, T>;

这使我们能够组合不同的cvref限定符：

template <typename T>
using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
template <typename From, typename To>
using copy_cv_t =
    apply_if_t<std::add_volatile_t, std::is_volatile_v<From>,
        apply_if_t<std::add_const_t, std::is_const_v<From>,
            std::remove_cv_t<To>>>;
template <typename From, typename To>
using copy_ref_t =
    apply_if_t<std::add_rvalue_reference_t, std::is_rvalue_reference_t<From>,
        apply_if_t<std::add_lvalue_reference_t, std::is_lvalue_reference_t<From>,
            std::remove_reference_t<To>>>;
template <typename From, typename To>
using copy_cvref_t = copy_ref_t<From,
    copy_cv_t<std::remove_reference_t<From>, remove_cvref_t<To>>>;