C++泛型编程学习 std::declval void_t

void_t 判断 类型是否存在

class T
{
    public:
    int test(){int a = 1;}
}
std::declval:将任何一个类型T转换成引用类型， 在不创建对象的情况下能达到创建对像的效果，
可以使 decltype 表达式中不必经过构造函数就能使用成员函数
eg: decltype(std::declval<T>.test())   //int 这里没有创建T的对象， 也没有执行a = 1;

给定一个变量或表达式，decltype能够推导出他的类型。最重要的是能够不需要计算表达式就可以推导出表达式所得值的类型。
struct Default { int foo() const { return 1; } };
struct NonDefault
{
    NonDefault(const NonDefault&) { }
    int foo() const { return 1; }
}
decltype(Default().foo()) n1 = 1;                   // type of n1 is int



//判断是否有这种类型
#define _HAS_TYPE_MEM_(parMTpNm)\
template<typename T, typename U = std::void_t<>>\
struct HTM_##parMTpNm: std::false_type{}; \
template<typename T>\
struct HTM_##parMTpNm<T, std::void_t<typename T::parMTpNm>>:std::true_type{};

eg: std::cout<< _HAS_TYPE_MEM_<classname>::value << std::endl;
//or std::cout<< HTM_type<classname>::value << std::endl;
   

//判断类是否有这种变量
#define _HAS_TYPE_VAR_(parMTpNm)\
template<typename T, typename U = std::void_t<>>\
struct HTM_##parMTpNm: std::false_type{}; \
template<typename T>\
struct HTM_##parMTpNm<T, std::void_t<decltype(T::var)>>:std::true_type{};

//判断类中是否存在成员函数
#define _HAS_TYPE_FUN_(parMTpNm)\
template<typename T, typename U = std::void_t<>>\
struct HTM_##parMTpNm: std::false_type{}; \
template<typename T>\
struct HTM_##parMTpNm<T, std::void_t<decltype<T>().parMTpNm>>:std::true_type{};

//
typename = int typename = char 等
优先于
typename = void 
///

/// is_copy_assignable() 类对象是否可以拷贝复值
template<typename T, typename U = std::void_t<>>
struct ISCopyAssignable:std::false_type
{
};
template <typename T>
struct ISCopyAssignable<T, std::void_t<decltype(std::declval<T&>()/*临时变量*/ = std::declval<const T&>())> >:std::true_type
{
};

std::declval<T&>()/*临时变量*/ = std::declval<const T&>()  它类似 T& operator= (const T &)， 与前面一一对应，  结果为T&
//





eg:
template<typename T, typename U, typename V = std::void_t<>>
struct IfCanAdd: std::false_type
{}

template<typename T, typename U>
struct IfCanAdd<T, U, std::void_t<decltype(std::declval<T>() + std::declval<U>())>>:std::true_type
{
    
}
/*
    template<typename T, typename U>
    struct VerAddRet
    {
        //    using type = decltype(T() + U())
        using type = decltype(std::declval<T>() + std::declval<U>());
    }
*/
template<typename T, typename U, bool = IfCanAdd<T, U>::value>//泛
struct VerAddRet
{
    using type = decltype(std::declval<T>() + std::declval<U>());
}

template<typename T, typename U>//特
struct VerAddRet<T, U, false>
{
   
}

template<typename T, typename U>
std::vector<typename VerAddRet<T, U>::type> operator+(std::verctor<T> const&, std::verctor<T> const&)
{
    std::verctor<typename VerAddRet<T, U>::type> tmpvec;
    return tmpvec;
}

struct elemC
{
      elemC(int i);
      elemC operator+(const elemC&t); 
}
std::vector<elemC> vea;
std::vector<elemC> veb;
vea + veb;