C++ 模板
模板：
模板，即数据是灵魂，其余为肉身，正所谓有趣的灵魂万里挑一，所以想要模板变得完美，关键在于数据；其余不过是抄作业的框架。
模板函数：
模板函数可以自动推导出你传给他的数据类型，同时也可以指定数据类型；但自定义的class在做相应的运算则需要对操作符进行重载。
#include
#include
using namespace std;
template
T1 add(T1 a,T2 b,T3 c)
{
cout<<"T1"<(a,b,c)< 模板函数与普通函数
当模板函数遇上普通函数重载时，按类型匹配高的来。
#include
#include
using namespace std;
template
void myswap(T &a, T1 &b) // 自动推导出传入的数据类型
{
T temp;
temp = a;
a = b;
b = temp;
cout << "模板函数" << endl;
}
void myswap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
cout << "普通函数" << endl;
}
int main(int argc, char const *argv[])
{
int a = 10;
int b = 20;
myswap(a, b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
cout << "-------------" << endl;
float c = 10.5;
float d = 20.5;
myswap(c, d);
cout << "c=" << c << endl;
cout << "d=" << d << endl;
cout << "-------------" << endl;
int e = 10;
float f = 13.35;
myswap(f, e);
cout << "e=" << e << endl;
cout << "f=" << f << endl;
cout << "-------------" << endl;
return 0;
}
自定义数据类型给模板函数传参
自定义的数据成为模板函数的参数时参与运算时，需要自行重载操作符，否则会报错。
#include
using namespace std;
template
bool isBig(T a, T b)
{
if (a > b)
{
return true;
}
else
{
return false;
}
}
// 定义用户自定义数据类型
class base
{
public:
base(int v) : value(v) {}
private:
int value;
bool friend operator>(base a, base b);
};
bool operator>(base a, base b)
{
return a.value > b.value;
}
int main()
{
// 基本的数据类型
// int a = 10;
// int b = 20;
base a(10);
base b(20);
if (isBig(a, b))
{
cout << "a is bigger than b" << endl;
}
else
{
cout << "b is bigger than a" << endl;
}
} 模板类：
模板类构造
必须手动指明参数类型。
#include
#include
using namespace std;
template
class student
{
private:
T name;
T1 id;
T2 number;
public:
student(T name, T1 id, T2 number) : id(id), number(number), name(name)
{
}
void show()
{
cout << "name=" << name << endl;
cout << "id=" << id << endl;
cout << "number=" << number << endl;
cout<<"---------------------------"< stu("张三", 2301956, 1346545);
stu.show();
student tech("李四", "老师", "物理");
tech.show();
return 0;
}
模板类传参
模板是无法进行直接传参的，但可以通过特殊方式进行传参
1、指定实例化类型
2、将需要实例化的数据类型继续模板化
3、直接将函数接口改为模板函数
#include
using namespace std;
template
class base // 定义一个模板类
{
public:
T a;
};
// 1.把模板类的类型 ，实例化
void set_base(base &tmp, int v)
{
tmp.a = v;
}
void show_base(base &tmp)
{
cout << tmp.a << endl;
}
// 2.把模板类的类型，继续模板化
template
void set_base(base &tmp, T v)
{
cout << "继续模板化" << endl;
tmp.a = v;
}
template
void show_base(base &tmp)
{
cout << "继续模板化" << endl;
cout << tmp.a << endl;
}
// 3.直接定义模板函数
template
void set_base(T &tmp, T1 v)
{
tmp.a = v;
}
template
void show_base(T &tmp)
{
cout << tmp.a << endl;
}
int main()
{
base tmp;
set_base(tmp, 100);
show_base(tmp);
}
模板类的继承
模板类因为数据类型不确定，也无法直接继承，也需要特殊的改造；
方法一、 指定模板数据类型，其子类回归普通类。
方法二、将数据类型继续模板化，但其子类属性依然是模板类
#include
using namespace std;
// 模板基类
template
class base
{
public:
base() {}
base(T v) : data(v) {}
void show()
{
cout << this->data << endl;
}
private:
T data;
};
// 1.指定基类的模板类 类型 -> 已经不是模板类
class xbase : public base
{
};
// 2.继续把基类的类型 模板化 -> 派生类还是模板类
template
class xbase2 : public base
{
};
int main()
{
xbase tmp;
xbase2 tmp2;
}