小鹿快跑～

C++ 模板、函数模板、类模板

函数模板、类模板

文章目录

函数模板、类模板
前言
1.模板
- 1.1 模板的概念
- 1.2 模板的特点
2. 函数模板
- 2.1 函数模板语法
- 2.2 函数模板注意事项
- 2.3 普通函数与函数模板的区别
- 2.4 普通函数与函数模板的调用规则
- 2.5 模板的局限性
- 2.6 函数模板案例
3. 类模板
- 3.1 类模板语法
- 3.2 类模板与函数模板区别
- 3.3 类模板中成员函数创建时机
- 3.4 类模板对象做函数参数
- 3.5 类模板与继承
- 3.6 类模板成员函数类外实现
- 3.7 类模板分文件编写
- 3.8 类模板与友元
总结

前言

本文包含模板的概念、模板的特点、函数模板语法、函数模板注意事项、普通函数与函数模板的区别、普通函数与函数模板的调用规则、模板的局限性、类模板语法、类模板与函数模板区别、类模板中成员函数创建时机、类模板对象做函数参数、类模板与继承、类模板成员函数类外实现、类模板分文件编写、类模板与友元。

1.模板

1.1 模板的概念

（1）、模板就是建立通用的模具，大大提高复用性

（2）、生活中的模板

一寸照片模板：

PPT模板：

1.2 模板的特点

（1）、模板不可以直接使用，它只是一个框架；

（2）、模板的通用并不是万能的。

2. 函数模板

（1）、C++另一种编程思想称为泛型编程，主要利用的技术就是模板

（2）、C++提供两种模板机制：函数模板和类模板

2.1 函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。

语法：

template
函数声明或定义

解释：

template — 声明创建模板

typename — 表面其后面的符号是一种数据类型，可以用class代替

T — 通用的数据类型，名称可以替换，通常为大写字母

// 函数模板语法

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 交换整型函数
void Int_Swap(int& a, int& b) {  // 使用引用的方式传递，将本体交换，修改实参；不使用引用，则为赋值，形参不修改实参，会创建一个临时变量
	int temp = a;  // 创建一个临时变量存放元素
	a = b;
	b = temp;
}

// 交换双精度浮点型函数
void Double_Swap(double& a, double& b) {
	double temp = a;
	a = b;
	b = temp;
}

// 利用模板提供通用的交换函数
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Swap(T& a, T& b) {  // 使用模板时再指定类型
	T temp = a;
	a = b;
	b = temp;
}

void test() {
	int a = 10;
	int b = 20;
	double c = 5.55;
	double d = 10.11;

	cout << "交换前：" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;

	Int_Swap(a, b);
	cout << "使用Int_Swap()函数交换后：" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	Double_Swap(c, d);
	cout << "使用Double_Swap()函数交换后：" << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;

	// 1、自动类型推导
	Fun_Swap(a, b);  // 编译器运行时，将变量传入函数形参中，根据变量类型int自动推导出T类型为int
	cout << "使用Fun_Swap()函数模板交换后：" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	// 2、显示指定类型
	Fun_Swap<double>(c, d);  // 指定模板参数类型
	cout << "使用Fun_Swap()函数模板交换后：" << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

2.2 函数模板注意事项

（1）、自动类型推导，必须推导出一致的数据类型T，才可以使用；

// 函数模板注意事项

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 利用模板提供通用的交换函数
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Swap(T& a, T& b) {  // 使用模板时再指定类型
	T temp = a;
	a = b;
	b = temp;
}

void test() {

	int a = 10;
	int b = 20;
	double c = 5.55;
	
	// 1、自动类型推导，必须推导出一致的数据类型T，才可以使用
	Fun_Swap(a, b);  // 正确，可以推导出一致的T
	//Fun_Swap(a, c);  // 错误，推导不出一致的T类型
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（2）、模板必须要确定出T的数据类型，才可以使用。

// 函数模板注意事项

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun() {
	cout << "调用Fun()函数" << endl;
}

void test() {

	// 2、模板必须要确定出T的数据类型，才可以使用
	//Fun();  // 错误，模板不能独立使用，必须确定出T的类型

	Fun<int>();  // 利用显示指定类型的方式，给T一个类型，才可以使用该模板
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

2.3 普通函数与函数模板的区别

（1）、普通函数调用时可以发生自动类型转换（隐式类型转换）；

// 普通函数与函数模板区别

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 普通函数
int Fun_Add01(int a, int b) {
	return a + b;
}

void test() {

	int a = 10;
	char c = 'A';  // A - 65

	// 1、普通函数调用时可以发生自动类型转换（隐式类型转换）
	cout << "a + c = " << Fun_Add01(a, c) << endl;  // 正确，将char类型的'A'隐式转换为int类型  'A' 对应 ASCII码 65
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（2）、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；

// 普通函数与函数模板区别

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 利用模板提供通用的相加函数
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
int Fun_Add02(T a, T b) {
	return a + b;
}

void test() {

	int a = 10;
	char c = 'A';  // A - 65

	// 2、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
	//cout << "a + c = " << Fun_Add02(a, c) << endl; // 报错，使用自动类型推导时，不会发生隐式类型转换
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（3）、如果利用显示指定类型的方式，可以发生隐式类型转换。

// 普通函数与函数模板区别

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 利用模板提供通用的相加函数
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
// 此处不可使用&，引用的本质在c++内部实现是一个指针常量；指针常量是指针指向不可改，指向a地址后，不可再指向b地址
// 使用赋值，会创建一个临时变量，不改变实参
int Fun_Add02(T a, T b) {  
	return a + b;
}

void test() {

	int a = 10;
	char c = 'A';  // A - 65

	// 3、如果利用显示指定类型的方式，可以发生隐式类型转换
	cout << "a + c = " << Fun_Add02<int>(a, c) << endl;  // 正确，如果用显示指定类型，可以发生隐式类型转换
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

2.4 普通函数与函数模板的调用规则

（1）、如果函数模板和普通函数都可以实现，优先调用普通函数；

// 普通函数与函数模板调用规则

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 普通函数
void Fun_Print(int a, int b) {
	cout << "调用普通函数！" << endl;
}

// 函数模板
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
	cout << "调用函数模板！" << endl;
}

void test() {

	int a = 10;
	int b = 20;

	// 1、如果函数模板和普通函数都可以实现，优先调用普通函数
	// 注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
	Fun_Print(a, b);
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（2）、可以通过空模板参数列表来强制调用函数模板；

// 普通函数与函数模板调用规则

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 普通函数
void Fun_Print(int a, int b) {
	cout << "调用普通函数！" << endl;
}

// 函数模板
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
	cout << "调用函数模板！" << endl;
}

void test() {

	int a = 10;
	int b = 20;

	// 2、可以通过空模板参数列表来强制调用函数模板
	Fun_Print<>(a, b);
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（3）、函数模板也可以发生重载；

// 普通函数与函数模板调用规则

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 普通函数
void Fun_Print(int a, int b) {
	cout << "调用普通函数！" << endl;
}

// 函数模板
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
	cout << "调用函数模板！" << endl;
}

// 重载函数模板
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b, T c) {
	cout << "调用重载函数模板！" << endl;
}

void test() {

	int a = 10;
	int b = 20;

	// 3、函数模板也可以发生重载
	int c = 30;
	Fun_Print<>(a, b, c);
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（4）、如果函数模板可以产生更好的匹配，优先调用函数模板。

// 普通函数与函数模板调用规则

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 普通函数
void Fun_Print(int a, int b) {
	cout << "调用普通函数！" << endl;
}

// 函数模板
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
	cout << "调用函数模板！" << endl;
}

void test() {

	int a = 10;
	int b = 20;

	// 4、如果函数模板可以产生更好的匹配,优先调用函数模板
	char d = 'a';
	char e = 'b';
	Fun_Print(d, e);  // 调用函数模板；如果调用普通函数，需要将char转为int，程序为了避免麻烦，调函数模板，可以产生更好的匹配
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

2.5 模板的局限性

（1）、模板的通用性并不是万能的

template<class T>
void f(T a, T b)
{ 
   	a = b;
}

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

template<class T>
void f(T a, T b)
{ 
   	if(a > b) { ... }
}

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

（2）、因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

// 函数模板的局限性

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个Person类
class Person {

public:
	Person(string name, int age) {  // 有参构造，赋值
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

// 普通的通用函数模板；判断两个数是否相等
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
bool Fun_Compare(T& a, T& b) {
	// 相等返回true，否则返回false
	if (a == b) {
		return true;
	}
	else {
		return false;
	}
}

// 解决方法：1、运算符重载（麻烦，如果是<,>等都需要重载一遍）

// 具体化，显示具体化的原型和定义以template<>开头，并通过名称来指出类型
// 解决方法：2、具体化优先于常规模板
template<> bool Fun_Compare(Person& p1, Person& p2) {  // template<>告诉编译器为模板的重载
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age) {  // 判断实例p1和p2的姓名、年龄是否都相等
		return true;
	}
	else {
		return false;
	}
}

void test01() {

	int a = 10;
	int b = 10;

	// 内置数据类型可以直接使用通用的函数模板
	bool con = Fun_Compare(a, b);

	if (con) {
		cout << "a == b" << endl;
	}
	else {
		cout << "a != b" << endl;
	}
}

void test02() {

	Person p1("张三", 18);
	Person p2("张三", 18);

	// 自定义数据类型，不会调用普通的通用函数模板
	// 可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
	bool con = Fun_Compare(p1, p2);

	if (con) {
		cout << "p1 == p2" << endl;
	}
	else {
		cout << "p1 != p2" << endl;
	}
}

int main() {

	test01();
	test02();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

2.6 函数模板案例

（1）、利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序

（2）、排序规则从大到小，排序算法为选择排序

（3）、分别利用char数组和int数组进行测试

// 函数模板案例

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 利用模板提供通用的交换函数
template<typename T>  // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Swap(T& a, T& b) {
	T temp = a;  // 创建一个临时变量存放元素
	a = b;
	b = temp;
}

// 利用选择排序，进行对数组从大到小的排序，提供通用排序模板
template<typename T>
void Fun_Sort(T arr[], int len) {
	for (int i = 0; i < len; i++) {  // 获取每一个元素，与它之后的元素进行对比
		int max = i;  // 最大数的下标；假设认定第一个下标为最大值
		for (int j = i + 1; j < len; j++) {  // 获取第i个元素之后的所有元素
			if (arr[max] < arr[j]) {  // 认定的最大值比遍历出的数组要小，说明j下标的元素才是真正的最大值
				max = j;  // 将j赋值给max
			}
		}
		if (max != i) {  // 如果最大数的下标不是i，交换两者
			Fun_Swap(arr[max], arr[i]);  // 将最大下标的元素，与第i个元素进行交换
		}
	}
}

// 打印数组通用模板
template<typename T>
void Fun_Print(T arr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << arr[i] << " ";  // 每个数组元素之间使用空格分开
	}
	cout << endl;  // 换行
}

// 测试int数组
void test01() {

	int int_Arr[] = { 7,2,6,9,1,0,5,3 };
	int len = sizeof(int_Arr) / sizeof(int);  // sizeof()：求对象或者类型的大小

	cout << "int型数组排序前：" << endl;
	Fun_Print(int_Arr, len);

	Fun_Sort(int_Arr, len);

	cout << "int型数组排序后：" << endl;
	Fun_Print(int_Arr, len);
}

// 测试char数组
void test02() {

	char char_Arr[] = "ksiudxtenz";
	int len = sizeof(char_Arr) / sizeof(char);

	cout << "char型数组排序前：" << endl;
	Fun_Print(char_Arr, len);

	Fun_Sort(char_Arr, len);

	cout << "char型数组排序后：" << endl;
	Fun_Print(char_Arr, len);
}

int main() {

	test01();
	test02();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3. 类模板

3.1 类模板语法

类模板作用：

建立一个通用类，类中的成员、数据类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template
类

解释：

template — 声明创建模板

class — 表面其后面的符号是一种数据类型，可以用typename代替

T — 通用的数据类型，名称可以替换，通常为大写字母

// 类模板语法

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个Person类模板
template<class nameType, class ageType>  // nameType、ageType为虚拟类型
class Person {

public:
	Person(nameType name, ageType age) {  // 有参构造，赋值
		this->m_Name = name;
		this->m_Age = age;
	}

	void Fun_Print() {  // 打印成员属性
		cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
	}

	nameType m_Name;  // 姓名
	ageType m_Age;  // 年龄
};

void test() {

	// 指定nameType为string类型，ageType为int类型
	Person<string, int> p("张三", 18);  // 类型参数化；<>模板的参数列表

	p.Fun_Print();  // 调用成员函数Fun_Print()
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3.2 类模板与函数模板区别

（1）、类模板没有自动类型推导的使用方式；

// 类模板与函数模板区别

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个Person类模板
template<class nameType, class ageType>  // nameType、ageType为虚拟类型
class Person {

public:
	Person(nameType name, ageType age) {  // 有参构造，赋值
		this->m_Name = name;
		this->m_Age = age;
	}

	void Fun_Print() {  // 打印成员属性
		cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
	}

	nameType m_Name;  // 姓名
	ageType m_Age;  // 年龄
};

void test() {

	// 1、类模板没有自动类型推导的使用方式
	//Person p("张三", 18);  // 错误 类模板使用时候，不可以用自动类型推导

	// 必须使用显示指定类型的方式，使用类模板
	Person<string, int> p("张三", 18);

	p.Fun_Print();  // 调用成员函数Fun_Print()
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（2）、类模板在模板参数列表中可以有默认参数

// 类模板与函数模板区别

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个Person类模板
template<class nameType, class ageType = int>  // 类模板在模板参数列表中可以有默认参数
class Person {

public:
	Person(nameType name, ageType age) {  // 有参构造，赋值
		this->m_Name = name;
		this->m_Age = age;
	}

	void Fun_Print() {  // 打印成员属性
		cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
	}

	nameType m_Name;  // 姓名
	ageType m_Age;  // 年龄
};

void test() {

	// 2、类模板在模板参数列表中可以有默认参数
	Person<string> p("李四", 40);  // 类模板中的模板参数列表，可以指定默认参数

	p.Fun_Print();  // 调用成员函数Fun_Print()
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3.3 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

（1）、普通类中的成员函数一开始就可以创建；

（2）、类模板中的成员函数在调用时才创建。

// 类模板中成员函数创建时机

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建Aoo类
class Aoo {

public:
	void Fun_Print1() {
		cout << "调用Fun_Print1()函数！" << endl;
	}
};

// 创建Boo类
class Boo {

public:
	void Fun_Print2() {
		cout << "调用Fun_Print2()函数！" << endl;
	}
};

// 创建Coo类模板
template<class T>  // 类模板在模板参数列表中可以有默认参数
class Coo {

public:

	T t;

	// 类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成

	void Fun1() {    // 没有调用时，不会创建；无法确定obj是何类型
		t.Fun_Print1();
	}

	void Fun2() {
		t.Fun_Print2();
	}
};

void test() {

	Coo<Aoo> c;  // T为Aoo的数据类型

	c.Fun1();  // 相当于Aoo.Fun_Print1()

	// 编译会出错，说明函数调用才会去创建成员函数
	//c.Fun2();  // 编译会出错：Fun_Print2不是Aoo的成员；Aoo.Fun_Print2()，Aoo类中并没有Fun_Print2()函数
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3.4 类模板对象做函数参数

（1）、类模板实例化出的对象，向函数传参的方式；

（2）、一共有三种传入方式：

1）、指定传入的类型 — 直接显示对象的数据类型；

// 类模板对象做函数参数：指定传入的类型

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个Person类模板
template<class nameType, class ageType = int>  // 类模板在模板参数列表中可以有默认参数
class Person {

public:
	Person(nameType name, ageType age) {  // 有参构造，赋值
		this->m_Name = name;
		this->m_Age = age;
	}

	void Fun_Print() {  // 打印成员属性
		cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
	}

public:
	nameType m_Name;  // 姓名
	ageType m_Age;  // 年龄
};

// 1、指定传入的类型
void Print_Person(Person<string>& p) {  // Person类模板的对象p做函数Print_Person中的一个参数
	p.Fun_Print();
}

void test() {

	Person<string> p("张三", 18);  // ：类模板参数类型；p("张三", 18)：有参构造
	Print_Person(p);  // 调用Print_Person()函数，传入p
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

2）参数模板化 — 将对象中的参数变为模板进行传递；

// 类模板对象做函数参数：参数模板化

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个Person类模板
template<class nameType, class ageType = int>  // 类模板在模板参数列表中可以有默认参数
class Person {

public:
	Person(nameType name, ageType age) {  // 有参构造，赋值
		this->m_Name = name;
		this->m_Age = age;
	}

	void Fun_Print() {  // 打印成员属性
		cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
	}

public:
	nameType m_Name;  // 姓名
	ageType m_Age;  // 年龄
};

// 2、参数模板化
template<class T1, class T2>  // 告诉函数T1, T2是模板中的两个参数类型
void Print_Person(Person<T1, T2>& p) {  // 将string, int模板化，变成T1, T2
	p.Fun_Print();

	// typeid()查看类型，name()将类型以字符串形式显示出来
	cout << "T1的类型为： " << typeid(T1).name() << endl;  
	cout << "T2的类型为： " << typeid(T2).name() << endl;
}

void test() {

	Person<string, int> p("李四", 40);  // ：类模板参数类型；p("李四", 40)：有参构造
	Print_Person(p);  // 调用Print_Person()函数，传入p
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3）、整个类模板化 — 将这个对象类型模板化进行传递。

// 类模板对象做函数参数：整个类模板化

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个Person类模板
template<class nameType, class ageType = int>  // 类模板在模板参数列表中可以有默认参数
class Person {

public:
	Person(nameType name, ageType age) {  // 有参构造，赋值
		this->m_Name = name;
		this->m_Age = age;
	}

	void Fun_Print() {  // 打印成员属性
		cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
	}

public:
	nameType m_Name;  // 姓名
	ageType m_Age;  // 年龄
};

// 3、整个类模板化
template<class T>
void Print_Person(T& p) {  // 编译器自动推导出T为Person类型
	p.Fun_Print();

	// typeid()查看类型，name()将类型以字符串形式显示出来
	cout << "T的类型为： " << typeid(T).name() << endl;  
}

void test() {

	Person<string, int> p("王五", 51);
	Print_Person(p);  // 调用Print_Person()函数，传入p
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

（1）、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型；

（2）、如果不指定，编译器无法给子类分配内存；

// 类模板继承

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个父类模板
template<class T>
class Aoo {
	T m;
};

//class Boo :public Aoo {};  // 错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Boo :public Aoo<int> {  // 必须指定一个类型；此时类型写死，必须是int

};

void test() {

	Boo b;
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（3）、如果想灵活指定出父类中T的类型，子类也需变为类模板。

// 类模板继承

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个父类模板
template<class T>
class Aoo {
	T m;
};

// 如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1, class T2>
class Boo :public Aoo<T2> {  // 类模板继承类模板 ,可以用T2指定父类中的T类型

public:
	Boo() {
		// typeid()查看类型，name()将类型以字符串形式显示出来
		cout << "T1的类型为： " << typeid(T1).name() << endl;
		cout << "T2的类型为： " << typeid(T2).name() << endl;
	}

	T1 t;
};

void test() {

	Boo<int, char> b;  // int传给T1，T1为子类Boo中t的类型；char传给T2，T2为父类Aoo中m的类型
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3.6 类模板成员函数类外实现

// 类模板中成员函数类外实现

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个类模板，只声明
template<class T1, class T2>
class Person {

public:

	// 成员函数类内声明
	Person(T1 name, T2 age);
	void Fun_Print();

public:

	T1 m_Name;  // 姓名
	T2 m_Age;  // 年龄
};

// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {  // 类模板的类外实现；Person::Person(T1 name, T2 age)普通函数的类外实现；Person::作用域
	this->m_Name = name;
	this->m_Age = age;
}

// 成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::Fun_Print() {  // Person类::作用域下的Fun_Print()函数，体现为模板参数列表，template告诉服务器为类模板中的成员函数参数类型
	cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
}

void test() {

	Person<string, int> p("张三", 18);
	p.Fun_Print();
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3.7 类模板分文件编写

类模板成员函数分文件编写产生的问题：

类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决方式：

（1）、解决方式1：直接包含.cpp源文件（将包含头文件person.h改为person.cpp）；

Person.h中代码：

#pragma once  // 防止头文件重复包含

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 创建一个类模板，只声明
template<class T1, class T2>
class Person {

public:

	// 成员函数类内声明
	Person(T1 name, T2 age);
	void Fun_Print();

public:

	T1 m_Name;  // 姓名
	T2 m_Age;  // 年龄
};

Person.cpp中代码：

# include "Person.h"  // 包含Person.h头文件

// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {  // 类模板的类外实现；Person::Person(T1 name, T2 age)普通函数的类外实现；Person::作用域
	this->m_Name = name;
	this->m_Age = age;
}

// 成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::Fun_Print() {  // Person类::作用域下的Fun_Print()函数，体现为模板参数列表，template告诉服务器为类模板中的成员函数参数类型
	cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
}

main.cpp中代码：

//#include "person.h"  // 模板函数，调用时生成，包含person.h头文件，头文件中的模板函数Person、showPerson并不会生成产生这两个函数，看不到也不会去找cpp中的函数

#include "Person.cpp"  // 解决方式1：直接包含Person.cpp源文件

void test() {

	Person<string, int> p("LZQ", 25);
	p.Fun_Print();  // 调用p对象的Fun_Print()函数
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（2）、解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。

Person.hpp中代码：

#pragma once  // 防止头文件重复包含

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

 // 创建一个类模板，只声明
template<class T1, class T2>
class Person {

public:

	// 成员函数类内声明
	Person(T1 name, T2 age);
	void Fun_Print();

public:

	T1 m_Name;  // 姓名
	T2 m_Age;  // 年龄
};

// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {  // 类模板的类外实现；Person::Person(T1 name, T2 age)普通函数的类外实现；Person::作用域
	this->m_Name = name;
	this->m_Age = age;
}

// 成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::Fun_Print() {  // Person类::作用域下的Fun_Print()函数，体现为模板参数列表，template告诉服务器为类模板中的成员函数参数类型
	cout << "姓名：" << this->m_Name << "   年龄：" << this->m_Age << endl;
}

main.cpp中代码：

// 解决方式2：将声明和实现写到一起，文件后缀名改为.hpp（hpp一般看见，就知道是类模板，约定俗成）
#include "person.hpp"

void test() {

	Person<string, int> p("LZQ", 25);
	p.Fun_Print();  // 调用p对象的Fun_Print()函数
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

3.8 类模板与友元

类模板配合友元函数的类内和类外实现

（1）、全局函数类内实现 ----- 直接在类内声明友元即可；

// 类模板中成员函数类内实现

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

 // 创建一个类模板Person
template<class T1, class T2>
class Person {

	// 1、全局函数配合友元   类内实现  （直接在类内写全局有元函数的函数定义和函数实现）
	friend void Fun_Print(Person<T1, T2>& p) {  // Person类型，有两个属性，参数模板化
		cout << "姓名：" << p.m_Name << "   年龄：" << p.m_Age << endl;
	}

public:

	Person(T1 name, T2 age) {  // 构造函数需写在public公共下，否则无法初始化对象
		this->m_Name = name;
		this->m_Age = age;
	}

private:  // 私人属性

	T1 m_Name;  // 姓名
	T2 m_Age;  // 年龄
};

void test() {

	// 1、全局函数在类内实现

	Person <string, int> p("张三", 18);  // 创建Person对象p("张三", 18);
	Fun_Print(p);  // 调用全局函数
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

（2）、全局函数类外实现 ----- 需要提前让编译器知道全局函数的存在。

// 类模板中成员函数类外实现

#include   // 包含标准输入输出流头文件
using namespace std;  // 使用标准命名空间

// 2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
// 提前让编译器知道Person类的存在
template<class T1, class T2> class Person;

// 如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
//template void Fun_Print(Person & p); 

template<class T1, class T2>
// 函数模板的实现；先让编译器看到这有一个类外实现的模板函数定义；函数中有个Person类型，需让编译器知道有个Person存在，并告诉编译器这是一个模板，加上模板template
void Fun_Print(Person<T1, T2>& p) {  // 全局函数，不需要加作用域
	cout << "类外实现 ----    姓名：" << p.m_Name << "   年龄：" << p.m_Age << endl;
}

 // 创建一个类模板Person
template<class T1, class T2>
class Person {

	// 2、全局函数配合友元  类外实现
	// 加一个空模板参数列表<>；代表函数模板的函数声明
	// 如果全局函数是类外实现，需要让编译器提前知道这个函数的存在；本质发生变化，这是一个函数模板
	// 如果不加<>，实际是一个普通函数的声明；和类外的函数模板实现不是一套东西
	friend void Fun_Print<>(Person<T1, T2>& p);

public:

	Person(T1 name, T2 age) {  // 构造函数需写在public公共下，否则无法初始化对象
		this->m_Name = name;
		this->m_Age = age;
	}

private:  // 私人属性

	T1 m_Name;  // 姓名
	T2 m_Age;  // 年龄
};

void test() {

	// 2、全局函数在类外实现

	Person <string, int> p("张三丰", 999);  // 创建Person对象p("张三丰", 999);
	Fun_Print(p);  // 调用全局函数
}

int main() {

	test();

	system("pause");  // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果

	return 0;  // 程序正常退出
}

经典案例：类模板案例

总结

（1）、函数模板利用关键字 template；

（2）、使用函数模板有两种方式：自动类型推导、显示指定类型；

（3）、模板的目的是为了提高复用性，将类型参数化；

（4）、使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型；

（5）、建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T；

（6）、既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性；

（7）、利用具体化的模板，可以解决自定义类型的通用化；

（8）、学习模板并不是为了写模板，而是在STL能够运用系统提供的模板；

（9）、类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板；

（10）、类模板使用只能用显示指定类型方式；

（11）、类模板中的模板参数列表可以有默认参数；

（12）、类模板中的成员函数并不是一开始就创建的，在调用时才去创建；

（13）、通过类模板创建的对象，可以有三种方式向函数中进行传参；

（14）、使用比较广泛是第一种：指定传入的类型；

（15）、如果父类是类模板，子类需要指定出父类中T的数据类型；

（16）、类模板中成员函数类外实现时，需要加上模板参数列表；

（17）、类模板分文件编写主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

（18）、建议全局函数做类内实现，用法简单，而且编译器可以直接识别；

（19）、模板可以提高代码复用，需要熟练掌握。

你可能感兴趣的:(C++,c++,开发语言)

OCS2 是一个针对切换系统最优控制（OCS2）的 C++工具箱十年一梦实验室 c++开发语言
https://github.com/leggedrobotics/ocs2我将详细介绍位于https://github.com/leggedrobotics/ocs2的OCS2项目，这是一个由leggedrobotics团队开发并维护的开源软件库，专注于开关系统的最优控制（OptimalControlforSwitchedSystems）。以下是对其背景、功能、特点、应用场景及使用方法的全面说明
HarmonyNext实战：基于ArkTS的跨平台3D图形渲染应用开发 harmonyos-next
HarmonyNext实战：基于ArkTS的跨平台3D图形渲染应用开发引言3D图形渲染是现代应用开发中的一个重要领域，尤其在游戏、虚拟现实和增强现实等场景中。HarmonyOSNext作为新一代操作系统，提供了强大的图形渲染能力，而ArkTS作为其核心开发语言，为开发者提供了高效、简洁的开发体验。本文将深入探讨如何在HarmonyNext平台上使用ArkTS开发一个跨平台的3D图形渲染应用，涵盖3
Python真经：代码修仙录 zzzzjflzdvkk python 开发语言青少年编程 python真经
第一章：Python真经的起源在八十年代末，九十年代初，荷兰国境之内，有一位名为GuidovanRossum的修士，于国家数学与计算机科学研究所中，悟出了一门无上真经——Python。此真经融合了诸多上古大能的智慧结晶，如ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unixshell等，终成一体，化为Python真经。Python真经自诞生之日起，便遵循GPL（GN
C++ QT 树支持按住Ctrl, 多次点击，多选node 吗？ m0_68739984 c++qt 开发语言
Yes,inC++Qt,youcanenablemultipleselectionsinaQTreeViewusingCtrlformulti-clickselection.ThisishandledbysettingtheselectionModepropertyofthetreeviewtoQAbstractItemView::MultiSelection,whichallowsmultipl
计算机毕业设计Java河南省农村多元化养老服务管理系统设计与实现(源码+系统+mysql数据库+lw文档) 山逸网络数据库 java mysql
计算机毕业设计Java河南省农村多元化养老服务管理系统设计与实现(源码+系统+mysql数据库+lw文档)计算机毕业设计Java河南省农村多元化养老服务管理系统设计与实现(源码+系统+mysql数据库+lw文档)本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win1
C/C++都有哪些开源的Web框架？草原上唱山歌笔记 c++开源前端
CppCMSCppCMS是一个采用C++语言开发的高性能Web框架，通过模版元编程方式实现了在编译期检查RESTful路由系统，支持传统的MVC模式和多种语言混合开发模式。CppCMS最厉害的功能是WebSocket，10万连接在内存中长期保存占用的大小不超过600MB，直接将WS和Node.js甩几条街。某自动驾驶公司的OTA服务使用该框架构建API网关，在编译阶段完成所有的接口参数校验，软件运
C++内存管理秘籍：深入解析与实战代码示例黑猫Teng 编程学习 c++java 开发语言
C++内存管理秘籍：深入解析与实战代码示例一、内存管理的基本概念二、内存泄漏与野指针三、智能指针：现代C++的内存管理利器四、实战代码示例示例1：传统动态内存管理示例2：使用`std::unique_ptr`示例3：使用`std::shared_ptr`五、总结在C++编程的世界里，内存管理是一项既基础又核心的技能。它直接关系到程序的性能、稳定性和可维护性。不同于一些高级语言自动管理内存的特性，C
LeetCode 热题 100_前 K 个高频元素（73_347_中等_C++）(堆)(哈希表+排序；哈希表+优先队列（小根堆）) Dream it possible！ LeetCode 热题 100 leetcode c++散列表数据结构
LeetCode热题100_前K个高频元素（73_347）题目描述：输入输出样例：题解：解题思路：思路一（哈希表+排序）：思路二（哈希表+优先队列（小根堆））：代码实现代码实现（思路一（哈希表+排序））：代码实现（思路二（哈希表+优先队列（小根堆）））：以思路二为例进行调试部分代码解读题目描述：给你一个整数数组nums和一个整数k，请你返回其中出现频率前k高的元素。你可以按任意顺序返回答案。输入输
CCF CSP 第30次（2023.09）（1_坐标变换_C++）（先输入再计算；边输入边计算） Dream it possible！ CCF CSP认证 c++算法 CSP
CCFCSP第30次（2023.09）（1_坐标变换_C++）题目描述：输入格式：输出格式：样例输入：样例输出：样例解释：子任务：解题思路：思路一（先输入再计算）：思路二（边输入边计算）：代码实现代码实现（思路一（先输入再计算））：代码实现（思路一（边输入边计算））：时间限制：1.0秒空间限制：512MiB题目描述：对于平面直角坐标系上的坐标(x,y)，小P定义了一个包含n个操作的序列T=(t1,
LeetCode 热题 100_两数相加（28_2_中等_C++）(单链表) Dream it possible！ LeetCode 热题 100 leetcode c++算法
LeetCode热题100_两数相加（28_2）题目描述：输入输出样例：题解：解题思路：代码实现（思路一（使用原链表存储答案））：代码实现（思路二（使用新链表存储答案））：题目描述：给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字0之外，这两个数都不会以0开头。输入输出
LeetCode 热题 100_数组中的第K个最大元素（74_215_中等_C++）（堆）（暴力破解法（将整个数组进行排序）；线性时间选择（快速排序：基础版）；线性时间选择（快速排序：三路划分）） Dream it possible！ LeetCode 热题 100 leetcode c++算法
LeetCode热题100_数组中的第K个最大元素（74_215）题目描述：输入输出样例：题解：解题思路：思路一（暴力破解法（将整个数组进行排序））：思路二（线性时间选择（快速排序：基础版））：思路三（线性时间选择（快速排序：三路划分））：代码实现代码实现（思路一（暴力破解法（将整个数组进行排序）））：代码实现（思路二（线性时间选择（快速排序：基础版）））：代码实现（思路三（线性时间选择（快速排序
CCF CSP 第30次（2023.05）（2_矩阵运算_C++）（暴力破解）(矩阵相乘) Dream it possible！ CCF CSP认证矩阵 c++算法
CCFCSP第30次（2023.05）（2_矩阵运算_C++）题目背景：题目描述：输入格式：输出格式：样例输入样例输出：样例解释：子任务：提示：解题思路：思路一（暴力破解）：代码实现代码实现：部分代码解读时间限制：5.0s空间限制：512.0MB题目背景：Softmax(Q×KT/√d)×V是Transformer中注意力模块的核心算式，其中Q、K和V均是n行d列的矩阵，KT表示矩阵K的转置，×表
C++中map和set的详解 yang789022 c++算法开发语言
C++中map和set的介绍与使用在C++编程中，map和set是标准模板库（STL）中两种非常重要的关联容器。它们基于平衡二叉搜索树（通常是红黑树）的数据结构来实现，提供了高效的数据存储和检索功能。本文将详细介绍map和set的特点、用法以及一些常见的操作示例。一、map的介绍与使用1.map的基本概念map是一个键值对容器，其中每个键都是唯一的，且按照升序排序。map的内部结构是红黑树，这使得
C++中map和set的详解漏洞猎人001 c++算法开发语言
C++中map和set的介绍与使用在C++编程中，map和set是标准模板库（STL）中两种非常重要的关联容器。它们基于平衡二叉搜索树（通常是红黑树）的数据结构来实现，提供了高效的数据存储和检索功能。本文将详细介绍map和set的特点、用法以及一些常见的操作示例。一、map的介绍与使用1.map的基本概念map是一个键值对容器，其中每个键都是唯一的，且按照升序排序。map的内部结构是红黑树，这使得
C++每日一练——day 1 「已注销」 #C++每日一练 C++c++
年轻人，你渴望拥有C++练习题吗？？？从这篇博文开始，我每天都会更新一个C++主要知识点题目，并附上解析！~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Dayone——解密题目描述给你这样一个任务：解密一份被加密过的文件。经过研究，你发现了加密文件有如下加密规律（括号中是一个“原文一>密文”的例子）
每日一练—C++专项练习 7.24 weixin_42095973
1、已知：类A中一个成员函数说明如下：voidSet(A&a);其中，A&的含义是（）A、指向类A的指针为aB、将a的地址赋值给变量SetC、a是类A对象的引用，用来作函数Set()的参数D、变量A与a按位与作为Set()的参数选择C。2、下面哪个语句无法通过编译?A、if(x>y);B、if(x=y)&&(x!=0)x+=y;C、if(x!=y)scanf("%d",&x);elsescanf(
24点游戏算法（c++每日一练）三少爷的剑！ c++每日一练 c++
问题描述：给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利输入：4个1-10的数字。[数字允许重复，但每个数字仅允许使用一次，测试用例保证无异常数字]输出：trueorfalse#include#includeusingnamespacestd;boolis(vectora,intnum,intkey){if(a.size()==0){returnkey==num;}for(inti=
每日一练模拟卷（1）参考答案「已注销」 #各大编程比赛题目解析 c++
2024CCF非专业级别软件能力认证第一轮(CSP-J1)入门级C++语言试题-模拟卷（一）考生注意事项：满分100分。请在答题纸上作答，写在试题纸上的一律无效。不得使用任何电子设备（如计算器、手机、电子词典等）或查阅任何书籍资料。一、单项选择题（共15题，每题2分，共计30分;每题有且有一个正确选项)1.C++语言中，程序在什么阶段对define定义的内容进行替换?()A.链接B.编译C.预处理
C++ 前置递增（Preincrement）和前置递减（Predecrement）十年一梦实验室 c++算法
我来为你详细讲解前置递增（Preincrement）和前置递减（Predecrement），以及它们与后置形式（Postincrement和Postdecrement）的区别和使用建议。什么是递增和递减运算符？在编程中，递增（increment）和递减（decrement）运算符用于将变量的值增加或减少1。它们有两种形式：前置（Prefix）：运算符写在变量前面，例如++i（前置递增）或--i（前
C++入门基础------类的介绍 XG丶小哥 C++c++
本文是对C++的一些知识点总结以及自己的理解，建议是对于C有较好的理解或者是学过一些C++的同学使用，可以加深自己的理解！C++基础一、类的定义二、创建类对象三、访问类的成员四、类成员变量和成员函数五、C++类的访问权限六、类的简单封装七、类的构造函数八、C++构造函数初始化列表九、析构函数十、this指针十一、C++中的静态变量十二、静态函数十三、const成员函数一、类的定义类是创建对象的模板
C++8--赋值运算符重载大胆飞猪 c++
1.运算符重载C++引入运算符的目的是为了增强代码的可读性。运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数相似。函数名字为：关键字operator后面接需要重载的运算符符号函数原型：返回值类型operator操作符(参数列表)注意：不能通过连接其他符号来创建新的操作符：比如operator@重载操作符必须有一个类类型参数用于内置类型的
C++14--内存管理（new delete）大胆飞猪 c++
目录1.C++内存管理方式1.1new/delete操作内置类型1.2new和delete操作自定义类型2.operatornew与operatordelete函数3.new和delete的实现原理3.1内置类型3.2自定义类型4.定位new表达式(placement-new)5.malloc/free和new/delete的区别1.C++内存管理方式前言C语言内存管理在C++中可以继续使用，但是
C++26--包装器（function bind）大胆飞猪 c++
目录function包装器bindfunction包装器function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要function呢？ret=func(x);//上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)?也有可能是//lambda表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能
C++枚举算法详解卫青~护驾！算法数据结构 c++青少年编程枚举算法
一、枚举算法核心思想枚举算法是一种通过遍历所有可能情况来解决问题的暴力搜索方法，其核心特点是：全面性：不遗漏任何可能性简单性：逻辑直接易实现低效性：时间复杂度通常较高（O(n^k)）适用场景：问题规模有限且可穷举的情况（如数值范围小、维度低）二、经典案例：福尔摩斯密码破解问题描述ABCDE×?=EDCBA其中A,E,?∈[1,9]，B,C,D∈[0,9]所有字符互不相同算法实现（6层嵌套循环）fo
C++中栈的用法冬瓜生鲜 1 大学学习的算法
简单记忆，具体详细见：https://blog.csdn.net/qq_20366761/article/details/70053813c++栈的方法的基本用法：push():向栈内压入一个成员；pop():从栈顶弹出一个成员；empty():如果栈为空返回true，否则返回false；top():返回栈顶，但不删除成员；size():返回栈内元素的大小；#include#includeusin
C++调用Python程序方法超级大反派@_@ C++c++python 开发语言
前言：在之前做的一个项目中，要使用一段Python的代码。一般来讲可以将Python代码中的功能在C++项目中重构，但是如果Python项目太大，或者这部分是别人写的，自己不清楚整个项目的逻辑，这样重构起来就比较麻烦。这里给出了另外一种实现方法，即利用Python的API使得C++项目可以直接启动Python程序，快速在PC端验证代码功能。急性子可直接看：2.2C++调用python有参有返回值函
北本海硕腾讯二面没过，该如何准备才能再战大厂？程序员yt 面试
今天给大家分享的是一位粉丝的提问，北本海硕腾讯二面没过，该如何准备才能再战大厂？接下来把粉丝的具体提问和我的回复分享给大家，希望也能给一些类似情况的小伙伴一些启发和帮助。同学提问：bg北本海硕两段大厂实习，感觉自己bg其实不错但问题是实习干的都是些crud当时也没意识记录一些更深刻的技术或者架构上的问题，八股又欠背(大致看完了小林codinga和csguilde的c++指北但实际中延伸出来的问题太
vscode中调试Python和C++的混合代码 destiny44123 vscode python c++
文章目录使用流程参考一些差异使用流程参考ExampledebuggingmixedPythonC++inVSCode一些差异这里假设的项目是通过python调用c++的相应共享库(so)文件。首先，新建文件夹.vscode，在其中添加文件配置launch.json.示例如下：{"version":"0.2.0","configurations":[{"name":"(gdb)附加","type":
C++：std::vector常用函数及用法详解湫兮之风 c++c++算法开发语言
std::vector是C++标准库中最常用的动态数组容器，提供了丰富的操作方法，支持动态扩展、插入、删除等操作。本文将详细介绍vector的常用函数及其用法，并配合代码示例说明。1.std::vector的基本使用在C++中，vector需要包含头文件：#include示例：#include#includeintmain(){std::vectorvec={1,2,3,4,5};for(intn
2024年最新【Rust指南】快速入门开发环境 hello world_rust开发是啥(3) 2301_79772893 程序员 rust 开发语言后端
2、与其他编程语言相比较C/C++性能很好，但是系统类型和内存都不太安全。Java/C#，拥有GC机制，能保证内存安全，特性也优秀，但是性能不行Rust：安全无需GC代码安全高效，易于维护、调试3、Rust特别擅长的领域高性能WebServiceWebAssembly命令行工具网络编程嵌入式设备系统编程4、Rust的用户和案例Google：新操作系统Fuschia，其中Rust代码量约占30%Am
PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 java UI PHP android linux
╔-----------------------------------╗┆
各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 bozch .net .net mvc
在.net mvc5中，在执行某一操作的时候，出现了如下错误：各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。回想过去：在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。 &
Java 对象大小的计算 e200702084 java
Java对象的大小如何计算一个对象的大小呢？
Mybatis Spring 171815164 mybatis
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); CustomerService userService = (CustomerService) ac.getBean("customerService"); Customer cust
JVM 不稳定参数 g21121 jvm
-XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。可以说“不稳定参数”
用户自动登录网站永夜-极光用户
1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 2.思路:将用户的信息保存为cookie 每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
centos7 安装后失去win7的引导记录程序员是怎么炼成的操作系统
1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ### 在后面添加 menuentry "Windows 7 (loader) (on /dev/sda1)" {
Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载 aijuans oracle
Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
JavaEE开源快速开发平台G4Studio_V3.2发布了無為子 AOP oracle mysql javaee G4Studio
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。访问G4Studio网站 http://www.g4it.org G4Studio_V3.2版本变更日志功能新增 (1).新增了系统右下角滑出提示窗口功能。 (2).新增了文件资源的Zip压缩和解压缩
Oracle常用的单行函数应用技巧总结百合不是茶日期函数转换函数(核心)数字函数通用函数(核心)字符函数
单行函数; 字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 一:字符函数: .UPPER(字符串) 将字符串转为大写 .LOWER (字符串) 将字符串转为小写 .INITCAP(字符串) 将首字母大写 .LENGTH (字符串) 字符串的长度 .REPLACE(字符串,'A','_') 将字符串字符A转换成_
Mockito异常测试实例 bijian1013 java 单元测试 mockito
Mockito异常测试实例： package com.bijian.study; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Assert; import org.junit.Test; import org.mockito.
GA与量子恒道统计 Bill_chen JavaScript 浏览器百度 Google 防火墙
前一阵子，统计**网址时，Google Analytics（GA）和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下：为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
【Linux命令三】Top命令 bit1129 linux命令
Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果： top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99 Tasks: 202 total, 4 running, 198 sl
spring四种依赖注入方式白糖_ spring
平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
angular.injector boyitech AngularJS AngularJS API
angular.injector 描述: 创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入. 使用方法: angular.injector(modules, [strictDi]) 参数详解: Param Type Details mod
java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待 bylijinnan Integer
public class PC { /** * 题目：生产者-消费者。 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。 */ private static final Integer[] val=new Integer[10]; private static
使用Struts2.2.1配置 Chen.H apache spring Web xml struts
Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar struts2-core-2.2.1.jar struts2-sp
[职业与教育]青春之歌 comsci 教育
每个人都有自己的青春之歌............但是我要说的却不是青春... 大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的.... &nbs
oracle连接(join)中使用using关键字 daizj JOIN oracle sql using
在oracle连接(join)中使用using关键字 34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. Evaluate the following SQL statement: SELECT oi.order_id, product_id, order_date FRO
NIO示例 daysinsun nio
NIO服务端代码： public class NIOServer { private Selector selector; public void startServer(int port) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(
C语言学习homework1 dcj3sjt126com c homework
0、课堂练习做完 1、使用sizeof计算出你所知道的所有的类型占用的空间。 int x; sizeof(x); sizeof(int); # include <stdio.h> int main(void) { int x1; char x2; double x3; float x4; printf(&quo
select in order by , mysql排序 dcj3sjt126com mysql
If i select like this: SELECT id FROM users WHERE id IN(3,4,8,1); This by default will select users in this order 1,3,4,8, I would like to select them in the same order that i put IN() values so:
页面校验-新建项目 fanxiaolong 页面校验
$(document).ready( function() { var flag = true; $('#changeform').submit(function() { var projectScValNull = true; var s =""; var parent_id = $("#parent_id").v
Ehcache（02）——ehcache.xml简介 234390216 ehcache ehcache.xml 简介
ehcache.xml简介 ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
junit 4.11中三个新功能 jackyrong java
junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 import static org.junit.Assert.assertEquals; import java.util.Arrays; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runn
国外程序员爱用苹果Mac电脑的10大理由 php教程分享 windows PHP unix Microsoft perl
Mac 在国外很受欢迎，尤其是在设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 1、Mac OS X 是基于 Unix 的这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
位运算、异或的实际应用 wenjinglian 位运算
一．位操作基础，用一张表描述位操作符的应用规则并详细解释。二．常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。三．位操作与空间压缩，针对筛素数进行空间压缩。 &n
weblogic部署项目出现的一些问题（持续补充中……） Everyday都不同 weblogic部署失败
好吧，weblogic的问题确实…… 问题一： org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
tomcat7性能调优（01） toknowme tomcat7
Tomcat优化： 1、最大连接数最大线程等设置 <Connector port="8082" protocol="HTTP/1.1" useBodyEncodingForURI="t
PO VO DAO DTO BO TO概念与区别 xp9802 java DAO 设计模式 bean 领域模型
O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持