C语言指针的进阶,数组指针,函数指针

本章重点

  1. 字符指针
  2. 数组指针
  3. 指针数组
  4. 数组传参和指针传参
  5. 函数指针
  6. 函数指针数组
  7. 指向函数指针数组的指针
  8. 回调函数
  9. 指针和数组面试题的解析

指针
我们知道了指针的概念:

  1. 指针就是个变量,用来存放地址,地址唯一标识一块内存空间。
  2. 指针的大小是固定的4/8个字节(32位平台/64位平台)。
  3. 指针是有类型,指针的类型决定了指针的±整数的步长,指针解引用操作的时候的权限。
  4. 指针的运算。

1. 字符指针

#include<stdio.h>
int main()
{
    
    
	char ch = 'w';
	char* pc = &ch;//指针变量pc
	printf("%c\n", ch);
	*pc = 'd';
	printf("%c\n", ch);
	return 0;
}

在这里插入图片描述

int main()
{
    
    
	char* pstr = "hello bit.";//这里是把一个字符串首地址放到pstr指针变量里
	printf("%s\n", pstr);
	return 0;
}

在这里插入图片描述
把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

题目:

#include <stdio.h>
int main()
{
    
    
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    char *str3 = "hello bit.";
    char *str4 = "hello bit.";
    if(str1 ==str2)
 printf("str1 and str2 are same\n");
    else
 printf("str1 and str2 are not same\n");
       
    if(str3 ==str4)
 printf("str3 and str4 are same\n");
    else
 printf("str3 and str4 are not same\n");
       
    return 0; }

在这里插入图片描述
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域,
当几个指针。指向同一个字符串的时候,他们实际会指向同一块内存。但是用相同的常量字符串去初始
化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同,str3和str4不同。

2.指针数组

定义:存放指针的数组。

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

3.数组指针

在这里插入图片描述

3.1数组指针的定义

定义:指向数组的指针。

int (*p)[10];
//解释:p先和*结合,说明p是一个指针变量,然后指着指向的是一个大小为10个整型的数组。所以p是一个指针,指向一个数组,叫数组指针。

3.2数组名,&数组名

我们知道arr是数组名,数组名表示数组首元素的地址。
那&arr数组名到底是啥?

#include <stdio.h>
int main()
{
    
    
    int arr[10] = {
    
    0};
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}

在这里插入图片描述

虽然结果地址一样,但是表示的意思根本不相同。
数组名大多数情况下表示首元素的地址,sizeof(数组名)中数组名表示整个数组,以字节为单位
而&arr表示整个数组的地址,这里的数组名也是整个数组。下面证明一下:

#include <stdio.h>
int main()
{
    
    
	int arr[10] = {
    
     0 };
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", &arr);
	printf("==========\n");
	printf("arr+1 = %p\n", arr + 1);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

在这里插入图片描述
&arr 表示的是数组的地址,而不是数组首元素的地址。数组的地址+1,跳过整个数组的大小,所以 &arr+1 相对于 &arr 的差值是40.

3.3 数组指针的使用

#include <stdio.h>
int main()
{
    
    
	int arr[10] = {
    
     0 };
	int* p = arr;//一维数组的地址存在指针p中
	int(*parr)[10] = &arr;//数组的地址,存放在数组指针中
	//int(*parr)[10]  它的类型就是int(*)[10]
	return 0;
}

例子,打印数组:

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
    
    
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
    
    
        for (j = 0; j < col; j++)
        {
    
    
            //printf("%d ", arr[i][j]);
            printf("%d ", *(arr[i] + j));
        }
        printf("\n");
    }
}

void print_arr2(int(*arr)[5], int row, int col)
{
    
    
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
    
    
        for (j = 0; j < col; j++)
        {
    
    
            //printf("%d ", arr[i][j]);
            printf("%d ", *(arr[i] + j));

        }
        printf("\n");
    }
}
int main()
{
    
    
    int arr[3][5] = {
    
     1,2,3,4,5,6,7,8,9,10 };
    print_arr1(arr, 3, 5);
    //数组名arr,表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr,其实相当于第一行的地址,是一维数组的地址
    //可以数组指针来接收
    printf("\n");
    print_arr2(arr, 3, 5);
    return 0;
}

在这里插入图片描述

4. 数组参数、指针参数

4.1 一维数组传参

#include <stdio.h>
void test(int arr[])
{
    
    
	printf("8888\n");
}

void test2(int* arr[20])
{
    
    
	printf("---\n");
}
int main()
{
    
    
	int arr[10] = {
    
     0 };
	int* arr2[20] = {
    
     0 };
	test(arr);
	test2(arr2);
	return 0;
}

在这里插入图片描述

4.2 二维数组传参

#include<stdio.h>
printf2(int(*p)[5], int r, int c)
{
    
    
	int i = 0;
	for (i = 0; i < r; i++)
	{
    
    
		int j = 0;
		for (j = 0; j < c; j++)
		{
    
    
			//printf("%d ", *(*(p + i) + j));
			printf("%d ", p[i][j]);
		}
		printf("\n");
	}
}
int main()
{
    
    
	int arr[3][5] = {
    
     1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	//二维数组传参
	//printf1(arr, 3, 5);
	printf2(arr, 3, 5);//arr是猪组名,数组名是数组首元素地址,二维数组相当于第一行
	return 0;
}

在这里插入图片描述

总结:二维数组传参,函数形参的设计只能省略第一个[]的数字。因为对一个二维数组,可以不知道有多少行,但是必须知道一行多少元素

4.3 一级指针传参

#include <stdio.h>
void print(int* p, int sz)
{
    
    
	int i = 0;
	for (i = 0; i < sz; i++)
	{
    
    
		printf("%d ", *(p + i));
	}
}
int main()
{
    
    
	int arr[10] = {
    
     1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p,传给函数
	print(p, sz);
	return 0;
}

在这里插入图片描述

4.4 二级指针传参

#include<stdio.h>
void test(int** ppa)
{
    
    

}

int main()
{
    
    
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;

	int* arr[5];

	test(ppa);
	test(&pa);
	test(arr);
	return 0;
}

5. 函数指针

函数指针变量,存放函数的地址。

#include<stdio.h>
int Add(int x, int y)
{
    
    
	return x + y;
}
int main()
{
    
    
	printf("%p\n", &Add);
	printf("%p\n", Add);//这两个完全一样
	return 0;
}

在这里插入图片描述

#include<stdio.h>
int Add(int x, int y)
{
    
    
	return x + y;
}
int main()
{
    
    
	//printf("%p\n", &Add);
	//printf("%p\n", Add);//这两个完全一样
	
	int a = 90;//类型int
	int arr[10] = {
    
     0 };//类型int[10]
	int(*parr)[10] = &arr;//parr就是数组指针变量

	//int (*pf)(int, int) = &Add;//pf是用来存放函数的地址,pf就是函数指针变量,类型就是int(*)(int,int)
	//指针*pf
	//指向函数()
	//参数类型int,int
	//返回类型int

	int (*pf)(int, int) = Add;//跟上面一样
	int ret = Add(2, 3);
	printf("%d\n", ret);

	//ret = (*pf)(4, 5);
	ret = pf(4, 5);//*号个数无影响向,可以省略
	printf("%d\n", ret);
	return 0;
}

在这里插入图片描述

有趣的代码:

#include<stdio.h>
int main()
{
    
    
	//这个代码是函数调用
	//解析:1.代码中把0强制转化为类型为void(*)()的一个函数的地址
	//2.解引用0地址就是去调用0地址处的这个函数,被调用的函数是无参,返回类型就是void
	(*(void(*)())0)();
	return 0;
}
#include<stdio.h>
int main()
{
    
    
	//函数声明
	//函数名signal
	//函数参数,第一个是int,第二个是void(*)(int)的函数指针类型
	//signal函数的返回类型是void (*)(int)函数指针类型
	void (*signal(int, void(*)(int)))(int);
	return 0;
}

注意:
如果定义typedef void(*pfun_t)(int);
那么void (*signal(int, void(*)(int)))(int);等价于:pfun_t signal(int, pfun_t);

6. 函数指针数组

#include<stdio.h>
int Add(int x, int y)
{
    
    
	return x + y;
}

int Sub(int x, int y)
{
    
    
	return x - y;
}

int Mul(int x, int y)
{
    
    
	return x * y;
}

int Div(int x, int y)
{
    
    
	return x / y;
}
int main()
{
    
    
	int* arr[10];//整型指针数组
	//函数指针数组  --存放函数指针的数组

	int (*pf1)(int, int) = Add;
	int (*pf2)(int, int) = Sub;
	int (*pf3)(int, int) = Mul;
	int (*pf4)(int, int) = Div;


	//pfArr就是函数指针的数组
	int (*pfArr[4])(int, int) = {
    
     Add,Sub,Mul,Div };

	return 0;
}

应用:实现计算器:

猜你喜欢

转载自blog.csdn.net/qq_44721738/article/details/121168382

相关文章