吉林市网站建设公司,wordpress 首页折叠,济宁网站建设排行,阿里云官网首页泛型编程
写一个交换函数#xff0c;在学习模板之前#xff0c;为了匹配不同的参数类型#xff0c;我们可以利用函数重载来实现。
void Swap(int a, int b)
{int c a;a b;b c;
}
void Swap(char a, char b)
{char c a;a b;b c;
}
void Swap(dou…泛型编程
写一个交换函数在学习模板之前为了匹配不同的参数类型我们可以利用函数重载来实现。
void Swap(int a, int b)
{int c a;a b;b c;
}
void Swap(char a, char b)
{char c a;a b;b c;
}
void Swap(double a, double b)
{double c a;a b;b c;
}//...
虽然这样似乎解决了问题但是这样的设计写着太过麻烦只要出现新类型就需要写新的函数代码的复用率很低。有没有什么可以让我们一劳永逸呢模板就可以实现这一功能。
这种通过抽象和模板化来编写可重用和灵活的代码以此提升代码的可读性和维护性同时避免代码重复的方式称为泛型编程。
函数模板
函数模板是c中的一类机制通过在函数定义中使用模板参数我们可以编写一个函数而在调用时根据实际参数的类型自动生成相应的版本。
template class T
void Swap(T a, T b)
{T c a;a b;b c;
}这样编译器就可以根据传入的参数类型来生成对应的Swap()函数大大提高了代码的复用率。下面我们来尝试运行一下。
template class T
void Swap(T a, T b)
{T c a;a b;b c;
}int main()
{int a,b;a 1; b 2;double c, d;c 0.0; d 1.2;Swap(a, b);Swap(c, d);cout a b endl;cout c d endl;return 0;
} 我们发现调用Swap()之后int类型的ab和double类型的cd都完成了交换。但是他们是否调的是同一个函数呢
转到反汇编 我们发现两次调用的是不同的Swap()函数根据传入参数类型的不同 编译器会生成不同的函数。然后再调用生成的函数。
函数模板的实例化
通过函数模板生成对应函数的过程叫做函数实例化。
当模板的参数只有一个时却传入了不同类型的变量编译器无法推导出T的类型出现了推导错误。
template class T
void Swap(T a, T b)
{T c a;a b;b c;
}int main()
{int a, b;a 1; b 2;double c, d;c 0.0; d 1.2;Swap(a, c);Swap(b, d);cout a b endl;cout c d endl;return 0;
} 然后我们就会发现报错了 我们写的模板中是两个相同的类型T在实例化的过程中出现了推导问题不能生成对应的函数。
不重新定义模板参数的情况下要解决这个问题有两种方法
1.推导实例化任然让编译器来推导出T的类型通过强制类型转换来让传入的变量类型一致。
#define _CRT_SECURE_NO_WARNINGS 1#include iostream
using namespace std;template class T
T Add(const T a, const T b)
{return a b;
}int main()
{int a1 10, a2 5;double d1 11.2, d2 12.6;cout Add(a1, (int)d1) endl;cout Add((double)a1, d1) endl;return 0;
} 2.显示实例化不用编译器推导T的类型直接指定T的类型。
template class T
T Add(const T a, const T b)
{return a b;
}int main()
{int a1 10, a2 5;double d1 11.2, d2 12.6;/*cout Add(a1, (int)d1) endl;cout Add((double)a1, d1) endl;*/cout Addint(a1, d1) endl;cout Adddouble(a1, d1) endl;return 0;
} 这两种方法都可以解决推导问题但是都对精度有影响。 并且当T不作参数时只能使用显示实例化。
模板函数的匹配原则
当函数模板和现成的函数同时存在时编译器会选择现成的函数。很简单有现成的为什么还要自己生成呢。
T Add(const T a, const T b)
{return a b;
}
int Add(int a,int b)
{return (a b) * 10;
}int main()
{int a 1;int b 2;cout Add(a, b) endl;return 0;
} 类模板
#define _CRT_SECURE_NO_WARNINGS 1#include iostream
using namespace std;template typename T
class Stack
{
public:Stack(int n 4):_array(new T[n]), _capacity(n), _size(0){}void push(const T x){if (_capacity _size){T* tmp new T[2 * _capacity];memcpy(tmp, _array, _size * sizeof(T));delete[] _array;_array tmp;_capacity * 2;}_array[_size] x;}~Stack(){delete[] _array;_array nullptr;_capacity _size 0;}
private:T * _array;int _capacity;int _size;
};int main()
{//类模板都是显示实例化Stackint str1;str1.push(1);str1.push(2);str1.push(3);return 0;
}
底层 首先类模板不能推导实例化。 编译器不能自动推导出类中T的类型这点和T作返回值不作参数的情况一样编译器没有推理其中T类型的依据所以不手动规定类的类型就会报错。先比于c语言用类模板的类可以储存不同类型的数据而不用重新在写一个Stack。 当定义和声明分离时需要重新声明模板并且99%的情况下不能把定义和声明放到两个文件中。
#define _CRT_SECURE_NO_WARNINGS 1#include iostream
using namespace std;template typename T
class Stack
{
public:Stack(int n 4):_array(new T[n]), _capacity(n), _size(0){}void push(const T x);~Stack(){delete[] _array;_array nullptr;_capacity _size 0;}
private:T * _array;int _capacity;int _size;
};
template typename T//重新声明模板void StackT::push(const T x)
{if (_capacity _size){T* tmp new T[2 * _capacity];memcpy(tmp, _array, _size * sizeof(T));delete[] _array;_array tmp;_capacity * 2;}_array[_size] x;
}
int main()
{//类模板都是显示实例化Stackint str1;str1.push(1);str1.push(2);str1.push(3);return 0;
}
