一、函数模板定制
函数模板可以实现对于不同的类型复用同一套代码，但是某些情况下，某些类型需要专门去实现，不能套用模板，举例比如对于print函数，可以打印整型、浮点型甚至字符，但是如果输入一个指针呢？所以这个时候就需要对指针类型的这个函数进行专门定制。
假设是下面这个类：
template <typename T>
class Storage{
private: T m_value;
public:
Storage(T value){m_value = value;}
~Storage(){}
void print(){
std::cout << m_value<<'\n';
}
}
这个模板类对很多类型都适用，比如：
Storage<int> nValue(5);
Storage<double> dValue(6.7);
nValue.print();
dValue.print();
假如我们没有进行模板特化，传入一个指针类型会发生什么？如下面代码所示
const char *string = new char[40];
string = "abcde";
Storage<const char*> storage(string);
delete[] string;
string.print();
如果中间没有那一句delete[] string则程序会正常输出，但是上面的代码却在vs里面直接报错。因为这里面在类初始化中，构造函数如下：
template <>
Storage<char*>::Storage(char* value)
{
m_value = value;
}
这里面只做了一个浅拷贝，当把外部的变量删了之后，这个自然就找不到位置了。所以需要针对某些特定类型做模板的定制 。
具体规则就是在要具体定义的函数前面加上
template <>。因为这里就是具体规定类型，所以就用空<>代替即可。
template <>
Storage<char*>::Storage(char* value)
{
// Figure out how long the string in value is
int length=0;
while (value[length] != '\0')
++length;
++length; // +1 to account for null terminator
// Allocate memory to hold the value string
m_value = new char[length];
// Copy the actual value string into the m_value memory we just allocated
for (int count=0; count < length; ++count)
m_value[count] = value[count];
}
具体的函数专业化其实是已经结束了，但是作为代码的完整性，还不够，因为上面内部开辟了一块内存空间，但是，没有释放这一块内存。所以完整代码还需要补充一块析构函数。
template <>
Storage<char*>::~Storage()
{
delete[] m_value;
}
二、类模板定制
大体思路和函数模板定制接近，教程选了一个比较难的例子。
template <class T>
class Storage8
{
private:
T m_array[8];
public:
void set(int index, const T &value)
{
m_array[index] = value;
}
const T& get(int index) const
{
return m_array[index];
}
};
对于上面的例子，初始化类为Storage8<int> intStorage什么的都可以，但是如果初始化为一个Storage8<bool> boolStorage，一个变量都至少需要一个字节，所以本来只需要一个字节来存储的，但是目前需要8个字节，所以对于类型为bool的类，为了提高空间利用效率，可以针对这个类型专门定制。
那为什么不重新定义一个类呢？因为我们必须给它起一个不同的名字。然后，程序员必须记住，Storage8 是用于非布尔类型的，而Storage8Bool（或我们称之为新类的任何名称）是布尔的。我们宁愿避免这种不必要的复杂性。
规则：
首先，请注意，我们从开始template<>。template关键字告诉编译器以下内容已模板化，而空括号则表示没有任何模板参数。在这种情况下，没有任何模板参数，因为我们将唯一的模板参数（T）替换为特定类型（bool）。
接下来，我们在类名称中添加以表示我们正在对Storage8类的bool版本进行专用化。
template <> // the following is a template class with no templated parameters
class Storage8<bool> // we're specializing Storage8 for bool
{
// What follows is just standard class implementation details
private:
unsigned char m_data{};
public:
void set(int index, bool value)
{
// Figure out which bit we're setting/unsetting
// This will put a 1 in the bit we're interested in turning on/off
auto mask{ 1 << index };
if (value) // If we're setting a bit
m_data |= mask; // Use bitwise-or to turn that bit on
else // if we're turning a bit off
m_data &= ~mask; // bitwise-and the inverse mask to turn that bit off
}
bool get(int index)
{
// Figure out which bit we're getting
auto mask{ 1 << index };
// bitwise-and to get the value of the bit we're interested in
// Then implicit cast to boolean
return (m_data & mask);
}
};
三、部分模板定制
3.1 单独的函数部分模板定制
上面两部分的专业化其实是模板的完全定制，就是所有的参数都确定下后进行定义，但是对于含有非类型参数的类型：
template <class T, int size> // size is the expression parameter
class StaticArray{......}
对于这种模板，可能有时候需要定制的是第一个参数，第二个参数个数不能被定制。这种定制被称为部分模板定制化。
举例一个打印上述类内容的函数：
template <typename T, int size>
void print(StaticArray<T, size> &array)
{
for (int count{ 0 }; count < size; ++count)
std::cout << array[count] << ' ';
}
假设我们需要对StaticArray类中char类型进行print函数定制的话？怎么写呢？首先因为typename T已经被固定了，所以首行中的template中不需要在进行类型定义了，只需要保留第二个参数，定义即：
template <typename T, int size>
void print(StaticArray<T, size> &array)
{
for (int count{ 0 }; count < size; ++count)
std::cout << array[count] << ' ';
}
// overload of print() function for partially specialized StaticArray<char, size>
template <int size> //不能定制的参数，这里要保留
void print(StaticArray<char, size> &array) //注意这里面Staticarray中的类型要明确
{
for (int count{ 0 }; count < size; ++count)
std::cout << array[count];
}
3.2 类的函数部分定制
如果我们要对一个类中的某些函数进行部分定制怎么办呢？
如下面这个类中的print函数。
template <class T, int size> // size is the expression parameter
class StaticArray
{
private: T m_array[size]{};
public:
T* getArray() { return m_array; }
T& operator[](int index){ return m_array[index];}
void print(){
for (int i{ 0 }; i < size; ++i)
std::cout << m_array[i] << ' ';
std::cout << '\n';
}
};
最直观的想法就是这样写：
// Error！！！！
template <int size>
void StaticArray<double, size>::print()
{
for (int i{ 0 }; i < size; ++i)
std::cout << std::scientific << m_array[i] << ' ';
std::cout << '\n';
}
然而这样写是错误的。其实也可以直接重新定义这个类：
template <int size>
void StaticArray<double, size>
{......}
但是由于我们只需要重写print函数，所以这样写就会有很多重复的代码。
解决这个问题其实没有进一步的语法可以规避，靠的是一个trick。
我们可以定义一个基础类：
template <class T, int size> // size is the expression parameter
class StaticArray_Base
{......}
然后一般的类都这样用：
template <class T, int size> // size is the expression parameter
class StaticArray: public StaticArray_Base<T, size>
{
public:
};
对于要重写的类，可以这么写：
template <int size> // size is the expression parameter
class StaticArray<double, size>: public StaticArray_Base<double, size>
{
public:
void print()
{
for (int i{ 0 }; i < size; ++i)
std::cout << std::scientific << this->m_array[i] << ' ';
// note: The this-> prefix in the above line is needed.
// See https://stackoverflow.com/a/6592617 or https://isocpp.org/wiki/faq/templates#nondependent-name-lookup-members for more info on why.
std::cout << '\n';
}
};
3.3 指针相关的部分模板专门化
重温一下前面使用过的一个例子：
template <class T>
class Storage
{
private:
T m_value;
public:
Storage(T value)
{
m_value = value;
}
~Storage()
{
}
void print()
{
std::cout << m_value << '\n';
}
};
前面的例子中，我们定制化了char*这个类型。但是问题其实还有：如果是int* float*……这些指针怎么办呢？
int* float*这些指针明显又有很多相通的地方，所以指针很多类型其实又可以规划为一大类，进行指针类型定制。如下：
template <typename T>
class Storage<T*> // this is a partial-specialization of Storage that works with pointer types
{
private:
T* m_value;
public:
Storage(T* value) // for pointer type T
{
// For pointers, we'll do a deep copy
m_value = new T(*value); // this copies a single value, not an array
}
~Storage()
{
delete m_value; // so we use scalar delete here, not array delete
}
void print()
{
std::cout << *m_value << '\n';
}
};
值得注意的是，由于此部分专用的Storage类仅分配一个值，因此对于C样式的字符串，将仅复制第一个字符。如果希望复制整个字符串，则可以完全专门化char *类型的构造函数（和析构函数）。完全专业的版本将优先于部分专业的版本。这是一个示例程序，它既使用指针的部分专门化，又使用char *的完全专门化：
完全体代码：
#include <iostream>
#include <cstring>
// Our Storage class for non-pointers
template <class T>
class Storage
{
private:
T m_value;
public:
Storage(T value)
{
m_value = value;
}
~Storage()
{
}
void print()
{
std::cout << m_value << '\n';
}
};
// Partial-specialization of Storage class for pointers
template <class T>
class Storage<T*>
{
private:
T* m_value;
public:
Storage(T* value)
{
m_value = new T(*value);
}
~Storage()
{
delete m_value;
}
void print()
{
std::cout << *m_value << '\n';
}
};
// Full specialization of constructor for type char*
template <>
Storage<char*>::Storage(char* value)
{
// Figure out how long the string in value is
int length = 0;
while (value[length] != '\0')
++length;
++length; // +1 to account for null terminator
// Allocate memory to hold the value string
m_value = new char[length];
// Copy the actual value string into the m_value memory we just allocated
for (int count = 0; count < length; ++count)
m_value[count] = value[count];
}
// Full specialization of destructor for type char*
template<>
Storage<char*>::~Storage()
{
delete[] m_value;
}
// Full specialization of print function for type char*
// Without this, printing a Storage<char*> would call Storage<T*>::print(), which only prints the first element
template<>
void Storage<char*>::print()
{
std::cout << m_value;
}
int main()
{
// Declare a non-pointer Storage to show it works
Storage<int> myint(5);
myint.print();
// Declare a pointer Storage to show it works
int x = 7;
Storage<int*> myintptr(&x);
// If myintptr did a pointer assignment on x,
// then changing x will change myintptr too
x = 9;
myintptr.print();
// Dynamically allocate a temporary string
char *name = new char[40]{ "Alex" }; // requires C++14
// If your compiler isn't C++14 compatible, comment out the above line and uncomment these
// char *name = new char[40];
// strcpy(name, "Alex");
// Store the name
Storage< char*> myname(name);
// Delete the temporary string
delete[] name;
// Print out our name
myname.print();
}
扫一扫
1239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
