【C++】 函数模板和类模板
文章目录
- 一、模板
-
- 1.1 函数模板和类模板
- 1.2 函数模板
-
- 1.2.1 普通函数和函数模板区别
- 1.2.2 普通函数和函数模板调用规则
- 1.2.3 模板局限性
- 1.3 类模板
-
- 1.3.1 类模板对象做函数参数
- 1.3.2 类模板的继承
- 1.3.3 类模板成员函数的类外实现
- 1.3.4 类模板分文件编写
- 1.3.5 类模板全局函数类内实现
本文是我在学习C++过程当中的心得和学习笔记，在学习C++时已经有C语言的基础，因此入门知识省略了一部分。文章包含了C++的入门基础内容和核心进阶内容，并附上了学习的代码，仅供大家参考。如果有问题，有错误欢迎大家留言。剩余的内容可以通过 这篇文章找到。
一、模板
1.1 函数模板和类模板
函数模板：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。
模板的目的是为了提高复用性，将类型参数化。
/*模板语法：
template
函数声明或定义
*/
/*template 声明创建模板，typename表明其后面的符号是一种数据类型，可以用class代替，T表示通用的数据类型，名称可以替换，通常为答谢字母*/
template<typename T>
void myswap(T &a, T &b)
{
T temp = a;
a = b;
b = temp;
}
void test2()
{
int a = 10; // 将int换成其他类型也可以运行
int b = 20;
//myswap(a, b); // 自动类型推导
myswap<int>(a, b);// 显示指定类型
/*两种方式使用模板：1.自动类型推导 2.显示指定类型*/
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
数组排序：
template<typename T>
void myswap(T& a, T& b) // 交换函数通用模板
{
T temp = a;
a = b;
b = temp;
}
template<class T>
void myArrsort(T arr[], int len) // 数组选择排序通用模板
{
for (int i = 0; i < len; i++)
{
int max = i; // 认定最大值下标
for (int j = i + 1; j < len; j++)
{
if (arr[max] < arr[j])
{
max = j; // 更新最大值下标
}
}
if (max != i)
{
myswap(arr[max], arr[i]);
}
}
}
template<class T>
void printArr(T arr[], int len) // 数组打印通用模板
{
for (int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
}
void test1()
{
char charArr[] = "eafcbd";
int num = sizeof(charArr) / sizeof(char);
myArrsort(charArr, num);
printArr(charArr, num);
}
void test2()
{
int intArr[] = { 8,4,5,6,3,9,2,1 };
int num = sizeof(intArr) / sizeof(int);
myArrsort(intArr, num);
printArr(intArr, num);
}
1.2 函数模板
1.2.1 普通函数和函数模板区别
int myAdd1(int a, int b)
{
return a + b;
}
template<class T>
T myAdd2(T a, T b) // 交换函数通用模板
{
return a + b;
}
void test1()
{
int a = 10;
int b = 20;
char c = 'c'; // a-97 c-99
cout << myAdd1(a, c) << endl; // c转换成ASCII码相加
// 自动类型推导 报错， 不会发送隐式类型转换
//cout << myAdd2(a, c) << endl;
// 显示指定int类型，会发生隐式类型转换
cout << myAdd2<int>(a, c) << endl;
}
1.2.2 普通函数和函数模板调用规则
void myPrint(int a, int b)
{
cout << "调用普通函数" << endl;
}
template<class T>
void myPrint(T a, T b)
{
cout << "调用模板" << endl;
}
template<class T>
void myPrint(T a, T b, T c)
{
cout << "调用重载模板" << endl;
}
void test1()
{
int a = 10;
int b = 20;
myPrint(a, b); // 调用的普通函数
myPrint<>(a, b); // 通过空模板参数列表，强制调用函数模板
myPrint(a, b, 100); // 模板也可以有重载
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2); // 模板的类型更匹配，调用的模板
}
1.2.3 模板局限性
模板并不是万能的，某些特定的数据类型，需要用具体化的方式做实现。
class Person
{
public:
Person(string name, int age)
{
this->m_name = name;
this->m_age = age;
}
string m_name;
int m_age;
};
template<class T>
bool myCompare(T &a, T &b)
{
if (a == b)
{
return true;
}
else
return false;
}
template<> bool myCompare(Person& p1, Person& p2)
{
if (p1.m_name == p2.m_name && p1.m_age == p2.m_age)
{
return true;
}
else
return false;
}
template<class T>
void myPrint(T a, T b, T c)
{
cout << "调用重载模板" << endl;
}
void test1()
{
int a = 10;
int b = 20;
bool ret = myCompare(a, b);
if (ret)
{
cout << "a == b " << endl;
}
else
{
cout << "a != b " << endl;
}
}
void test2()
{
Person p1("Tom", 10);
Person p2("Tom", 10);
bool ret = myCompare(p1, p2);
if (ret)
{
cout << "p1 == p2 " << endl;
}
else
{
cout << "p1 != p2 " << endl;
}
}
1.3 类模板
类模板和函数模板区别：
1.类模板没有自动类型推导
2.类模板在模板参数列表中可以有默认参数
template<class Nametype, class Agetype = int> // 类型默认参数为string和int
class Person
{
public:
Person(Nametype name, Agetype age)
{
this->m_name = name;
this->m_age = age;
}
Nametype m_name;
Agetype m_age;
void showPerson()
{
cout << "name: " << this->m_name << endl << "age: " << this->m_age << endl;
}
};
void test1()
{
// Person p1("张三", 18); // 报错，没有自动类型推导
Person<string, int> p1("张三",18);
Person<string > p2("张三", 18); // int为默认参数，不用写
p2.showPerson();
}
类模板中成员函数在调用时才去创建。
// 类模板中成员函数在调用时才去创建
class Person1
{
public:
void showPerson1()
{
cout << "Person1 show" << endl;
}
};
class Person2
{
public:
void showPerson2()
{
cout << "Person2 show" << endl;
}
};
template <class T>
class MyClass
{
T obj;
public:
void func1()
{
obj.showPerson1(); // 直接运行不报错，编译通过，这时类模板的成员函数还没有被创建
}
void func2()
{
obj.showPerson2();
}
};
void test1()
{
MyClass<Person1> m;
m.func1();
//m.func2();
}
int main()
{
test1();
system("pause");
return 0;
}
1.3.1 类模板对象做函数参数
类模板的函数传参一般来讲，有以下三种方式：
1、指定传入类型
2、参数模板化
3、整个类模板化
// 类模板中成员函数在调用时才去创建
class Person1
{
public:
void showPerson1()
{
cout << "Person1 show" << endl;
}
};
class Person2
{
public:
void showPerson2()
{
cout << "Person2 show" << endl;
}
};
template <class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->m_name = name;
this->m_age = age;
}
void showPerson()
{
cout << "姓名：" << this->m_name << "年龄：" << this->m_age << endl;
}
T1 m_name;
T2 m_age;
};
void printPerson1(Person<string, int>& p) // 1、指定传入类型
{
p.showPerson();
}
template <class T1, class T2>
void printPerson2(Person<T1, T2>& p) // 2、参数模板化
{
p.showPerson();
cout << "T1的类型为： " << typeid(T1).name() << endl;
cout << "T2的类型为： " << typeid(T2).name() << endl;
}
template <class T>
void printPerson3(T& p) // 3、整个类模板化
{
p.showPerson();
cout << "T的类型为： " << typeid(T).name() << endl;
}
void test1()
{
Person<string, int>p1("张三 ", 18);
Person<string, int>p2("李四 ", 25);
Person<string, int>p3("王五 ", 30);
printPerson1(p1);
printPerson2(p2);
printPerson3(p3);
}
1.3.2 类模板的继承
// 类模板与继承
template <class T>
class Base
{
T m;
};
class Son : public Base<int> // 报错，必须要知道父类中T的类型，才能继承给子类，需要加上、或者
{
};
template<class T1, class T2>
class Son2 :public Base <T2>
{
public:
Son2()
{
cout << "T1的数据类型为：" << typeid(T1).name() << endl;
cout << "T2的数据类型为：" << typeid(T2).name() << endl;
}
T1 obj;
};
void test1()
{
Son2<int, char>S2; // int指定给T1，char指定给父类继承来的T2，在父类中表示为T
}
1.3.3 类模板成员函数的类外实现
// 类模板成员函数的类外实现
template <class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPerson();
T1 m_name;
T2 m_age;
};
// 类外实现类模板的构造函数
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_name = name;
this->m_age = age;
}
// 类外实现类模板的成员函数
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
}
void test1()
{
Person <string, int>P("Tom", 20);
P.showPerson();
}
1.3.4 类模板分文件编写
若仅包含.h文件，编译器在编译时是不会创建类模板的成员函数Person和showPerson，因此出现无法解析的错误（编译器不知道这两个函数是什么），若包含.cpp文件则可以运行，编译器会找着.cpp文件中包含的Person.h文件，最终两个文件都会包含。
// main.cpp文件
# include // 编译器报错
//# include "Person.cpp" // 第一种解决方式，直接包含源文件
# include "Person.hpp" // 第二种解决方式，将.h和.cpp中的内容写到到一起，将后缀名改为.hpp
using namespace std;
// 类模板分文件编写
void test1()
{
Person <string, int>P("Tom", 20);
P.showPerson();
}
int main()
{
test1();
system("pause");
return 0;
}
// Person.h文件
#pragma once
# include // Person.cpp文件
# include // Person.hpp文件 = Person.h文件 + Person.cpp文件
#pragma once
# include 1.3.5 类模板全局函数类内实现
不建议使用全局函数类外实现，过于复杂，类内实现用法简单，而且编译器可以直接识别
// 提前让编译器知道Person类存在
template <class T1, class T2>
class Person;
// 类外实现
template <class T1, class T2>
void printPerson2(Person<T1, T2> p)
{
cout << "类外实现 ---- 姓名：" << p.m_name << " 年龄：" << p.m_age << endl;
}
template <class T1, class T2>
class Person
{
// 全局函数 类内实现
friend void printPerson(Person<T1, T2> p)
{
cout << "类内实现 ----- 姓名：" << p.m_name << " 年龄：" << p.m_age << endl;
}
// 全局函数 类外实现 这里写声明 加空模板参数列表<>
friend void printPerson2<>(Person<T1, T2> p);
public:
Person(T1 name, T2 age)
{
this->m_name = name;
this->m_age = age;
}
private:
T1 m_name;
T2 m_age;
};
void test1()
{
Person <string, int>P("Tom", 20);
printPerson(P);
printPerson2(P);
}