概述
问题引入：C++中有几种交换变量的方法？
1、定义宏代码块。优点：代码复用，适合所有类型；缺点：编译器不知道宏的存在，缺少类型检查。
2、定义函数。优点：真正的函数调用，编译器对类型进行检查；缺点：根据类型重复定义函数，无法代码复用。
泛型编程——函数模板：
一种特殊的函数，可用不同的类型进行调用，与普通函数的区别在于，类型可以被参数化。
template关键字，用于声明开始进行泛型编程；
typename关键字用于声明繁殖类型。
实现代码如下：
#include <iostream>
#include <string>
using namespace std;
template < typename T >
void Swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
template < typename T >
void Sort(T a[], int len)
{
for(int i=0; i<len; i++)
{
for(int j=i; j<len; j++)
{
if( a[i] > a[j] )
{
Swap(a[i], a[j]);
}
}
}
}
template < typename T >
void Println(T a[], int len)
{
for(int i=0; i<len; i++)
{
cout << a[i] << ", ";
}
cout << endl;
}
int main()
{
int a[5] = {5, 3, 2, 4, 1};
Println(a, 5);
Sort(a, 5);
Println(a, 5);
string s[5] = {"Java", "C++", "Pascal", "Ruby", "Basic"};
Println(s, 5);
Sort(s, 5);
Println(s, 5);
return 0;
}
C++通过函数模板，实现了对代码的复用。（复用代码的方式还有继承和包含）
编译器从函数模板通过具体类型产生不同的函数。
编译器会对函数模板进行两次编译：第一次是对函数模板代码本身进行编译，第二次是对参数替换后的代码进行编译。注：模板本身并不支持隐式类型转换，自动推到类型时，必须严格匹配，显式类型指定时，可以进行隐式类型转换。
函数模板可以定义任意多个不同的类型参数，但无法自动推导返回值类型。
当函数重载遇见函数模板会发生什么？
函数模板可以像普通函数一样被重载：
C++编译器优先考虑普通函数，如果函数模板可以产生一个更好的匹配，那么选择模板。
可以通过空模板实参列表限定编译器只匹配模板。
举例如下：
#include <iostream>
#include <string>
using namespace std;
template < typename T >
T Max(T a, T b)
{
cout << "T Max(T a, T b)" << endl;
return a > b ? a : b;
}
int Max(int a, int b)
{
cout << "int Max(int a, int b)" << endl;
return a > b ? a : b;
}
template < typename T >
T Max(T a, T b, T c)
{
cout << "T Max(T a, T b, T c)" << endl;
return Max(Max(a, b), c);
}
int main()
{
int a = 1;
int b = 2;
cout << Max(a, b) << endl;
// 普通函数 Max(int, int)
cout << Max<>(a, b) << endl;
// 函数模板 Max<int>(int, int)
cout << Max(3.0, 4.0) << endl;
// 函数模板 Max<double>(double, double)
cout << Max(5.0, 6.0, 7.0) << endl;
// 函数模板 Max<double>(double, double, double)
cout << Max('a', 100) << endl;
// 普通函数 Max(int, int)
return 0;
}
类模板
C++中，容器类主要用来设计用来存储其他对象或数据类型。比如：数组类、链表类、Stack类、Queue类，等。类中数据组织的方式和数据元素的具体类型无关。
C++的类模板为生成通用的类声明提供了一种更好的方法。模板提供参数化类型，即能够将类型名作为参数传递给接收方来建立类或函数。例如，将类型名int传递给Queue模板，可以让编译器构造一个对int进行排队的Queue类。即以相同的方式处理不同的类型数据。
实现代码如下：
#include <iostream>
#include <string>
using namespace std;
template < typename T >
class Operator
{
public:
T add(T a, T b)
{
return a + b;
}
T minus(T a, T b)
{
return a - b;
}
T multiply(T a, T b)
{
return a * b;
}
T divide(T a, T b)
{
return a / b;
}
};
string operator-(string& l, string& r)
{
return "Minus";
}
int main()
{
Operator<int> op1;
cout << op1.add(1, 2) << endl;
Operator<string> op2;
cout << op2.add("D.T.", "Software") << endl;
cout << op2.minus("D.T", "Software") << endl;
return 0;
}
编译器对类模板的处理方式和函数模板相同，对模板代码先编译一次，再对替换后的代码编译一次。
注意：类模板必须在头文件中定义，切不能分开实现在不同的文件中。类模板外部定义的成员函数需要加上“模板<>”声明，即在使用的时候必须显式指定类型。
#ifndef _OPERATOR_H_
#define _OPERATOR_H_
template < typename T >
class Operator
{
public:
T add(T a, T b);
T minus(T a, T b);
T multiply(T a, T b);
T divide(T a, T b);
};
template < typename T >
T Operator<T>::add(T a, T b)
{
return a + b;
}
template < typename T >
T Operator<T>::minus(T a, T b)
{
return a - b;
}
template < typename T >
T Operator<T>::multiply(T a, T b)
{
return a * b;
}
template < typename T >
T Operator<T>::divide(T a, T b)
{
return a / b;
}
#endifCPP代码如下：
#include <iostream>
#include <string>
#include "Operator.h"
using namespace std;
int main()
{
Operator<int> op1;
cout << op1.add(1, 2) << endl;
cout << op1.multiply(4, 5) << endl;
cout << op1.minus(5, 6) << endl;
cout << op1.divide(10, 5) << endl;
return 0;
}
类模板可以被特化。即指导类模板的特定实现，将部分类型参数显式指定，根据类型参数，分开实现类模板。
部分特化：用特定规则约束类型参数；
完全特化：完全显式指定类型参数。
注：函数模板只支持完全特化。
重定义与特化的不同：
重定义：生成一个新的类模板和一个新类型，使用的时候要考虑如何选择；
特化：以统一的方式使用类模板和特化类型，编译器会自动优先选择特化类型。
template
< typename T >
//函数模板定义
bool Equal(T a, T b)
{
cout << "bool Equal(T a, T b)" << endl;
return a == b;
}
template
< >
bool Equal<double>(double a, double b)
//完全特化
{
const double delta = 0.00000000000001;
double r = a - b;
cout << "bool Equal<double>(double a, double b)" << endl;
return (-delta < r) && (r < delta);
}最后
以上就是精明冬日为你收集整理的C++中的模板技术的全部内容，希望文章能够帮你解决C++中的模板技术所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复