【通用算法】类型萃取

在学习c++过程中通用算法我们学习了模板的知识，通过模板可以将很多代码相同，只是数据类型不同的函数或类用一个模板给出，在使用的时候，对其进行实例化就可以使用，大大减少了代码量，这时就衍生了许多的通用算法，接下来我要介绍的就是其中一种，这种算法的功能是实现拷贝。

实现拷贝功能首先想到的就是循环，利用循环语句将元素一个一个的进行放入，为了高效，我们也可以采用memcpy函数，但是这两个算法的实现各有缺陷，利用循环效率比较低，使用memcpy有时候会出现浅拷贝现象，在这里我们将两种情况都考虑进去，如果是内嵌类型的话就使用memset,不是的话就使用循环：

代码如下：

#include<iostream>
#include<string.h>
using namespace std;
template <class T>
void Copy(T* dst, T* src, size_t size)
{
	cout << typeid(T).name() << endl;//打印当前类型名
	if (IsPOD((char *)typeid(T).name()))//如果是内嵌类型采用memcpy
	{
		memcpy(dst, src, sizeof(T)* size);
	}
	else
	{
		for (size_t i = 0; i < size; ++i)
		{
			dst[i] = src[i];
		}
	}

}
bool IsPOD(char * TypeName)//判断是否是内嵌类型
{
	static char* p[] = { "int", "short", "float", "double", "char"};
	size_t i = 0;
	for ( i = 0; i < (sizeof(p)/sizeof(p[0])); ++i)//将当前类型名和提前设置好的内嵌类型进行比较，判断是否是内嵌类型
	{
		if (strcmp(p[i], TypeName) == 0)

			return true;
	}
	
	
	return false;
}

int main()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int b[10];
	Copy(b, a, sizeof(a) / sizeof(a[0]));
	string s1[] = { "1111", "2222", "3333", "4444" };
	string s2[4];
	Copy(s2, s1, (sizeof(s1) / sizeof(s1[0])));

	system("pause");
	return 0;
}

在监视窗口下可以看到数据已经都拷贝过去了。

还有一种实现的方式是利用模板的特化：

代码如下：

#include<iostream>
using namespace std;
struct TrueType
{
	static bool IsPODType()
	{
		return true;
	}

};
struct FalseType
{
	static bool IsPODType()
	{
		return false;
	}

};
template<class T>
struct TypeTraits
{
	typedef TrueType PODType;
};
template<>
struct TypeTraits<int>
{
	typedef TrueType PODType;
};
template<>
struct TypeTraits<short>
{
	typedef TrueType PODType;
}; 
template<>
struct TypeTraits<double>
{
	typedef TrueType PODType;
};
template <>
struct TypeTraits<char>
{
	typedef TrueType PODType;
};
template<>
struct TypeTraits<float>
{
	typedef TrueType PODType;
};
template<class T>
void Copy(T* dst, T* src, size_t size)
{
	cout << typeid(T).name() << endl;
	if (TypeTraits<T>::PODType::IsPODType())
	{
		memcpy(dst, src, sizeof(T)* size);
	}
	else
	{
		for (size_t i = 0; i < size; ++i)
		{
			dst[i] = src[i];
		}
	}
}
int main()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int b[10];
	Copy(b, a, sizeof(a) / sizeof(a[0]));
	string s1[] = { "1111", "2222", "3333", "4444" };
	string s2[4];
	Copy(s2, s1, (sizeof(s1) / sizeof(s1[0])));

	system("pause");
	return 0;
}

可以看到这样也可以实现拷贝功能：

我们来分析一下实现的过程：

我们还可以将其简化一下：这种方式实现的时候和前面那种基本相同，都是利用类的特化：

代码如下：

#include<iostream>
using namespace std;
struct TrueType
{};
struct FalseType
{};
template <class T>
struct TypeTraits
{
	typedef TrueType PODType;
};
template <>
struct TypeTraits<int>
{
	typedef TrueType PODType;
};
template <>
struct TypeTraits<short>
{
	typedef TrueType PODType;
};
template <>
struct TypeTraits<char>
{
	typedef TrueType PODType;
};
template <>
struct TypeTraits<double>
{
	typedef TrueType PODType;
};
template <>
struct TypeTraits<float>
{
	typedef TrueType PODType;
};
struct PODType
{

};
template<class T>
void _Copy(T* dst, T* src, size_t size, TrueType)
{
	memcpy(dst, src, sizeof(T)*size);
}
template<class T>
void _Copy(T* dst, T* src, size_t size,FalseType)
{
	for (size_t i = 0; i < size; i++)
	{
		dst[i] = src[i];
	}
}
template <class T>

void Copy(T *dst, T* src, size_t size)
{
	_Copy(dst, src, size, TypeTraits<T>::PODType());
}
int main()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int b[10];
	Copy(b, a, sizeof(a) / sizeof(a[0]));
	string s1[] = { "1111", "2222", "3333", "4444" };
	string s2[4];
	Copy(s2, s1, sizeof(s1) / sizeof(s1[0]));

	system("pause");
	return 0;
}

这样也可以实现想要的功能：

简要分析一下：