函数指针、指针函数；数组做参数；函数模板、模板函数；模板类、类模板

函数指针 = 本质是指针，指向函数的地址
指针函数 = 本质是函数，函数返回值是指针

**

函数指针：

**

int add(int a,int b)
{
	return a+b;
}

int main()
{
	int (*p)(int,int);
	p = add;	//p = &add;  两种写法均可以
	cout<<p(1,2)<<endl;

	system("pause");
	return 0;
}

int (*p)(int,int); p指针指向的 函数返回值是int, 参数为两个int类型；

**

指针函数

**

int sum = 0;
int * add(int a,int b)
{
	sum = a+b;
	return ∑
}

int main()
{
	int * p;
	p = add(1,2);		//返回一个int类型指针

	cout<<*p<<endl;
	system("pause");
	return 0;
}

int * add(int a,int b)； 返回值为int类型的指针

指针数组 = 本质是数组，数组里面存放的是指针
数组指针 = 本质是指针，指向这组数组的首地址

**

指针数组

**

int *p1[5]；	

里面存放5个类型为 int* 的指针。

	int arr[5] = {1,2,3,4,5};

	cout<< arr <<" "<<arr+1 <<" "<<*(arr+1)<<endl;
	cout<< &arr <<" "<<&arr+1<<" "<<*(&arr+1)<<endl;

arr = 首元素的地址 arr+1 = 加4个字节 指向下一个元素的地址
&arr = 数组的首地址 &arr+1 = 加20个字节长度，加了整个数组的长度

一维数组做参数

void fun1(int * p,int n)
{
	for (int i = 0; i < n; i++)
	{
		cout<<p[i]<<endl;
	}
}

void fun2(int p[],int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << p[i]<<endl;
	}
}

int main()
{
	int arr[5] = {2,3,4,5,6};

	int * p = arr;
	cout <<p[0]<<p[1]<<endl; //帮助记忆 2,3 

	fun1(arr,5);  
	fun2(arr,5);
	
	system("pause");
	return 0;
}

**

数组指针

**

int (*p2)[5]；

p2 指向一个数组，这个数组里面有5个int类型

int main()
{
	int arr[3][4]={ {0,1,2,3},
					{4,5,6,7},
					{8,9,10,11}}; 

	cout << arr <<" "<<&arr[0]<<endl;	   //数组 首行地址
	cout << arr+1 <<" "<<&arr[0]+1<<endl;  //数组 第二行的首地址 +1 = 加16个字节

	cout<<**arr <<" "<<**(&arr[0])<<endl;		//0 数组首元素，先解引用为首列地址，再解引用为此列首元素地址
	cout<<**(arr+1)<<" "<<**(&arr[0]+1)<<endl;	//4 第二行首元素的地址

	cout << *(*arr+2)<<endl;			//2
	cout <<	*(*(arr+2)+1)<<endl;		//9
	
	system("pause");
	return 0;
}

二维数组做参数

void fun(int * arr,int m,int n)
{
	int i , j ;
	for (int i = 0;i<m;i++)
	{
		for (int j = 0;j<n;j++)
		{
			cout << *(arr+i*n + j);	  //i*n = 第几行  +j = 第几列   
		}
	}
}

int main()
{
	int arr[3][4]={ {0,1,2,3},
					{4,5,6,7},
					{8,9,10,11}}; 

	fun(*arr,3,4);		//*arr  将二维数组看成一维，传入一维数组首地址
	return 0;
}

函数模板

template<typename T , typename T1>
T fun(T &a,T1 &b)
{
	return (T)(a+b);
}

模板函数

函数模板 经过实例化后形成 模板函数；
函数模板 一类函数。
模板函数 具体的函数

int fun(int &a,double &b)
{
	return (int)(a+b);
}

在这里插入代码片

类模板

template<class A,class B>
class MyClass
{
public:
	MyClass(A x,B y)
	{
		m_x = x;
		m_y = y;
	}

	void show();	
private:
	A m_x;
	B m_y;
};

template<class A,class B>
class MyClass
{
public:
	MyClass(A x,B y)
	{
		m_x = x;
		m_y = y;
	}

	void show();
private:
	A m_x;
	B m_y;
};

在类外定义类模板的成员函数
template<class A,class B>	//在每一个类模板定义之前，都需要在前面加上模板声明
void MyClass<A,B>::show()
{
	cout << m_x <<" "<< m_y<<endl;
}

int main()
{
	MyClass<int,double>m1(1,2.1);
	MyClass<int,char*> m2(10,"Temp");
	m1.show();
	m2.show();
	return 0;
}

模板类

模板类是类模板实例化后的一个产物（指具体的参数类型，同模板函数一样）