函数模板
语法:
template<typename T>
函数声明或定义
template ,声明创建模板
typename, 表面其后面的符号是—种数据类型,可以用class代替
T ,通用的数据类型,名称可以替换,通常为大写字母
template<typename T>
void myswap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
函数模板注意事项:
- 自动类型推导,必须推导出一致的数据类型T,才可以使用
- 模板必须要确定出T的数据类型,才可以使用
例如下述代码: 则无法推导出类型
template<typename T>
T myswap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
return a;
}
int main()
{
int a = 5;
char b = 'b';
myswap(a, b);
}
普通函数与函数模板区别
- 普通函数调用时可以发生自动类型转换(隐式类型转换)
- 函数模板调用时,如果利用自动类型推导,不会发生隐式类型转换
- 如果利用显示指定类型的方式,可以发生隐式类型转换
template<typename T>
T add(T a, T b)
{
return a + b;
}
int main()
{
int a = 0;
char c = 'c';
cout << add(a, c);//报错,无法推导出正确类型
cout << add<int>(a, c) << endl;
}
普通函数与函数模板的调用规则
- 如果函数模板和普通函数都可以实现,优先调用普通函数
- 可以通过空模板参数列表来强制调用函数模板
- 函数模板也可以发生重载
- 如果函数模板可以产生更好的匹配,优先调用函数模板
#include<iostream>
using namespace std;
//普通函数与函数模板的调用规则
void myPrint(int a, int b)
{
cout << "调用的普通函数" << endl;
}
//函数模板
template<typename T>
void myPrint(T a,T b)
{
cout << "调用的函数模板" << endl;
}
//函数模板
template<typename T>
void myPrint(T a, T b,T c)
{
cout << "调用的重载的函数模板" << endl;
}
void test01()
{
int a = 10;
int b = 20;
//1.如果函数模板和普通函数都可以实现,优先调用普通函数
myPrint(a, b);//调用的普通的
//2.可以通过空模板参数列表来强制调用函数模板
myPrint<>(a, b);//调用的函数模板
//3、函数模板也可以发生重载
myPrint(a, b, 100);
//4.如果函数模板可以产生更好的匹配, 优先调用函数模板
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2);
}
int main()
{
test01();
return 0;
}
类模板
建立一个通用类,类中的成员数据类型可以不具体制定,用一个虚拟的类型来代表。
template<typename T>
类
template<class T>
class person
{
public:
T name;
int age;
person(T _name, int _age)
{
this->name = _name;
this->age = _age;
}
};
int main()
{
person<string> test("tom", 10);
}
与函数模板的区别:
- 类模板没有自动类型推导的使用方式,必须显式给出
- 类模板在模板参数列表中可以有默认参数
//T2默认类型为int
template<class T1,class T2=int>
class person
{
public:
T1 name;
T2 age;
person(T1 _name,T2 _age)
{
this->name = _name;
this->age = _age;
}
};
int main()
{
person<string> test("tom", 10);
person<string, string> test("tom", "10");
}
使用using起别名
由于模板不是一个类型,不能通过typedef取别名。但是新标准允许我们为类模板定义一个类型别名。
template<typename T> using twin = pair<T, T>;
twin<string> authors;
twin<double> areas;
template<typename T>
ostream& operator<<(ostream& cout, twin<T> & num)
{
cout << num.first << " " << num.second << endl;
return cout;//返回输出流对象
}
int main()
{
areas.first = 10;
areas.second = 20;
authors.first = "tom";
authors.second = "TOM";
cout << areas<<authors;
}
类模板的static成员
类模板中,对于给定类型的对象,共享相同的静态成员。比如在test模板中,test< int > 共享静态变量num,test< string > 共享一个。
template<class T>
class test {
public:
static int num;
};
template<typename T>
int test<T>::num = 10;
int main()
{
test<int> s1,s2;
cout << s1.num << " " << s2.num << endl;
test<int>::num = 15;
cout << s1.num << " " << s2.num << endl;
test<string> s3, s4;
test<string>::num = 20;
cout <<"int " <<s1.num << " " << s2.num << endl;
cout <<"string " <<s3.num << " " << s4.num << endl;
}
模板类中每个static数据成员有且只有一个定义,但类模板的每个实例都有一个独特的static对象。所以我们要将static数据成员也定义为模板。
类模板中成员函数的创建时间
类模板中成员函数和普通类中成员函数创建时机的区别:
- 普通类中的成员函数—开始就可以创建
- 类模板中的成员函数在调用时才创建
class test1
{
void showtest1() { cout << "test1" << endl; }
};
class test2
{
void showtest2() { cout << "test2" << endl; }
};
template<class T>
class t
{
public:
T obj;
void fun1() { obj.showtest1(); }
void fun2() { obj.showtest2(); }
};
int main()
{
t<test1> test;
test.fun1();
//test.fun2();
//编译会出错,说明函数调用才会去调用
}
类模板做函数对象参数
一共有三种传入方式
- 指定传入的类型,直接显示对象的数据类型
- 参数模板化,将对象中的参数变为模板进行传递
- 整个类模板化,将这个对象类型模板化进行传递
template<class nametype,class agetype>
class person
{public:
nametype name;
agetype age;
person(nametype _name, agetype _age)
{
name = _name, age = _age;
}
void show() { cout << name << " " << age << endl; }
};
//指定参与类型
void test1(person<string, int>& p)
{
p.show();
}
//参数模板化
template<class nametype, class agetype>
void test2(person<nametype, agetype>& p)
{
p.show();
}
//整个类模板化,但局限性很大
template<class T>
void test3(T& p)
{
p.show();
}
int main()
{
person<string, int> p("tom", 10);
test1(p);
test2(p);
test3(p);
}
类模板与继承
- 当子类继承的父类是一个类模板时,子类在声明的时候,要指定出父类中T的类型。如果不指定,编译器无法给子类分配内存。
- 如果想灵活指定出父类中T的类型,子类也需变为类模板
指定类型继承
template<class T>
class base
{public;
T data;
};
class test :public base<int>
{
test(int _data)
{
this->data = _data;
cout << base::data << endl;
}
};
子类也是类模板
template<class T>
class base
{public;
T data;
};
template<class T1,class T2>
class test :public base<T2>
{
};
类模板成员函数类外实现
成员函数需要函数模板
template<class T>
class test {
public:
T data;
test(T _data);
void show();
};
template<class T>
test<T>::test(T _data)
{
this->data = _data;
}
template<class T>
void test<T>::show()
{
cout << this->data << endl;
}
int main()
{
test<int> s(10);
s.show();
}
类模板分文件编写
类模板中成员函数创建时机是在调用阶段,导致分文件编写时链接不到解决;
c++在写模版函数时(template之类的),头文件不能与cpp文件分离。
解决方法:
- 直接包含.cpp源文件
- 将声明和实现写到同一个文件中,并更改后缀名为.hpp
// “person.cpp”
#include"person.h"
template<class T1, class T2>
person<T1, T2>::person(T1 _age, T2 _name)
{
this->age = _age;
this->name = _name;
}
template<class T1, class T2>
void person<T1, T2>::show()
{
std::cout << age << " " << name << std::endl;
}
// person.h
#pragma once
#include<iostream>
template<class T1,class T2>
class person
{
public:
T1 age;
T2 name;
person(T1 _age,T2 _name);
void show();
};
// main.cpp
#include<iostream>
#include"person.cpp"
using namespace std;
int main()
{
person<int, string> test(10, "tom");
test.show();
}
// "person.hpp"
#include<iostream>
template<class T1,class T2>
class person
{
public:
T1 age;
T2 name;
person(T1 _age,T2 _name);
void show();
};
template<class T1, class T2>
person<T1, T2>::person(T1 _age, T2 _name)
{
this->age = _age;
this->name = _name;
}
template<class T1, class T2>
void person<T1, T2>::show()
{
std::cout << age << " " << name <<std:: endl;
}
// main.cpp
#include<iostream>
#include"person.hpp"
using namespace std;
int main()
{
person<int, string> test(10, "tom");
test.show();
}
类模板与友元
全局函数类内实现 :直接在类内声明友元,实现即可
全局函数类外实现 : 需要提前让编译器知道全局函数的存在
template<class T>
class test;
template<class T>
void show(test<T>& temp)
{
cout << temp.data << endl;
}
template<class T >
class test
{
private:
T data;
public:
test(T _data);
friend void show<>(test<T> & temp);
};
template<class T >
test<T>::test(T _data)
{
this->data = _data;
}
int main()
{
test<int> t(10);
show(t);
test<string> s("tom");
show(s);
}
控制实例化
当模板被使用时才会进行实例化,这一特性意味着,相同的实例可能出现在多个对象文件中。当两个或多个独立编译的源文件使用了相同的模板,并提供了相同的模板参数时,每个文件中都会有该模板的一个实例。
在大系统中,在多个文件中实例化相同模板的额外开销可能非常严重。在新标准中,我们可以通过显式实例化(explicit instantiation)来避免这种开销。
// 实例化声明
extern template declaration;
// 实例化定义
template declaration;
declaration是一个类或函数声明,其中所有模板参数已被替换为模板实参。
当编译器遇到extern模板声明时,它不会在本文件中生成实例化代码。将一个实例化声明为extern就表示承诺在程序其他位置有该实例化的一个非extern声明(定义)。对于一个给定的实例化版本,可能有多个extern声明,但必须只有一个定义。
由于编译器在使用一个模板时自动对其实例化,因此extern声明必须出现在任何使用此实例化版本的代码之前。