c++ traits提取数据类型2

使用说明：用户使用的是func函数，可以传入的参数有两类，class和基本类型

当传递class参数时，需要通过类unknow_class封装然后传入，支持模板类

后续添加新的数据类型时，只需要重载_func()即可

当传递基本类型参数时，以指针形式传递

本案例中的unknow_class接收各种数据类型的指针，经过func()返回上述指针。详情见test03()

#include <iostream>
using namespace std;

template<class T>//注意自定义类必须开放默认构造
class A {
public:
    T* m_a; //注意指针成员
    typedef typename T value_type;  //定义自身类型
    A(){}
    explicit A(T* t) :m_a(t) {}
    //A(const A& a) :m_a(new T(*a.m_a)) {}
    //~A() { if (m_a) { delete m_a; m_a = nullptr; } }
    //A<T>& operator=(const A& a) {
    //    if (m_a) {
    //        delete m_a; m_a = nullptr;
    //    }
    //    m_a = new T(*a.m_a);
    //    return *this;
    //}
    friend ostream& operator<< <T>(ostream& out, const A<T>& a);
};
template<class T>
ostream& operator<<(ostream& out, const A<T>& a) {
    out << *a.m_a << endl;
    return out;
}

class B {
    int m_a;
public:
    typedef typename B value_type;
    B() {}    //注意自定义类必须开放默认构造
    explicit B(int a) :m_a(a) {}
    friend ostream& operator<<(ostream& out, const B& a);
};
ostream& operator<<(ostream& out, const B& a) {
    out << a.m_a << endl;
    return out;
}

template<class T>   //class类型统一承载容器接口,记录类型及地址
struct unknow_class {
    typedef typename T value_type;
    T* m_a;
    explicit unknow_class(T* t) :m_a(t) {}
};

template<class T>    //定义萃取器，仅能处理class数据类型
struct it_traits {
    typedef typename T::value_type value_type;
};
template<class T>       //当传入指针时，会获取指针指向的类型
struct it_traits<T*> {
    typedef typename T value_type;
};
template<class T>       //当传入指针时，会获取指针指向的类型
struct it_traits<const T*> {
    typedef typename const T value_type;
};

template<class unknow_class>
typename it_traits<unknow_class>::value_type
_func(unknow_class& t, vector<int>) {
    typedef typename it_traits<unknow_class>::value_type value_type;
    return value_type(*t.m_a);
}
template<class unknow_class>
typename it_traits<unknow_class>::value_type
_func(unknow_class& t, A<int>) {
    typedef typename it_traits<unknow_class>::value_type value_type;
    return value_type(*t.m_a);
}
template<class unknow_class>
typename it_traits<unknow_class>::value_type
_func(unknow_class u, B) {
    typedef typename it_traits<unknow_class>::value_type value_type;
    return B(*u.m_a);
}
template<class unknow_class, class T >
typename it_traits<unknow_class>::value_type
_func(unknow_class u, T)
{
    //typedef typename it_traits<T>::value_type value_type;
    return *u;
}

template<class unknow_class>
typename it_traits<unknow_class>::value_type
func(unknow_class u) {
    typedef typename it_traits<unknow_class>::value_type value_type;
    return _func(u, value_type());
}



void test03() {
    B b(1);    //普通类
    unknow_class<B> u(&b);
    cout << func(u) << endl;

    int a = 2;//基本类型
    cout << func(&a) << endl;

    vector<int> v;//模板类
    v.push_back(1);
    unknow_class<vector<int> >u(&v);
    cout << func(u)[0] << endl;

    int a = 1;
    A<int> v(&a);//模板类
    unknow_class<A<int> >u(&v);
    cout << *func(u).m_a << endl;


}