C++模板(泛型)

1. 模板

1.1 知识点

模板:template

泛型编程:

是指数据的类型是广泛,任意的数据类型

模板:可以将一个函数或类描述成一个模板,例如:画画,给一个人物模型上色彩,根据用户上的色彩是什么人物显示什么样的色彩

模板分为 函数模板  和  类模板

1.1.1 注意

(1)template用于声明一个模板

(2)typename/class来声明模板形参,模板形参是指传递给该函数的参数类型(模板形参就是该函数的参数类型),指定该函数里用的模板形参的类型

(3)模板形参要与函数形参一一对应

1.2 函数模板

关键字:template、class/typename

格式:


	template   <模板形参1,模板形参2,........>函数返回值   函数名   ([参数1,参数2,.......])
	{

	}
	template   函数返回值   函数名   ([参数1,参数2,.......])
	{
		
	}
	template   函数返回值   函数名   ([参数1,参数2,.......])
	{

	}	

1.2.1 函数模板的调用

与C/C++普通函数调用一致:

隐式调用

格式:
		函数名(实参1,实参2);//隐式调用(模板形参)
例如:
		sum(10,20);

函数模板的显示调用(模板形参):

格式:
		函数名 <数据类型1,数据类型2,.......>(实参1,实参2,......);
例如:
		sum (10,'a');

1.2.1.1 隐式调用

wide_practise.cpp

#include "iostream"
using namespace std;

//模板(泛型)

//声明函数模板写法1
template  void sum(T1 a,T2 b) {
	T1 m = a;
	T2 n = b;
	cout << "m= " << m << endl;
	cout << "n= " << n << endl;
}

声明函数模板写法2
//template  T1 sum(T1 a, T2 b) {
//	
//}
//
声明函数模板写法3
//template  T2 sum(T1 a, T2 b) {
//	
//}

int main()
{
	sum(10, 20);
	sum(10.2, 3.14);
	sum(10,"hello world");
	sum("hello","world");
	sum("你好",10);
	return 0;
}

C++模板(泛型)_第1张图片

1.2.1.2 显示调用

wide_practise.cpp

//模板(泛型)显示调用
//声明函数模板写法1
template  void sum(T1 a, T2 b) {
	T1 m = a;
	T2 n = b;
	cout << "m= " << m << "  n= " << n << endl;
}

int main()
{
	sum(10,20);//隐式调用
	sum(50, 60);//显示调用
	sum(40, 'a');
	return 0;
}

C++模板(泛型)_第2张图片

1.3.3 自定义类型调用

wide_practise.cpp
//模板(泛型)自定义类型
class People {
public:
	int num = 90;

};

//声明模板函数
template  void sum(T1 a, T2 b) {

	cout << "自定义类型的a= " << a.num << "  b= " << b << endl;
}

int main()
{
	People people;
	sum(people, 80);//隐式调用
	sum(people, 55);//显示调用

	return 0;
}

C++模板(泛型)_第3张图片

1.4 练习

编写如下形式的模板: template void sort(Type* A, int n, bool f)

对一个具有n个Type类型的一维数组进行排序,f伪1表示从小到大排序, f为0表示从大到小排序

要求使用快速排序

wide_test.cpp

#include "iostream"
#include 
using namespace std;


//编写如下形式的模板: template void sort(Type* A, int n, bool f)
//对一个具有n个Type类型的一维数组进行排序,f伪1表示从小到大排序, f为0表示从大到小排序
//快速排序

//使用快速排序
//将快速排序也声明为模板函数
template void quick_sort(Type arr[],int left,int right) {

	//跳出递归的条件
	if (left>=right) {
		return;
	}

	//左右哨兵
	int l = left;
	int r = right;

	//定义基准数
	Type base = arr[left];

	while (l!=r) {
		
		//右哨兵先走,遇见比基准数小的就停下(即比基准数大就走动)
		while(l=base) {
			r--;
		}
		//接着左哨兵走,遇见比基准数大的就停下(即比基准数小就走动)
		while (l(arr,left,r-1);
	quick_sort(arr,r+1,right);
}

//声明模板
template void sort(Type* arr, int n, bool f) {

	if (f) {//f为真正序排序

		//将快速排序也声明为模板函数
		quick_sort(arr,0,n-1);
	}
	else {//为假倒叙排序
		//我们现正排,然后反转数组,达到倒序排序的效果
		quick_sort(arr, 0, n - 1);

		int r = n;
		//数组反转
		for (int i = 0; i < n/2;i++) {
			Type tmp = arr[i];
			arr[i] = arr[r-1];
			arr[r-1] = tmp;
			r--;
		}
	}
	
}


int main()
{

	//传递整型
	int arr[] = { 8,4,1,2,7,13,2,4,8 }; 
	int size = sizeof(arr)/sizeof(arr[0]);
	sort(arr, size, 0);
	//遍历
	for (int i = 0; i < size;i++) {
		cout << arr[i]<<" ";
	}

	cout << endl;

	//传递字符型
	char arr2[] = { 'g','c','z','f','c','a'};
	int size2 = sizeof(arr2) / sizeof(arr2[0]);
	sort(arr2, size2, 1);
	//遍历
	for (int i = 0; i < size2; i++) {
		cout << arr2[i] << " ";
	}

	cout << endl;

	//传递浮点型
	double arr3[] = { 88.5,22.6,12.7,3.14,2.17,9.38 };
	int size3 = sizeof(arr3) / sizeof(arr3[0]);
	sort(arr3, size3, 0);
	//遍历
	for (int i = 0; i < size3; i++) {
		cout << arr3[i] << " ";
	}

	return 0;
}

C++模板(泛型)_第4张图片

2. 类模板

2.1 知识点

关键字:template、class/typename

格式:

	template  <模板形参1 , 模板形参2,非类型形参,......> class  类名
	{
		
	};
	template   class  类名
	{
		
	};	
	template   class  类名
	{
		
	};

2.1.1 注:

(1)class T1/T2等是模板形参,int  sum:非类型形参

非类型:是指实例化类的时候,不能传递类型,只能传递实参,非类型形参是整型int\short\long等等不能字符串或浮点型

2)<>里的class用于声明模板形参 ,  类名前的class用于声明一个类

2.2 举例

lei_template.cpp

#include "iostream"
using namespace std;

//声明模板类
//sum 这里的sum是非类型实参,传递时不能传递类型,要传递具体的值
template class Animal {
public:
	Animal(T1 a,T2 b) {
		this->a = a;
		this->b = b;

	}
	void diplay() {
		cout << "a= " << a << " b= " << b << endl;
	}

	T1 a;
	T2 b;
	int arr[sum];//我们利用非类型实参,给这个数组属性定义大小
};

int main()
{
	//实例化类模板
	Animal animal(10, 'v');
	animal.diplay();

	return 0;
}

C++模板(泛型)_第5张图片

2.3 练习

2.3.1 例1

我在一个类中定义了一个结构体,我在类中写了一个成员函数,返回值是结构体类型,我在主函数中使用此成员函数,该怎么接收返回值呢

test.cpp
#include 
using namespace std;

class MyClass {
public:
    // 定义一个结构体类型
    struct MyStruct {
        int data;
    };

    // 返回结构体类型的成员函数
    MyStruct getStruct() {
        MyStruct result;//定义结构类型
        result.data = 42;//给结构体属性赋值
        return result;//返回结构体类型
    }
};

int main() {
    // 实例化类对象
    MyClass myObject;

    // 调用成员函数并接收返回值
    // MyClass::MyStruct 访问嵌套的结构体类型
    //  MyClass::MyStruct 这种语法对于访问嵌套类型、静态成员或命名空间中的元素是很常见的。
    MyClass::MyStruct receivedStruct = myObject.getStruct();

    // 输出结构体成员的值
    cout << "Data in MyStruct: " << receivedStruct.data << endl;

    return 0;
}

C++模板(泛型)_第6张图片

2.2.2 例2

我的写法

定义一个堆栈类模板,实现不同数据类型数据的入栈和出栈操作,堆栈的大小用非类型参数指定。

lei_template_test.cpp

#include "iostream"
#include
using namespace std;

typedef bool status;
#define MAXSIZE 10
//定义一个堆栈类模板,实现不同数据类型数据的入栈和出栈操作,堆栈的大小用非类型参数指定。

//定义模板类
template class Stack_ {
public:

	struct Stack {
		T stack[MAXSIZE];
		int top;
	};

	//创建顺序栈
	struct Stack* Stack_Create() {
		struct Stack* p = (struct Stack*)malloc(sizeof(struct Stack));
		if (p == NULL) {
			return NULL;
		}

		//赋初值
		memset(p->stack, 0, sizeof(p->stack));
		p->top = -1;
		return p;

	}

	//入栈
	status Stack_Push(struct Stack* p, T data) {
		//判断栈是否满了
		if (p->top == MAXSIZE - 1) {
			printf("栈已满,入栈失败\n");
			return false;
		}

		p->top += 1;
		p->stack[p->top] = data;
		return true;
	}

	//出栈
	status Stack_Pop(struct Stack* p, T* data) {
		//判断栈是否为空
		if (p->top == -1) {
			printf("栈为空栈,出栈失败!\n");
			return false;
		}

		*data = p->stack[p->top];
		p->stack[p->top] = 0;//清空
		p->top--;
		return true;
	}

	//遍历栈
	status Stack_Travel(struct Stack* p) {
		//判断栈是否为空
		int top_1 = p->top;

		if (top_1 == -1) {
			printf("栈为空栈,遍历失败\n");
			return false;
		}
		while (top_1 >= 0) {
			cout << p->stack[top_1] << " ";
			top_1--;
		}
		return true;

	}

	// 释放堆栈
	void Stack_Destroy(struct Stack* p) {
		delete p;  // 使用 delete 进行动态内存释放
	}


};


int main()
{
	//栈中存入int类型
	//实例化类模板
	Stack_ stack_;
	Stack_::Stack* p = stack_.Stack_Create();//Stack_::Stack是在 C++ 中使用模板类 Stack 时访问内部嵌套结构 StackStruct 的方法。
	//入栈
	stack_.Stack_Push(p, 10);
	stack_.Stack_Push(p, 20);
	stack_.Stack_Push(p, 30);
	stack_.Stack_Push(p, 40);
	stack_.Stack_Push(p, 50);
	//遍历
	stack_.Stack_Travel(p);
	cout << endl;
	//出栈
	int data;
	stack_.Stack_Pop(p, &data);
	cout << "取出栈顶元素为:" << data << endl;
	//遍历
	stack_.Stack_Travel(p);
	//释放堆栈
	stack_.Stack_Destroy(p);


	cout << endl;
	cout << endl;


	//栈中存入char类型
	//实例化类模板
	Stack_ stack_2;
	Stack_::Stack* p2 = stack_2.Stack_Create();//Stack_::Stack是在 C++ 中使用模板类 Stack 时访问内部嵌套结构 StackStruct 的方法。
	//入栈
	stack_2.Stack_Push(p2, 'a');
	stack_2.Stack_Push(p2, 'b');
	stack_2.Stack_Push(p2, 'c');
	stack_2.Stack_Push(p2, 'd');
	stack_2.Stack_Push(p2, 'e');
	//遍历
	stack_2.Stack_Travel(p2);
	cout << endl;
	//出栈
	char data2;
	stack_2.Stack_Pop(p2, &data2);
	cout << "取出栈顶元素为:" << data2 << endl;
	//遍历
	stack_2.Stack_Travel(p2);
	//释放堆栈
	stack_2.Stack_Destroy(p2);

	cout << endl;
	cout << endl;

	//栈中存入double类型
	//实例化类模板
	Stack_ stack_3;
	Stack_::Stack* p3 = stack_3.Stack_Create();//Stack_::Stack是在 C++ 中使用模板类 Stack 时访问内部嵌套结构 StackStruct 的方法。
	//入栈
	stack_3.Stack_Push(p3, 3.14);
	stack_3.Stack_Push(p3, 8.25);
	stack_3.Stack_Push(p3, 1.22);
	stack_3.Stack_Push(p3, 7.45);
	stack_3.Stack_Push(p3, 6.489523);
	//遍历
	stack_3.Stack_Travel(p3);
	cout << endl;
	//出栈
	double data3;
	stack_3.Stack_Pop(p3, &data3);
	cout << "取出栈顶元素为:" << data3 << endl;
	//遍历
	stack_3.Stack_Travel(p3);
	//释放堆栈
	stack_3.Stack_Destroy(p3);

	return 0;
}

C++模板(泛型)_第7张图片

另一种写法

lei_template_test2.cpp

#include "iostream"
using namespace std;

//定义一个堆栈类模板,实现不同数据类型数据的入栈和出栈操作,堆栈的大小用非类型参数指定。
//
templateclass Stack
{
public:
	Stack()
	{
		stack = new T[MAXSIZE]{ 0 };//申请空间
		this->top = -1;
	}
	//判断栈是否为空
	bool isEmpty()
	{
		if (this->top == -1)
		{
			return true;
		}
		return false;
	}
	//判断栈是否为满
	bool isFull()
	{
		if (this->top == MAXSIZE - 1)
		{
			cout << "栈已满!" << endl;
			return true;
		}
		return false;
	}
	//入栈
	bool Push(T data)
	{
		if (this->isFull())
		{
			return false;
		}
		this->top += 1;
		this->stack[this->top] = data;
		return true;
	}
	//出栈
	bool Pop(T& data)
	{
		if (this->isEmpty())
		{
			return false;
		}
		data = this->stack[this->top];
		this->stack[this->top] = 0;
		this->top--;
		return true;
	}
	//返回栈顶元素
	bool get_Top_Data(T& data)
	{
		if (this->isEmpty())
		{
			return false;
		}
		data = this->stack[this->top];
	}
	//打印栈中的数据
	void display()
	{
		for (int i = 0; i < MAXSIZE; i++)
		{
			cout <stack[i] <<" ";
		}
	}
	~Stack()
	{
		delete[]stack;//释放资源
	}
private:
	int top;//指向栈顶指针
	T* stack;
};
int main()
{
	//实例化一个类 int类型的栈
	Stackstack;

	//看看栈是否已满
	bool flag = stack.isFull();
	if (flag) {

	}
	else {//不满添加数据
		stack.Push(10);
		stack.Push(20);
		stack.Push(30);

		stack.display();

	}
	
	//看看栈是否为空
	flag = stack.isEmpty();
	if (flag)
	{
		cout << "栈为空!" << endl;
	}
	else
	{
		cout << endl;
		int data;
		stack.Pop(data);
		cout << "取出栈顶元素为:" << data << endl;
		stack.display();

	}

	cout << endl;
	//实例化一个类,char类型的栈
	Stackstack2;
	//看看栈是否已满
	bool flag2 = stack2.isFull();
	if (flag2) {

	}
	else {//不满添加数据
		stack2.Push('a');
		stack2.Push('b');
		stack2.Push('c');

		stack2.display();

	}

	//看看栈是否为空
	flag2 = stack2.isEmpty();
	if (flag2)
	{
		cout << "栈为空!" << endl;
	}
	else
	{
		cout << endl;
		char data2;
		stack2.Pop(data2);
		cout << "取出栈顶元素为:" << data2 << endl;
		stack2.display();

	}

	return 0;
}

2.2.3 使用通用模板类写一个冒泡排序

bubble_sort.cpp
#include "iostream"
using namespace std;


//使用通用模板类写一个冒泡排序
class People {
public:
	People(char c) {
		str = c;
	}

	// 重载 > 运算符
	bool operator>(const People& other) const {
		return this->str > other.str;
	}

	char str;
};

template class b_sort {
public:
	void bubble_sort(T arr[], int sz) {
		for (int i = 0; i < sz - 1; i++) {
			for (int j = 0; j < sz - i - 1; j++) {

				if (arr[j] > arr[j + 1]) {
					T tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
	}

};


int main()
{
	//实例化一个对象
	//排序整型
	b_sort sort;
	int arr[] = { 8,3,1,5,63,2,7,9};
	int sz = sizeof(arr) / sizeof(arr[0]);
	sort.bubble_sort(arr,sz);
	for (int i = 0; i < sz;i++) {
		cout << arr[i] << " ";
	}

	cout << endl;
	cout << endl;


	//实例化一个对象
	//排序字符型
	b_sort sort2;
	char arr2[] = {'f','r','w','h','b','a'};
	int sz2 = sizeof(arr2) / sizeof(arr2[0]);
	sort2.bubble_sort(arr2, sz2);
	for (int i = 0; i < sz2; i++) {
		cout << arr2[i] << " ";
	}

	cout << endl;
	cout << endl;

	//实例化一个对象
	//排序自定义类型
	b_sort sort3;
	People people1('l');
	People people2('z');
	People people3('l');
	People people4('i');
	People arr3[] = {people1,people2,people3,people4 };
	int sz3 = sizeof(arr3) / sizeof(arr3[0]);
	sort3.bubble_sort(arr3, sz3);
	for (int i = 0; i < sz3; i++) {
		cout << arr3[i].str << " ";
	}

	return 0;
}

C++模板(泛型)_第8张图片

你可能感兴趣的:(C++,c++,算法,c语言,linux)