【C进阶】指针(一)

大家好,我是深鱼~

【前言】:

指针的主题,在初阶指针章节已经接触过了,我们知道了指针的概念:

1.指针就是个变量,用来存放地址,地址的唯一标识一块内存空间(指针变量),内存单元是由编号的,编号==地址==指针

2.指针/地址/指针变量的大小是固定的4/8个字节(32位平台/64位平台)

3.指针是有类型的,指针的类型决定了指针的+-整数的步长,指针解引用操作的时候的权限

4.指针的运算 


【目录】

一、字符指针

 二、指针数组

  三、数组指针

3.1数组指针的定义

3.2&数组名vs数组名 

3.3数组指针的使用

四、数组参数,指针参数

4.1一维数组传参

4.2二维数组传参

 4.3一级指针传参

4.4二级指针传参

五、函数指针


一、字符指针

一般使用:

#include<stdio.h>
int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'w';
	return 0;
}

还有一种使用方式如下:

#include<stdio.h>
int main()
{
	char ch = 'w';
	char* p = "abcdef";
		   //[abcdef]
		  //char arr[]="abcdef"
    printf("%sn,p);//打印的是整个字符串
    printf("%cn,*p);//打印的是a
	printf("%cn", "abcdef"[3]);//打印的是d
	return 0;
}

这里的字符串"abcdef“类似于数组,把这个字符串赋给p指针,也就是字符串的首地址赋给p指针

(假设是 32位平台,指针的大小也就是4个字节,但是这个字符串却有7个字节(算上),这样看是放不下的)

但是这个代码存在问题,p变量赋给了常量字符串,如果改变p变量,常量字符串是不会更改的

eg:这样代码很容易出错误,所以一般会在char *p之前写上const

char* p = "abcdef";
 *p = 'e';

更加安全的写法:

const char* p = "abcdef";

 下面再来看一道【经典面试题】

这道题的输出结果是啥?

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

【答案】:

str1 and str2 are not same
str3 and str4 are same

【解释】:

(1)首先创建两个数组,分别放入hello bit,因为是两个不同的数组,那么字符串就存在不同的位置,当判断str1和str2,也就是两个数组的首地址的时候,这两个h地址肯定不相同

(2)str3和str4指针都指向常量字符串,因为常量字符串不可修改,那么其实也没有必要再创建一个空间来存两个相同的常量字符串,如果两个指针同时指向这个常量字符串的时候,其实指向的也就是同一个地址,那么str3和str4也就相同


【拓展】:再加一个

if(&str3==&str4)

         printf("YESn");

else

         printf("NOn");

【答案】:NO

【图解】:指针变量不同,地址不同

p(指针变量):表示指针变量指向的内存地址

&p:取指针p的地址,表示编译器为变量p分配的内存地址(不同变量分配的地址不同),而不是这个指针p指向的地址


 二、指针数组

指针数组是数组

字符数组-存放字符的数组

整形数组-存放整形的数组

指针数组-存放指针的数组,存放在数组的元素都是指针类型的

eg: int *arr[5];  //存放整形指针的数组

        char * ch[6]; //存放字符指针的数组

【那指针数组一般怎么用呢?】

一般不会像这样使用:int *arr[3]={&a,&b,&c}

而是这样使用:可以用指针数组模拟一个二维数组

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	            //int*   int* int*
	//指针数组
	int* arr[] = { arr1,arr2,arr3 };
    for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("n");
	}
	return 0;
}

【图解】:指针数组放入三个数组,这三个数组的类型是int *指针类型,通过指针数组的打印可以模拟二维数组

【程序结果】: 


  再举个栗子:建立一个字符类型(int *)指针数组,并打印数组内的元素

#include<stdio.h>
int main()
{
	char* arr[5] = { "hello bit","hehe","penggeC","bitejiuyeke","C++" };
	for (int i = 0; i < 5; i++)
	{
		printf("%sn", arr[i]);
	}
	return 0;
}

【图解】:分别把字符串的首元素地址传给了指针,然后把这些指针放在数组中

【程序结果】:


  三、数组指针

3.1数组指针的定义

数组指针是指针,类型于字符指针(指向字符的指针),整形指针(指向整形的指针),浮点型指针(指向浮点型的指针),那么数组指针就是指向数组的指针

int a=10;  int *p=&a;(整形指针)

char ch='a'; char *pc=&ch;(字符指针)

int arr[10];  int (*p)[10]=&arr;(数组指针)

下面我们来理解一下int(*p)[10]:

int (*p) [10]中的*表示p是一个指针,*p指向[10]表示指向数组的指针,int代表数组元素类型

【注意】:

不能直接定义一个指针p,然后把&arr赋给p,&arr是整个数组的地址,&arr的类型是int (*)【10】,而指针p的类型是int *,不对等,所以&arr应该放在数组指针中 

3.2&数组名vs数组名 

首先数组名的理解:

数组名是首元素的地址但是存在两个例外:

1.sizeof(数组名),这里的数组名表示整个数组,计算的是整个数组的大小,单位是字节

2.&数组名,这里的数组名表示整个数组,取出来的是数组的地址

int main()
{
	int arr[10];

	printf("%pn", arr);//int *
	printf("%pn", arr+1);

	printf("%pn", &arr[0]);//int *
	printf("%pn", &arr[0]+1);

	printf("%pn", &arr);//int *[10]这就是数组指针的类型
	printf("%pn", &arr+1);
	//指针类型决定了指针+1到底+几个字节
	return 0

【注意】:这里的10不可省略,数组指针要明确指针指向的数组是几个元素

 【练习】:

char* arr2[5]的数组指针:char* (*p)[5](前面的char*是数组类型)

int arr3[]={1,2,3}的数组指针:int (*p)[3]   (数组指针要明确指向数组的大小,这个3必须写)

3.3数组指针的使用

先来看看用数组指针打印数组元素:这其实是多此一举的,本来可以直接arr打印数组元素,但是还要定义一个数组指针,再用数组指针来打印数组元素

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

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", (*p)[i]);
	}

	return 0;
}

 【那如果把打印的内容换成p[i],结果又如何呢?】

p[i]等价于*(p+i),而指针+1,直接就跳过一个数组地址,根本不可能打印出数组的元素

直接把数组名传给p指针,这样才能访问数组的元素:int *p=arr 

代码运行结果:


  【那么数组指针到底有什么用呢?】

数组指针用都是用在二维数组上,我们来看一个例子:打印一个二维数组


正常的方法:形参使用二维数组的形式

#include<stdio.h>
void print(int arr[3][5], int row, int col)
{
	for (int i = 0; i < 3;i++)
	{
		for (int j = 0; j < 5; j++)
		{
			printf("%d ", arr[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} };
	print(arr, 3, 5);
	return 0;
}

 数组指针的方法:形参使用数组指针的形式

(1)首先数组名是首元素的地址,在二维数组中,首元素的地址就是第一行数组元素的地址

(2)形参int (*p)[5]代表:这个数组指针指向的是数组第一行5个元素的地址

(3)p[i][j]代表:p[i]就相当于*(p+i),每行的地址,解引用后就是每行的数组名,每行的数组名[j],就可以得到每行的数组元素

#include<stdio.h>
void print(int (*p)[5], int row, int col)
{
	for (int i = 0; i < 3;i++)
	{
		for (int j = 0; j < 5; 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} };
	print(arr, 3, 5);
	return 0;
}

学了指针数组和数组指针我们来一起回顾并看看下面代码的意思: 

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];

<1>arr是一个能够存放5个整形数据的数组

<2>parr1是一个数组,数组10个元素,,每个元素的类型都是int *

<3>parr2是一个指针,该指针是指向数组的,指向的数组有10个元素,每个元素的类型都是int

<4>parr3是一个数组,是存放数组指针的数组(这个parr3【10】数组10个元素),存放数组指针(int (*    ) [5],指向的数组有5个元素,每个元素是int类型(这个比较难,不理解也没事)

对于4画图理解:parr3是10个元素的数组,每个元素中都是地址(数组指针),每个元素的类型都是int(* )[5],而对应数组中存放的数组指针,这个指针指向5个元素的数组


四、数组参数,指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数,那函数的参数应该如何设计呢?

4.1一维数组传参

数组传参,形参是可以写成数组的形式的,也可以是指针,传参的本质是传递了数组首元素的地址

以下6种方式传参都是可以的

#include <stdio.h>
void test(int arr[])//ok,数组的形式传参,可以省略数组的元素个数
{}
void test(int arr[10])//ok,直接把数组拿过来,数组的形式传参
{}
void test(int* arr)//ok,指针的形式传参
{}
void test2(int* arr[20])//ok,直接把指针数组拿过来,数组的形式传参
{}
void test2(int* arr[])//ok,数组的形式传参,可以省略数组的元素个数
{}
void test2(int** arr)//ok,指针的形式传参
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };//指针数组
	test(arr);
	test2(arr2);
}

对于最后一种的理解:arr2每个元素的类型都是int *,arr2也就是取int *元素的首地址,一个指针的地址,那么就放到二级指针里面去


4.2二维数组传参

void test(int arr[3][5])//ok
{}
void test(int arr[][])//no,二维数组只能省略行,不可省略列
{}
void test(int arr[][5])//ok
{}
void test(int* arr)//no,二维数组首元素地址是第一行的地址,所以指针传参不能省略列
{}
void test(int* arr[5])//no,这是一个指针数组,而不是本来的二维数组
{}
void test(int(*arr)[5])//ok,数组指针,指针指向数组,数组中有5个元素
{}
void test(int** arr)//no,二级指针是用来接收一级指针的地址,而我们只需要第一行数组的地址,一级指针即可
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

二维数组传参:

<1>数组形式传参:只能省略行,不可省略列

<2>指针形式传参:参数形式应该是数组指针int  (*arr)【列】,而不能是指针数组

 4.3一级指针传参

#include <stdio.h>
void print(int *p, int sz)
{
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%dn", *(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;
}

一级指针传参形式参数写成一级指针就可以


【思考】:

当一个函数的参数部分为一级指针的时候,函数能接收什么参数?

(1)传一维数组的数组名

(2)传变量的地址

(3)传指针

4.4二级指针传参

#include <stdio.h>
void test(int** ptr)
{
 printf("num = %dn", **ptr); 
}
int main()
{
 int n = 10;
 int*p = &n;
 int **pp = &p;
 test(pp);
 test(&p);
 return 0;
}

二级指针传参形式参数写成二级指针或者一级指针的地址都可以

【思考】:

当函数的参数为二级指针的时候,可以接收什么参数?

(1)一级指针的地址

(2)二级指针

(3)传指针数组(首元素的地址)

五、函数指针

类比:

数组指针-指向数组的指针-存放的是数组的地址-&数组名就是数组的地址

函数指针-指向函数的指针-存放的是函数的地址-那么怎么得到函数的地址呢

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	//&函数名就是函数的地址
	//函数名也是函数的地址

	printf("%pn", &Add);
	printf("%pn", Add);

	int (*pf1)(int, int) = Add;//pf1就是函数指针变量
	int (*pf2)(int, int) = &Add;

	return 0;
}

&函数名就是函数的地址,函数名也是函数的地址

int (*pf1)(int, int) = Add这里的括号不可省略,不然前面的部分就跟函数声明一样 

利用函数指针进行Add加和:

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pf2)(int, int) = &Add;
  //int (*pf2)(int, int) = Add;这样写也可以
	int ret = (*pf2)(2, 3);
  //int ret = pf2(2, 3);不用*也可以,但是用了*一定得加括号
  //int ret = *pf2(2, 3);这个就相当于*5
	printf("%dn", ret);

	return 0;
}

  阅读两段有趣的代码:

(* ( void ( * )(  ) ) 0 )( ) ;

(1)void(*)()是函数指针类型

(2)(类型)常量-强制类型转换-eg:int a=(int )3.14 

(3)有颜色的就是将0强制类型转换为函数指针类型,这个0就变成了地址(地址),然后调用0地址处的函数,这个函数没有参数,返回值是void


void ( *  signal (  int , void(*)(int)  )  )(  int  );

 这个代码是函数声明,声明的是signal函数,signal函数的参数有2个

一个是int 类型

一个是函数指针类型,该类型是void(*)(int)

           该函数指针指向的函数,参数是int,返回类型是void

signal函数的返回类型也是函数指针类型,该类型是void(*)(int)

           该函数指针指向的函数,参数是int,返回类型是void

【将这个代码简化】

typedef void(*pfun_t)( int );//也就是将void(*)(int)改给名字叫pfun_t

pfun_t signal(int ,pfun_t);


本次内容就到此啦,欢迎评论区或者私信交流,觉得笔者写的还可以,或者自己有些许收获的,麻烦铁汁们动动小手,给俺来个一键三连,万分感谢 !