最近在学习 C++，所以顺便将每日所学记录下来，一方面为了巩固学习的知识，另一方面也为同样在学习C++的童鞋们提供一份参考。

函数指针

函数指针基础

函数三要素：名称、参数、返回值

C语言中的函数有自己特定的类型

//C语言中通过typedef为函数类型重命名
typedef type name(parameter list)
typedef int f(int, int);
typedef void p(int);

函数指针应用

函数指针用于指向一个函数

函数名是执行函数体的入口地址

1)可通过函数类型定义函数指针: FuncType* pointer;
2)也可以直接定义：type (*pointer)(parameter list);

pointer为函数指针变量名

type为指向函数的返回值类型

parameter list为指向函数的参数类型列表

函数指针做函数参数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>



int add(int a, int b)
{
	int c;
	c = a + b;
	printf("c = %d\n", c);
	return c;
}

int MyOP(int (*myAdd)(int ,int ));

void main01()
{
	int(*pAdd)(int, int);
	pAdd = add;
	MyOP(pAdd);				//调用MyOP传递一个函数指针类型的变量
	system("pause");
}


int MyOP(int(*myAdd)(int, int))
{
	add(10, 20);
	myAdd(1, 2);
	return 0;
}


typedef int(*pFunc)(int, int);
int MyOP02(pFunc p)
{
	add(10, 20);
	p(3, 2);
	return 0;
}


void main()
{
	int(*pAdd)(int, int);
	pAdd = add;
	MyOP02(pAdd);
	system("pause");
}

模板

泛型编程基础

模板是创建泛型类或函数的蓝图或公式。库容器：比如迭代器，都是泛型编程的例子，他们都使用类模板的概念, 每个容器都有一个单一的定义，比如向量，我们可以定义许多不同类型的向量，比如vector 或 vector 。

模板是一种对类型进行参数化的工具，通常有两种形式：函数模板和类模板；

(1) 函数模板针对仅参数类型不同的函数；
(2) 类模板针对仅数据成员和成员函数类型不同的类。



#include <iostream>
using namespace std;

//template告诉编译器，现在需要泛型编程
//typename表示一个类型
/*
template<typename T>
void MySwap(T &a， T &b)
{
	T t = a;
	a = b;
	b = t;
}
//业务关系一样， 处理数据类型不同
void myswap(int &a, int &b)
{
	int c = a;
	a = b;
	b = c;
}

void myswap01(char &a, char &b)
{
	char c = a;
	a = b;
	b = c;
}

void main01()
{
	int a1 = 1;
	int b1 = 2;
	myswap(a1, b1);
	char a2 = 'A';
	char b2 = 'B';
	myswap01(a2, b2);
	printf("a1 = %d b1 = %d\n", a1, b1);
	printf("a2 = %c b2 = %c\n", a2, b2);
	system("pause");
}
*/
template<typename T>
void myswap3(T &a, T &b)
{
	T t = a;
	a = b;
	b = t;
}
void main()
{
	//泛型编程函数的使用方法有2种
	int x = 1;
	int y = 2;
	//自动类型推导，，
	myswap3(x, y);
	printf("x = %d y = %d\n", x, y);
	//具体类型调用
	char a = 'A';
	char b = 'B';
	myswap3<char>(a, b);
	printf("a = %c b = %c\n", a, b);
	system("pause");
}

函数模板增强



#include <iostream>
using namespace std;

/*
int Print(int *p, int num)
{
	for (int i = 0; i < num; i++)
	{
		printf("i = %d\n", p[i]);
	}
	return 0;
}
*/
template<typename T>
int Print(T *p, int num)
{
	for (int i = 0; i < num; i++)
	{
		cout << p[i] << endl;
	}
	return 0;
}
template<typename T>
int SortArray(T *p, int num)
{
	int temp;
	for (size_t i = 0; i < num; i++)
	{
		for (size_t j = i + 1; j < num; j++)
		{
			if (p[i] > p[j])
			{
				temp = p[i];
				p[i] = p[j];
				p[j] = temp;
			}
		}

	}
	return 0;
}


template<typename T1,typename T2>
int SortArray02(T1 *p, T2 num)
{
	T1 temp;
	for (size_t i = 0; i < num; i++)
	{
		for (size_t j = i + 1; j < num; j++)
		{
			if (p[i] > p[j])
			{
				temp = p[i];
				p[i] = p[j];
				p[j] = temp;
			}
		}

	}
	return 0;
}


void main()
{
	/*
	int a[10] = { 213, 4, 21, 4556, 13, 215, 61, 231,23,100 };
	
	int num = sizeof(a) / sizeof(int);
	SortArray<int>(a, num);
	Print<int>(a, num);
	*/
	int num = 10;
	char b[] = "sdasghadghadhdasdfasdasdasd";
	int num1 = strlen(b) - 1;
	SortArray02<char, int>(b, num);
	Print<char>(b, num);
	//Print<char>(b, num);
	system("pause");
}

函数模板遇上函数重载

#include <iostream>
using namespace std;

template <typename T>
T max(T a, T b)
{
	return a > b ? a : b;
}

void func1(int i, char c)
{
	max(i, i);
	max(c, c);
	//max(i, c);			//error
	//max(c, i);			//error 	3	IntelliSense:  没有与参数列表匹配的 函数模板 "max" 实例

}


//这样写可以调用
template <typename T1, typename T2>
T1 max(T1 a, T2 b)
{
	return a > b ? a : b;
}

void func(int i, char c)
{
	int q;
	max(i, i);
	max(c, c);
	q = max<int ,char>(i, c);			
	printf("q = %d\n", q);
	c = max<char,int >(c, i);			

}

void main()
{
	func(10, 'c');
	system("pause");
}

函数重载

#include <iostream>
using namespace std;

template <typename T>
int mySwap(T &a, T &b)
{
	T c ;
	c = a;
	a = b;
	b = c;
	return 0;
}

void mySwap(int &a, char &b)
{
	;
}
//模板不能提供隐式的类型转换

void main()
{
	int c = 20;
	int a = 10;
	char b = 'b';
	mySwap(c, b);
	system("pause");
}

重载函数模板

寻找和使用最符合函数名和参数类型的函数，若找到则调用；

sYstemk1t's blog

C++ - 函数指针