C++类型萃取

目的:识别对象的类型

在前面利用模板实现顺序表(Vector)扩容的时候出现了以下的问题

对于像int,char,float等内置类型,我们可以直接用memcpy去赋值给新的空间,可是对于自定义类型(string等)用memcpy就很有可能出错,为了避免错误,我们之前写的Expand函数时用for循环+(=)去赋值的,当类型为string的时候,这个操作会自动调用他的operator=完成内存的拷贝(深拷贝/写时拷贝)

但是我们都知道,memcpy的效率是高于operator=的,那我们想实现当时内置类型的时候使用memcpy,当是自定义类型的时候就使用for+operator=,要怎么去比较类型呢?

以下的思路可以吗?

template<class T>
if(T == int)
    //memcpy
else(T == string)
    //for+operator=

答案是一定不行的,比较只可以比价两个对象,不可以比较两个类型,这就是类型萃取出现的必要性了.

类型萃取:

我们要实现的目的是,如果我们对象的类型是内置类型,我们就使用memcpy赋值,如果是自定义类型,就使用for+(=)来赋值

1.首先,我们先定义两个类型,第一个类型表示是内置类型,第二个类型表示不是内置类型,那就是自定义类型了

struct __TrueType //这里指是内置类型
{};

struct __FalseType //这里指是自定义类型
{};

2.我们定义一个模板类,目的是将内置类型或者非内置类型传参给IsPODType

因为自定义类型有无数种,我们是不可能列举完全的,但是内置类型的数量是有限的,我们一定可以列举完全

让内置类型成为TypeTraits类的特化,如果对象定义为内置类型,编译器就会直接调用对应内置类型的全特化模板类,将IsPODType置为__TrueType,如果不是内置类型,编译器就只能调用没有特化的类型,即将IsPODType置为__FalseType

template<class TP>
struct TypeTraits
{
	typedef __FalseType IsPODType;
};

//以下的都构成了全特化
template<>
struct TypeTraits<int>
{
	typedef __TrueType IsPODType;
};

template<>
struct TypeTraits<char>
{
	typedef __TrueType IsPODType;
};

template<>
struct TypeTraits<float>
{
	typedef __TrueType IsPODType;
};

template<>
struct TypeTraits<bool>
{
	typedef __TrueType IsPODType;
};

//...其他的类型就不一一例举了

3.使用萃取出的类型的参数调用对应的 __TypeCope函数,两个__TypeCope构成了重载,TypeCope调用时会匹配对应的__TypeCope函数

template<class T>
void __TypeCopy(const T* src, T* dst, size_t size, __TrueType)
{
	cout << "TrueType : 内置类型" << endl;
	memcpy(dst, src, size);
}

template<class T>
void __TypeCopy(const T* src, T* dst, size_t size, __FalseType)
{
	cout << "FalseType : 自定义类型" << endl;
	size_t i = 0;
	for (; i < size; ++i)
	{
		dst[i] = src[i];
	}
}

template<class T>
void TypeCopy(const T* src, T* dst, size_t size)
{
	__TypeCopy(src, dst, size, TypeTraits<T>::IsPODType());
}

验证一下代码:

int main()
{
	string s1[10] = { "11", "22", "33", "4444444444444444444" };
	string s2[10] = { "11", "22" };
	TypeCopy(s1, s2, 10);

	int a1[10] = { 1, 2, 3, 4, 5, 6 };
	int a2[10] = { 0 };
	TypeCopy(a1, a2, 10);

	return 0;
}

可以看到,string调用的是自定义类型,int调用的是内置类型

最后再整理一下思路:

1.我们定义的类型调用TypeCopy函数

2.在函数内部调用__TypeCopy函数,调用时,我们同事调用了TypeTraits类,通过对应的类域取出了IsPODType的类型(注意:IsPOSType()创建了一个匿名对象,目的是传参)

3.根据传给__TypeCopy的最后一个参数去调用__TypeCopy函数,我们在__TypeCopy函数接收IsPODType参数的时候,只写了类型,并没有给实参,是因为我们在函数中根本没有用到这个参数,他的存在只是为了两个__TypeCopy函数构成重载.实现我们利用类型分离出两个函数的目的.

另外,其实我们实现的日期类(Date)也不可以用memcpy赋值(根据类用途决定),我们在进行全特化的时候也可以将Date类加进去.

完整代码:

#include <iostream>
using namespace std;

struct __TrueType //这里指是内置类型
{};

struct __FalseType //这里指是自定义类型
{};

template<class TP>
struct TypeTraits
{
	typedef __FalseType IsPODType;
};

//以下的都构成了全特化
template<>
struct TypeTraits<int>
{
	typedef __TrueType IsPODType;
};

template<>
struct TypeTraits<char>
{
	typedef __TrueType IsPODType;
};

template<>
struct TypeTraits<float>
{
	typedef __TrueType IsPODType;
};

template<>
struct TypeTraits<bool>
{
	typedef __TrueType IsPODType;
};

//...其他的类型就不一一例举了

template<class T>
void __TypeCopy(const T* src, T* dst, size_t size, __TrueType)
{
	cout << "TrueType : 内置类型" << endl;
	memcpy(dst, src, size);
}

template<class T>
void __TypeCopy(const T* src, T* dst, size_t size, __FalseType)
{
	cout << "FalseType : 自定义类型" << endl;
	size_t i = 0;
	for (; i < size; ++i)
	{
		dst[i] = src[i];
	}
}


template<class T>
void TypeCopy(const T* src, T* dst, size_t size)
{
	__TypeCopy(src, dst, size, TypeTraits<T>::IsPODType());
}

int main()
{
	string s1[10] = { "11", "22", "33", "4444444444444444444" };
	string s2[10] = { "11", "22" };
	TypeCopy(s1, s2, 10);

	int a1[10] = { 1, 2, 3, 4, 5, 6 };
	int a2[10] = { 0 };
	TypeCopy(a1, a2, 10);

	return 0;
}