第一章 模板

最新推荐文章于 2024-11-04 23:11:51 发布
最新推荐文章于 2024-11-04 23:11:51 发布
阅读量97 收藏
点赞数
分类专栏： # 泛型编程 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Memorise1999/article/details/122223777
版权

本阶段主要针对c++泛型编程和STL技术做详细讲解

1模板

1.1模板的概念

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

模板的特点

  • 不可以直接使用，他只是一个框架
  • 模板的通用并不是万能的

1.2函数模板

  • c++另一种编程思想称为泛型编程，主要利用的技术就是模板
  • c++提供两种模板机制：函数模板和类模板

1.2.1函数模板语法

函数模板作用：

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

语法：

template<typename T>

函数声明或定义

解释：

template——声明创建模板

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

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

代码

#include<iostream>
using namespace std;
//交换两个整型类型
void swapInt(int &a, int &b) 
{
	int temp = a;
	a = b;
	b = temp;
}
//交换两个浮点类型
void swapDouble(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
//模板
template<typename T>  //声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void mySwap(T &a, T &b) 
{
	T temp = a;
	a = b;
	b = temp;
}

void test01() 
{
	int a = 10;
	int b = 20;
	
	double c = 1.1;
	double d = 2.2;
	//swapInt(a, b);

	//利用函数模板进行交换
	//两种方式使用函数模板
	//1、自动类型推导
	//mySwap(a, b);

	//2、显示指定类型
	mySwap<int>(a, b);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	mySwap<double>(c, d);
	cout << "c=" << c << endl;
	cout << "d=" << d << endl;
}

int main()
{
	test01();

	system("pause");

	return 0;
}

总结

  • 函数模板利用关键字template；
  • 使用函数模板有两种方式：自动类型推导、显示指定类型
  • 模板的目的是为了提高复用性，将类型参数化

1.2.2函数模板注意事项

注意事项

  • 自动类型推导，必须推导出一致的数据类型T，才可以使用
  • 模板必须要确定出T的数据类型，才可以使用

代码

#include<iostream>
using namespace std;

//函数模板注意事项
template<class T>
void mySwap(T&a, T&b)
{
	T temp = a;
	a = b;
	b = temp;
}
//1、自动类型推导，必须推导出一致的数据类型T才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'a';
	mySwap(a, b);
	//mySwap(a,c);  错误！推导出不一致的T类型
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}
//2、模板必须要确定出T的数据类型，才可以使用
template<class T>
void func()
{
	cout << "func的调用" << endl;
}

void test02()
{
	func<int>();
}

int main()
{
	test01();
	test02();

	system("pause");

	return 0;

}

1.2.3函数模板案例

案例描述

  • 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
  • 排序规则从大到小，排序算法为选择排序
  • 分别利用char数组和int数组进行测试

代码

#include<iostream>
using namespace std;

//实现通用对数组进行排序的函数
//规则 从大到小
//算法 选择
//测试 char 数组、 int 数组
template<class T>
void mySwap(T&a, T&b) 
{
	T temp = a;
	a = b;
	b = temp;
}


template<class T>
void mySort(T arr[], int len) 
{
	for (int i = 0; i < len; i++) 
	{
		int max = i;  //认定最大值的下标
		for (int j = i + 1; j < len;j++) 
		{
			//认定的最大值 比 遍历出的数值要小， 说明j下标的元素才是真正的最大值
			if (arr[max] < arr[j]) 
			{
				max = j;
			}
		}
		if (max != i) 
		{
			//交换max和i
			mySwap(arr[max], arr[i]);
		}
	}
}
template<class T>
void printArray(T arr[], int len) 
{
	for (int i = 0; i < len; i++) 
	{
		cout << arr[i] << "";
	}
	cout << endl;
}

void test01() 
{
	char charArr[] = "bacfd";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}

void test02() 
{
	int intArr[] = { 8,6,7,9,5,3,4 };
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);
}

int main()
{
	test01();
	test02();
	system("pause");

	return 0;
}

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

区别

  • 普通函数调用时可以发生自动类型转换（隐式类型转换）
  • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
  • 如果利用显示指定类型的方式，可以发生隐式类型转换

代码

#include<iostream>
using namespace std;
//区别
//1、普通函数调用可以发生隐式类型转换
//2、函数模板 用自动类型推导，不可以发生隐式类型转换
//3、函数模板 用显示指定类型，可以发生隐式类型转换

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

//函数模板
template<class T>
T myAdd02(T a, T b) 
{
	return a + b;
}

void test01() 
{
	int a = 10;
	int b = 20;
	char c = 'c';  // a-97  c-99 
	cout << myAdd01(a, c) << endl;

	//自动类型推导——不会发生隐式类型转换
	//cout << myAdd02(a, c) << endl;    不可以隐式类型转换：两个不一样的类型转换

	//显示指定类型——可以发生隐式类型转换
	cout << myAdd02<int>(a, c) << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

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

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

调用规则

  • 如果函数模板和普通函数都可以调用，优先调用普通函数
  • 可以通过空模板参数列表来强制调用函数模板
  • 函数模板也可以发生重载
  • 如果函数模板可以产生更好的匹配，优先调用函数模板

代码

#include<iostream>
using namespace std;
//1、当普通函数和函数模板都能调用，优先调用普通函数
//2、可以通过空模板参数列表来强制调用函数模板
//3、函数模板可以发生函数重载
//4、如果函数模板可以产生更好的匹配，优先调用函数模板
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 test01() 
{
	int a = 10;
	int b = 20;
	//myPrint(10, 20);
	//myPrint<>(a, b);
	myPrint(a, b, 200);

	char c = 'a';
	char d = 'b';
	myPrint(c, d);

}

int main()
{
	test01();
	system("pause");

	return 0;
}

总结：

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

1.2.6模板的局限性

局限性：

  • 模板的通用性并不是万能的

代码

#include<iostream>
using namespace std;
#include<string>
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;
	}
}

//利用具体化Person的版本实现代码，具体化优先调用
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;
	}
}
void test01() 
{
	int a = 10;
	int b = 20;
	bool ret = myCompare(a, b);
	if (ret) 
	{
		cout << "a==b" << endl;
	}
	else 
	{
		cout << "a!=b" << endl;
	}
}

void test02() 
{
	Person p1("Tom", 10);
	Person p2("Tom", 11);

	bool ret = myCompare(p1, p2);
	if (ret) 
	{
		cout << "p1==p2" << endl;
	}
	else 
	{
		cout << "p1!=p2" << endl;
	}
}

int main()
{
	//test01();
	test02();
	
	system("pause");

	return 0;
}

总结：

  • 利用具体化的模板，可以解决自定义类型的通用化
  • 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3类模板

1.3.1类模板语法

作用

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

语法：

template<typename T>

类

解释：

template——声明创建模板

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

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

代码

#include<iostream>
using namespace std;
#include<string>

//类模板
template<class NameType, class AgeType>
class Person 
{
public:
	Person(NameType name,AgeType age) 
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void ShowPerson()
	{
		cout << " name: " << this->m_Name << " age: " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

void test01() 
{
	Person<string, int>p1("孙悟空", 999);
	p1.ShowPerson();
}

int main()
{
	test01();
	system("pause");

	return 0;
}

1.3.2类模板与函数模板的区别

区别

  • 类模板没有自动类型推导的使用方式
  • 类模板在模板参数列表中可以有默认参数

代码

#include<iostream>
using namespace std;
#include<string>
template<class NameType, class AgeType = int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void ShowPerson()
	{
		cout << " name: " << this->m_Name << " age: " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

//1、类模板没有自动类型推导使用方法
void test01() 
{
	//Person p("孙悟空", 99);  无法使用自动类型推导
	Person<string, int>p1("孙悟空", 1000);
	p1.ShowPerson();
}

//2、类模板在模板参数列表中可以有默认参数
void test02() 
{
	Person<string>p2("猪八戒", 909);
	p2.ShowPerson();
}

int main()
{
	test01();
	test02();
	system("pause");

	return 0;
}

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

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

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建

代码

#include<iostream>
using namespace std;

class Person1 
{
public:
	void showPerson1() 
	{
		cout << "Person1 show" << endl;
	}
};

class Person2 
{
public:
	void showPerson2() 
	{
		cout << "Person2 show" << endl;
	}
};

template<class T>
class MyClass
{
public:
	T obj;
	void fun1() 
	{
		obj.showPerson1();
	}

	void fun2() 
	{
		obj.showPerson2();
	}
};

void test01() 
{
	MyClass<Person1>m;
	m.fun1();
	//m.fun2();  编译会出错，说明函数调用才会去创建成员函数
}

int main()
{
	test01();
	system("pause");

	return 0;
}

1.3.4类模板对象做函数参数

学习目标

  • 类模板实例化出的对象，向函数传参的方式

传入方式

  • 1.指定传入的类型——直接显示对象的数据类型
  • 2.参数模板化——将对象中的参数变为模板进行传递
  • 3.整个类模板化——将这个对象类型 模板化进行传递

代码

#include<iostream>
using namespace std;
#include<string>
//类模板对象做函数参数
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;
};

//1、指定传入类型

void printPerson1(Person<string, int>&p) 
{
	p.showPerson();
}
void test01() 
{
	Person<string, int>p("孙悟空", 100);
	printPerson1(p);
}
//2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2>&p)
{
	p.showPerson();
	cout << "T1的数据类型为：" << typeid(T1).name() << endl;
	cout << "T2的数据类型为：" << typeid(T2).name() << endl;
}
void test02()
{
	Person<string, int>p("猪八戒", 90);
	printPerson2(p);
}
//3、整个类模板化
template<class T>
void printPerson3(T &p)
{
	p.showPerson();
	cout << "T的数据类型为：" << typeid(T).name() << endl;
}
void test03()
{
	Person<string, int>p("唐僧", 30);
	printPerson3(p);
}

int main()
{
	test01();
	test02();
	test03();
	system("pause");

	return 0;
}

总结：

  • 通过类模板创建的对象，可以有三种方式向函数中进行传参
  • 使用比较广泛是第一种：指定传入的类型

1.3.5类模板与继承

注意事项

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指出父类中T的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果想灵活指定出父类中T的类型，子类也需变为类模板

代码

#include<iostream>
using namespace std;

//类模板与继承
template<class T>
class Base 
{
	T m;
};

//class Son :public Base //错误，必须要知道父类中的T类型，才能继承给子类
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 test02() 
{
	Son2<int, char>S2;
}

int main()
{
	test02();
	
	system("pause");

	return 0;
}

总结：

  • 如果父类是类模板，子类需要指定出父类中T的数据类型

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

代码

#include<iostream>
using namespace std;
#include<string>

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;
};

//构造函数类外实现
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 test01() 
{
	Person<string, int>P("Tom", 20);
	P.ShowPerson();
}

int main()
{
	test01();
	
	system("pause");

	return 0;
}

总结：

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

1.3.7类模板分文件编写

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

解决：

  • 直接包含.cpp源文件
  • 将声明和实现写到同一个文件中，并更改后缀名为.hpp,hpp是约定的名称，并不是强制

代码

在person.hpp中

#pragma once
#include<iostream>
using namespace std;

#include<string>

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;
}

类模板分文件编写.cpp中的代码

#include<iostream>
using namespace std;
//第一种解决方式，直接包含 源文件
//#include"person.cpp"

//第二种解决方式，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
#include"person.hpp"

void test01()
{
	Person<string, int>P("Tom", 20);
	P.ShowPerson();
}

int main()
{
	test01();

	system("pause");

	return 0;
}

总结：

  • 主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

1.3.8类模板与友元

全局函数类内实现——直接在类内声明友元即可

全局函数类外实现——需要提前让编译器知道全局函数的存在

代码

#include<iostream>
using namespace std;
#include<string>

//提前让编译器知道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;
};



//1、全局函数在类内实现
void test01() 
{
	Person<string, int>p("Tom", 20);
	printPerson(p);
}

//2、全局函数在类外实现
void test02()
{
	Person<string, int>p("Jerry", 21);
	printPerson2(p);
}

int main()
{
	test01();
	test02();
	system("pause");

	return 0;
}

总结：

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

Memorises1999
关注
专栏目录
OpenCV 第七章 模板匹配和图像分割
weixin_45964083的博客
02-05 9037
一.模板匹配 定义：让模板图像在输入图像中滑动逐像素遍历整个图像进行比较，查找出与模板图像最匹配的部分。 单目标匹配 定义：输入图像中只存在一个可能匹配结果 基本格式如下： result = cv2.matchTemplate(image,templ,method) image为输入图像 templ为模板图像，要小于image method为匹配方法，如下： cv2.TM_SQDIFF：以方差结果为依据进行匹配。完全匹配时结果为零，否则为很大的值 cv2.TM_SQDIFF_NORMED:标准（归一化
第七章 模板（课后习题）
冯文彬38381415130
06-07 1886
一、名词解释函数模板：一个带类属参数的函数；类模板：一个带类属参数的类；模板函数：通过参数实例化可以再构造出具体的函数；模板类：通过参数实例化可以再构造出具体的类；二、填空题（1）C++支持两种模板，一种是  （  函数模板     ）  ，另一种是   （  类模板    ）  。（2）关键字  （ template ） 是定义模板的关键字。（3）&lt;模板参数表&gt;中包含一个或多个用逗号...
Acwing 第一章模板及详解（基础算法）
weixin_64393298的博客
02-03 9679
一、排序 二、二分 三、高精度 四、前缀和与差分 五、双指针算法 六、位运算 七、离散化 八、区间合并 快速排序算法模板： 1.确定分界点 q[l] , q[(l+r)/2] , q[r]； //随机选取 2.调整区间，使小于等于x的在左边，大于等于x 的在右边； 3.递归处理x的左右段； void quick_sort(int q[], int l, int r) { if (l >= r) return; int i = l - 1, j = r +...
第七章 模板
MING_X的代码工场
04-13 1863
C++深入浅出 之 7.6 模板特性
第15章：模板匹配
weixin_57440207的博客
01-24 1万+
第15章：模板匹配一、模板匹配基础：1. cv2.matchTemplate()函数：2. 匹配原理：3. 查找最值：二、多模版匹配：1. 获取匹配位置集合：2. 循环：3.调整坐标4.标记匹配图像的位置 ​ 模板匹配是指在当前图像A内匹配与图像B最相似的部分，一般将图像A称为输入图像，将图像B称为模板图像。 模板匹配的方法是将模板图像B在图像A上滑动，逐个遍历所有像素以完成匹配。 ​ 例如，下图中，大图像“lena”是输入图像，“眼睛”图像是模板图像。查找的方式是，将模板图像在输入图像内从左上角开始滑
第三章 Jinja2模板
qq_42385761的博客
02-05 3270
jinja2模板
第七章 模板课后习题
qq_41798482的博客
06-24 1962
一、名词解释函数模板：一个带类属参数的函数；类模板：一个带类属参数的类；模板函数：通过参数实例化可以再构造出具体的函数；模板类：通过参数实例化可以再构造出具体的类；二、填空题（1）C++支持两种模板，一种是  （  函数模板     ）  ，另一种是   （  类模板    ）  。（2）关键字  （ template ） 是定义模板的关键字。（3）&lt;模板参数表&gt;中包含一个或多个用逗号...
西安电子科技大学硕士论文latex模板第1章修改为第一章
jk123vip的专栏
02-25 5696
就是章号从阿拉伯数字修改成中文数字。 在XDUthesis.cls中查找chapter，并照下图所示，将name={\arabic{chapter}}修改为name={\chinese{chapter}}。
第七章 C++函数模板介绍
qq_40632679的博客
04-18 1953
以下是本人整理的C++基础知识点，内容并不包含全面的C++知识，只是对C++重点内容、特点进行整理和归纳。 7.1 C++函数模板介绍 泛型程序设计方法 介绍：大量编写模板、使用模板的程序设计 特点 算法只实现一遍，适用于多种数据类型的处理 减少重复代码的编写 模板分类 函数模板和类模板 类型的参数化 数据的类型通过参数来传递 函数定义时，不指明具体的数据类型 函数调用时，编译器根据传入的实参自动推断数据类型 函数模板
第四章：Vue组件模板文件
热门推荐
Good Luck
10-24 8万+
第一步：导航模板，在menu-list.js文件中添加一栏，注意id不能与以往的冲突。 { id: '1', name: '用户管理', icon: 'el-icon-document-remove', info: '标准版的CRUD', childList: [ {id: '1-1', name: '新增用户', icon: 'el-icon-plus', url: 'sa-view/users/us
Dreamweaver第章模板和库完美版资料.ppt
11-14
本章主要介绍了如何利用Dreamweaver的模板和库功能提高工作效率，保持网站的一致性和易于更新。 6.1 模板 模板是Dreamweaver中的一个重要概念，它允许设计师创建一个基础布局，然后其他网页可以基于这个模板进行...
刑法学 第一章_xmind模板.xmind
07-31
刑法学 第一章_xmind模板.xmind
第8章旅游网站模板和库制作.ppt
11-12
本章主要介绍了如何利用库和模板来高效制作旅游网站。模板在网页设计中扮演着重要角色，它们可以提供一致的页面布局和风格，简化批量制作相似网页的过程，并且当模板发生变化时，所有基于该模板的网页也会自动更新，...
CMMI第十一章 系统设计模板
08-21
附录I-1 体系结构设计报告 附录I-2 用户界面设计 附录I-3 数据库设计报告 附录I-4 模块设计报告
halcon解决方案指导--模板匹配Matching（第一章、第二章、第三章）.doc
04-15
第一章 简介 5 1.1 怎样使用该手册？ 5 1.2 匹配是什么？ 5 1.3 如何进行一般的匹配? 6 1.4 可用的方法有哪些? 6 1.5哪种方法适用于哪种情况? 7 1.5.1 匹配方法:2D与3D的比较 7 1.5.2 3D空间中3D对象和2D对象的决策 ...
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 252
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
最新发布
ChoSeitaku的博客
11-04 673
表A，B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的值往后移，若元素值相等，则创建一个值等于两节点的元素值的新节点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾。一个工作指针cura用来遍历链表A，一个工作指针curb用来遍历链表B，一个工作指针curc用来建立链表C，一个指针new用来创建共同节点的新节点尾插到C链表上。循环结束后，如果curb指向NULL，表示链表B的curb都等于对应的cura，链表B是链表A的连续子序列。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 590
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++之指针和引用
weixin_42300449的博客
11-04 137
在C++中，指针和引用是两种不同的机制，它们都可以用来间接访问变量。
C++编程：第六章 模板与STL解析
"C++程序设计第六章涵盖了模板和STL的主要内容，由东北大学提供。" 在C++编程中，第六章重点讲解了模板（Templates）和标准模板库（STL）。模板是C++中的一个重要特性，它允许我们编写泛型代码，实现代码复用，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Memorises1999

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值