C++之函数指针、指针函数以及相关问题

目录

1.指针

2.指针变量

3.指针分类

4.指针相关题

5.关于判定本质是否为指针的右左法则

6.函数指针

1.函数名代表函数的入口地址（一个函数）

2.函数名代表函数的入口地址（多个函数)

3.函数指针函数

7.扩展--函数转移表

8.面试题1：1+2+...+n,不用if，循环，公式，不能直接输出结果

9.面试题2：n个1~10的数据，计算1~10出现的次数

1.指针

指针就是一个地址

指针也就是内存地址，指针变量是用来存放内存地址的变量，在同一CPU构架下，不同类型的指针变量所占用的存储单元长度是相同的（一般为4字节），而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作。

2.指针变量

基类型 * 指针变量名

指针变量是指存放地址的变量。因指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址。

eg:

int a = 68;
long *p=NULL;
p=&a;

分析：

系统为变量a分配的首地址为0X065FDF4H

声明空指针long *p = NULL，

p=&a是存放变量a地址的指针变量，

即p=&a中存放的值为0x065FDF4H（a的值为68，&a的值为0x065FDF4H）。

对变量a的访问有两种方式：

1.直接按地址0x065FDF4H找到a的存储单元，从而对变量a进行访问；

2.按系统为p=&a分配的地址先找到p=&a，然后根据p，&a的值（即变量a地0x065FDF4H）找到变量a在内存中的存储单元，从而对变量a进行访问。

总结：

对于前一种访问方式称为直接访问方式，后一种访问方式称为间接访问方式。

如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。在C++程序设计中，指针变量只有确定了指向才有意义。

3.指针分类

单指针 双指针  指针数组  数组指针  指针函数  函数指针 
单指针--变量  一维数组  二维数组 函数
双指针--变量  指针数组
字符指针

4.指针相关题

void main()
{
	char a[] = "123";
	char b[] = "123";
	const char c[] = "123";
	const char d[] = "123";
	const char* p1 = "123";
	const char* p2 = "123";
	const char* const p3 = "123";
	const char* const p4 = "123";
	if (a == b)
		cout << "a==b" << endl;
	if (a == c)
		cout << "a==c" << endl;
	if (c == d)
		cout << "c==d" << endl;
	if (p1 == p2)
		cout << "p1==p2" << endl;
	if (p3 == p4)
		cout << "p3==p4" << endl;
	if (p1 == p3)
		cout << "p1==p3" << endl;
}

​

a、b、c、d都在表的是数组首元素的首地址，因其地址不同，所以前三个不输出

p1、p2、p3、p4代表的都是指向内容为"123" 的字符串（统一字符串只有一个，多个浪费空间），所以他们存储的是字符串"123"的首地址（1的地址）//不能修改

5.关于判定本质是否为指针的右左法则

规则：

首先，我们找到*符号，找到变量：

例如：

int (*p)[4];

1.()的优先级大，所以首先是一个指针，

2.然后以（*p)为中心，先从右边开始看，[4]为数字，即在指针前加一个修饰词数组，即就是数组指针，

3.再以判断过的部分(*p)[4]为中心从左边看是 int，即代表整型数组。

综上：整型数组指针--指向数组的指针

int *q[4] ;

1.q[4],代表一个数组，以q[4]使用右左原则

2.*q[4],在数组前加上修饰词指针，即就是指针数组

3.int代表整形
 综上：整型指针数组--存储指针的数组
 

 int(*p1[5]);

1.首先找到变量p1,p1[5]代表一个数组

2.再以p1[5]为中心进行右左原则，得到*p1[5],即就是指针数组

3.int代表整形

综上：同第二类，因为（）并没有真正印象到优先级 整型指针数组--存储指针的数组

int* (*p2[5])(int);

1.首先找到变量p2,p2[5]代表一个数组

2.再以p2[5]为中心进行右左原则，得到*p2[5],即就是指针数组

3.再以(*p2[5])为中心进行右左原则，得到(*p2[5])(int)即就是返回类型为整型的函数指针数组

4.再以(*p2[5])(int)为中心进行右左原则，得到int* (*p2[5])(int),加上返回类型尾指针的函数
综上： int*（返回值是指针的函数）(*p2[5])(int)（函数）--  指针函数指针数组

 int*p3(int n);

1.首先找到变量p3,p3（int n)代表一个函数

2.再以p3(int n)为中心进行右左原则，得到*p3(int n),即就是指针函数

3.再以*p3(int n)为中心进行右左原则，得到int* *p3(int n)即就是

指针函数--返回值为指针的函数

 int (*p4)(int,int)

1.首先找到变量p4,(*p4)代表一个指针

2.再以（*p4）为中心进行右左原则，得到*p4(int int),即就是函数指针

--函数指针--指向函数的指针

总结：

先找出变量，以变量为中心进行右左原则开始分析，每分析完一个成分，将修饰词加在前面，再将已分析完的部分加入中心部分，依次分析直至结束

6.函数指针

函数指针
* 函数名--代表函数的入口地址
* 1.指针指向函数，由指针调用函数
* 2.函数指针作为另外一个函数的参数
* 3.数指针作为另外一个函数的返回值

1.函数名代表函数的入口地址（一个函数）

int Sum(int a, int b)
{
	return a + b;
}
void main()
{
	int(*p)(int, int);
	p = Sum;
	cout << Sum(4, 7) << endl;
	cout << p(3, 6) << endl;
}

​

    int(*p)(int, int);//返回值为int的，里面有两个int型参数的 函数指针
    p = Sum;//函数名代表函数的入口地址
    cout << Sum(4, 7) << endl;
    cout << p(3, 6) << endl;//p指向Sum函数，两句意思一样

2.函数名代表函数的入口地址（多个函数)

int Sum(int a, int b)
{
	return a + b;
}
int Max(int a, int b)
{
	return a > b ? a : b;
}
int Min(int a, int b)
{
	return a < b ? a : b;
}
void test(int x, int y, int(*p)(int, int))
{
	cout << p(x, y) << endl;
}
void main()
{
	int(*p)(int, int);
	p = Sum;
	test(2, 9, Max);
}

    int(*p)(int, int);//返回值为int的，里面有两个int型参数的 函数指针
    p = Sum;//函数名代表函数的入口地址

3.函数指针函数

函数指针函数 fn是个函数名，函数里面有int n的一个参数，fn函数的返回值是一个指针，这个指针指向一类函数 int xx(int,int)

int Min(int a, int b)
{
	return a < b ? a : b;
}
int(*fn(int n))(int, int)//函数指针函数
{
	cout << "fn n=" << n << endl;
	return Min;
}
void main()
{
	cout << "函数指针作为函数返回值" << endl;
	cout<<fn(100)(3, 20)<
	int(*p)(int, int);
	p = fn(100);
	cout << p(3, 20) << endl;
}

int(*fn(int n))(int, int)//函数指针函数
cout<     p = fn(100);//加上下一句等同于cout<     cout << p(3, 20) << endl;//与上一句一起

 

7.扩展--函数转移表

int Sum(int a, int b)
{
	return a + b;
}
int Max(int a, int b)
{
	return a > b ? a : b;
}
int Min(int a, int b)
{
	return a < b ? a : b;
}
int Sub(int a, int b)
{
	return a - b;
}
int Mul(int a, int b)
{
	return a * b;
}
int Div(int a, int b)
{
	if (b != 0)
		return a / b;
}
int Mod(int a, int b)
{
	return a % b;
}
void main()
{
	int(*p[])(int, int) = { Sum,Max,Min,Sub,Mul ,Div,Mod };
	int x = 20, y = 8;
	int n = sizeof(p) / sizeof(p[0]);
	for (int i = 0; i < n; i++)
	{
		cout << p[i](x, y) << endl;
	}
}

int(*p[])(int, int) = { Sum,Max,Min,Sub,Mul ,Div,Mod };//  函数指针数组

运算结果会将数组中的所有函数的值都依次计算出结果

8.面试题1：1+2+...+n,不用if，循环，公式，不能直接输出结果

int f0(int n)
{
	return 0;
}
int f1(int n)
{
	static int (*pf[2])(int) = { f0,f1 };
	return pf[!!n](n - 1) + n;
}
 
void main()
{
	cout << f1(100) << endl;
}

1.进入f1函数，返回pf( 非非100)，即就是pf1(99)+100

2.再进入f1函数，返回pf( 非非99)，即就是pf1(98)+99

.

.

.

n.再进入f1函数，返回pf( 非非1)，即就是pf(0)+1

n+1.再进入f0函数，返回0

类似于递归函数，依次减一，0为出口

9.面试题2：n个1~10的数据，计算1~10出现的次数

void main()
{
	int num[] = {10,1,4,7,4,7,9,5,2,3,4,6,10,5,8,10 };
	int n = sizeof(num) / sizeof(num[0]);
	int count[11] = { 0 };
	int i;
	for (i = 0; i < n; i++)
	{
		count[num[i]]++;
	}
	for (i = 1; i <= 10; i++)
		cout << i << "：" << count[i] << endl;
}

        count[num[i]]++;等于下面两句
        /*if (num[i] == 1)
            count[1]++;*/

类似于桶排序，将所有数据放入0-10，这11个桶中，每次存放一个数据，该桶的计数器+1