模版特化及类型萃取

最新推荐文章于 2022-01-20 23:46:39 发布

Cardiac.TJ

最新推荐文章于 2022-01-20 23:46:39 发布

阅读量159

点赞数

分类专栏：内功心法

本文链接：https://blog.csdn.net/weixin_41892460/article/details/86934032

版权

内功心法专栏收录该内容

62 篇文章 0 订阅

订阅专栏

1.非类型模版参数

模版参数分为类型形参与非类型形参

类型形参：出现在模版参数列表中，跟在class或者typename之类的参数类型名称
非类型参数：用一个常量作为类（函数）模版的一个参数，在类（函数）模版中可将该参数当做常量来使用

T为类型形参，N为非类型形参

template<class T, size_t N = 10>
class Array
{
public:
 T& operator[](size_t index)
 {
 return _array[index];
 }

 const T& operator[](size_t index)const
 {
 return _array[index];
 }

 size_t Size()const
 {
 return _size;
 }

 bool Empty()const
 {
 return 0 == _size;
 }

private:
 T _array[N];
 size_t _size;
}；

注意：

浮点数，类对象以及字符串是不允许作为非类型模版参数的
非类型的模版参数必须在编译期就能确认结果

2.模版的特化

1）基本概念
在原来模版类的基础上，针对特殊类型所进行特殊化的实现方式。如下：我们想比较字符串内容是否相同，但是编译器比较的是地址，所以我们需要对char*类型进行特化。

template<class T>
bool IsEqual(T& left, T& right)
{
 return left == right;
}
void Test()
{
 char* p1 = "hello";
 char* p2 = "world";
 if(IsEqual(p1, p2))
 cout<<p1<<endl;
 else
 cout<<p2<<endl;
}

2）分类
模版特化分为函数模版特化与类模版特化
3）函数模版特化
特化的步骤：

必须要先有一个基础的函数模版
关键字template后面接一对空的尖括号<>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参表：必须要和模版函数的基础参数类型完全相同，如果不同编译器可能会报一些错误

template<>
bool IsEqual<char*>(char*& left, char*& right)
{
 if(strcmp(left, right) > 0)
      return true;

 return false;
}

注;一般情况下如果函数模版遇到不能处理或者处理有误的类型，为了实现简单通常都是讲函数直接给出。

bool IsEqual(char* left, char* right)
{
 if(strcmp(left, right) > 0)
      return true;

 return false;
}

4）类模版特化

a.全特化

《1》概念
全特化就是将模版参数类表中所有的参数都确定化

template<class T1, class T2>
class Data
{
public:
 Data() {cout<<"Data<T1, T2>" <<endl;}
private:
 T1 _d1;
 T2 _d2;
};

//特化版本
template<>
class Data<int, char>
{
public:
 Data() {cout<<"Data<int, char>" <<endl;}
private:
 T1 _d1;
 T2 _d2;
};
void TestVector()
{
 Data<int, int> d1;
 Data<int, char> d2;
}

b.偏特化

《1》基本概念
偏特化：任何针对模版参数进一步进行条件限制的特化版本。
《2》偏特化分类

部分特化
参数进一步的限制
《3》部分特化
将模版参数类表中的一部分参数特化

template<class T1, class T2>
class Data
{
public:
 Data() {cout<<"Data<T1, T2>" <<endl;}
private:
 T1 _d1;
 T2 _d2;
};



// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
 Data() {cout<<"Data<T1, int>" <<endl;}
private:
 T1 _d1;
 int _d2;
};

《4》参数更进一步的限制
偏特化并不仅仅是指特化部分参数，而是针对模版参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
 Data() {cout<<"Data<T1*, T2*>" <<endl;}

private:
 T1 _d1;
 T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
 Data(const T1& d1, const T2& d2)
 : _d1(d1)
 , _d2(d2)
 {
 cout<<"Data<T1&, T2&>" <<endl;
 }

private:
 const T1 & _d1;
 const T2 & _d2;
 };
void test2 ()
{
 Data<double , int> d1; // 调用特化的int版本
 Data<int , double> d2; // 调用基础的模板
 Data<int *, int*> d3; // 调用特化的指针版本
 Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

3.类模版特化应用之类型萃取

1）使用memcpy拷贝

template<class T>
void Copy(T* dst,const  T* src,size_t  size)
{
    memcy(dst,src,sizeof(T)*size);
 }

int main()
{
  string  strarr1[3] = {"11'',"22","33"};
  string strarr2[3];
  Copy(strarr2,strarr1,3);
}

上述代码虽然对于任意类型的空间都可以进行拷贝，但是如果拷贝自定义类型对象就可能会出错，因为自定义类型对象有可能会涉及到深拷贝（eg：string）。而memcpy属于浅拷贝。如果对象中涉及资源管理，就只能用赋值。
2）使用赋值方式拷贝

template<class T>
void Copy(T* dst, const T* src, size_t size)
{
 for(size_t i = 0; i < size; ++i)
 {
 dst[i] = src[i];
 }
}

用循环赋值的方式虽然可以，但是代码的效率比较低。
3）增加bool类型区分自定义类型与内置类型

template<class T>
void Copy(T* dst, const T* src, size_t size, bool IsPODType)
{
 if(IsPODType)
    memcpy(dst, src, sizeof(T)*size);
 else
 {
    for(size_t i = 0; i < size; ++i)
        dst[i] = src[i];
 }
}

通过多增加一个参数，就可将两种拷贝的优势体现结合起来。但缺陷是：用户需要根据所拷贝元素的类型去传递第三个参数，那出错的可能性就增加。
4）使用函数区分内置类型与自定义类型
因为内置类型的个数是确定的，可以将所有内置类型集合在一起，如果能够将所拷贝对象的类型确定下来，在内置类型集合中查找其是否存在即可确定所拷贝类型是否为内置类型。

bool IsPODType(const char* strType)
{
	 const char* arrType[] = {"char", "short", "int", "long", "long long", "float","double", "long double"};
	 for(size_t i = 0; i < sizeof(array)/sizeof(array[0]); ++i)
	 {
	 if(0 == strcmp(strType, arrType[i]))
	 return true;
	 }
	 return false;
}

template<class T>
void Copy(T* dst, const T* src, size_t size)
{
	 if(IsPODType(typeid(T).name()))
	 memcpy(dst, src, sizeof(T)*size);
	 else
	 {
	 for(size_t i = 0; i < size; ++i)
	 dst[i] = src[i];
	 }
}

通过typeid来确认所拷贝对象的实际类型，然后再在内置类型集合中枚举其是否出现过，既可确认所拷贝元素的类型为内置类型或者自定义类型。但缺陷是：枚举需要将所有类型遍历一遍，每次比较都是字符串的比较，效率比较低。

5)类型萃取
定义两个类，为了区分内置类型和自定义类型：

//内置类型
class TrueType
{ 
   public:
       static bool Get()
        {
          return true;
          }
};

//自定义类型
class FasleType
{
 public:
    static bool Get()
    {
        return  false;
     }
};

定义一个模版类，里边包含对自定义类型的重命名，并将所有的内置类型都特化。

//定义一个模板类，里边包含对自定义类型和内置类型的重命名
template<class T>
class TypeTraits
{
public:
	typedef FalseType IsPodType;
};
//使用所有内置类型对该模板特化
template<>
class TypeTraits<int>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<short>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<char>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<float>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<double>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<long>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<long long>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<long double>
{
public:
	typedef TrueType IsPodType;
};

通过对TypeTraits类模版重写改写Copy函数模版，来确认所拷贝对象的实际类型：

template<class T>
void Copy(T* dst, T* src, size_t size)
{
	if (TypeTraits<T>::IsPodType::Get())
		memcpy(dst, src, sizeof(T)*size);
	else
	{
		for (int i = 0; i < size; i++)
		{
			dst[i] = src[i];
		}
	}
}

如果T为int，TypeTraits已经特化过，程序运行时就会使用已经特化过的TypeTraits，该类中IsPodType刚好为类TrueType，而TrueType中Get函数返回true，内置类型使用memcpy方式拷贝。所有的内置类型都是这样。
如果T为string，TypeTraits没有特化过，程序运行时使用TypeTraits类模板, 该类模板中的IsPodType 刚好为类FalseType，而FalseType中Get函数返回false，自定义类型使用赋值方式拷贝。所有的自定义类型都是这样。

STL中一些类型萃取方法：

//让_Copy函数因最后一个参数(内置类型和自定义类型)形成函数重载
//在写一个通用的Copy函数，根据不同的参数调用重载的两个_Copy函数
template<class T>
//第4个参数乐意不提供名字，只要构成重载即可
void _Copy(T* dst, T* src, size_t size, TrueType t)
{
	memcpy(dst, src, sizeof(T)*size);
}

template<class T>
void _Copy(T* dst, T* src, size_t size, FalseType f)
{
	for (int 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>::IsPodType);
}

注：在特化TypeTraits模板类的时候，必须将所有的类型有符号、无符号全部特化(int、unsigned int signed int)

3.模板不支持分离编译

1）分离编译的基本概念
一个项目由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
2）模板为什么不支持分离编译
模版编译不会生成代码，只有实例化才生成代码，链接时无法链接，所以不支持分离编译。
3）解决方法

将声明和定义放在一个文件xxx.hpp里面
模版定义的位置显式实例化，不常用，因为这样做就降低了模版的好处
使用过程中不要将声明与定义分离

4.模版优缺点

优点

模版复用了代码，节省资源，更快的迭代开发，c++的标准模版库（STL）因此而产生
增强了代码的灵活性

缺点

模版会导致代码膨胀问题，也会导致编译时间变长
出现模版编译错误时，错误信息非常凌乱，不易定位错误

Cardiac.TJ

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
模版特化及类型萃取

1.非类型模版参数模版参数分为类型形参与非类型形参类型形参：出现在模版参数列表中，跟在class或者typename之类的参数类型名称非类型参数：用一个常量作为类（函数）模版的一个参数，在类（函数）模版中可将该参数当做常量来使用T为类型形参，N为非类型形参template&lt;class T, size_t N = 10&gt;class Array{public: T&a...
复制链接

扫一扫