c++ 模板

冒泡排序

#include<stdio.h>

void Sort(int* arr,int len)
{
	for(int i=0;i<len-1;i++)
	{
		for(int j=0;j<len-1-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				int tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
			}
		}
	}
}
void Print(int* arr,int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	int arr[]={1,9,418,23,64};
	int len=sizeof(arr)/sizeof(arr[1]);
	Sort(arr,len);
	Print(arr,len);
	return 0;
}

折半查找

#include<stdio.h>

int Found(int* arr,int len,int num)
{
	int left,right,mid;
	left=0;
	right=len-1;
	mid=(left+right)/2;
	while(left<right)
	{
		if(arr[mid]>num)
		{
			right=mid-1;
			mid=(left+right)/2;
		}
		else if(arr[mid]<num)
		{
			left=mid+1;
			mid=(left+right)/2;
		}
		else
			return mid;
	}
}


int main()
{
	int arr[]={1,9,23,64,89};
	int len=sizeof(arr)/sizeof(arr[1]);
	printf("下标是：%d\n",Found(arr,len,89)+1);

	return 0;
}

1.模板

在前面的排序和查找代码中，我们的功能函数都是指定接收某一种类型来进行，如果我们需要创建一个可以接受任意数据类型的功能函数呢，应该怎么做？

在c++中我们可以通过模板的方式进行，通过模板，编译器可以帮我们枚举所有的类型。

如下：

在函数上端添加template<class A>,可在函数，结构体/类中使用

通过查看有无模板俩两者之间的反汇编代码，我们发现两者没有任何区别，在汇编中我们找不到模板的影子，因此我们可以得出总结：

继承是将父类的数据进行复制

模板是将代码进行复制，在编译时会编译器会根据我们传参的类型进行代码的复制

2.作业

1.使用模板实现swap(x,y)函数，功能：交换x，y的值

#include<stdio.h>
template <class A>
void Swap(A* x,A* y)
{
	int tmp=*x;
	*x=*y;
	*y=tmp;
}
int main()
{
	int x=22;
	int y=77;
	printf("x=%d  y=%d\n",x,y);
	Swap(&x,&y);
	printf("x=%d  y=%d\n",x,y);
	return 0;
}

2.实现冒泡排序结构体

#include<stdio.h>
struct Base
{
	int x;
	int y;
};
template <class A>
void Sort(A* arr,int len)
{
	for(int i=0;i<len-1;i++)
	{
		for(int j=0;j<len-1-i;j++)
		{
			if(arr[j]->x>arr[j+1]->x)
			{
				A tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
			}
		}
	}
}
void Print(int* arr,int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	Base a,b,c;
	a.x=3;
	b.x=2;
	c.x=1;
	Base* arr[3]={&a,&b,&c};
	Print((int*)arr,3);
	printf("\n");
	Sort(arr,3);
	Print((int*)arr,3);
	return 0;
}

我们发现，在普通数据类型进行比较时，比如int，char，short类型进行比较时，可以直接进行比较，但是在类或者结构体进行比较时，我们需要对类或者结构体的成员变量进行调用，因此在比较时不可以将其划分为template <class T>这种操作