C语言——指针进阶

前言

我在指针初阶的时候讲过了：

1.指针就是个变量，是用来存放地址的，地址唯一标识一块内存空间。

2.指针的大小分为4个或8个，在32位平台指针大小是4个字节，在64位平台指针大小是8个字节。

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

4.指针的运算。

这次我们来讲解指针的进阶。

(一)字符指针

我们都知道字符是char 那字符指针就是char*
#include<stdio.h>
int main()
{
	char ch = "abcdef";
	char* pc = &ch; 字符指针
	char* p = "abcdef"; p指向的是首元素a的地址 abcdef是常量字符串不能被修改
	*p = 'w'; 不能修改会报错  因为是常量字符串
    return 0;
}


#include<stdio.h>
int main()
{
	char arr[]="abcdfe";
	char* p = arr;  p指向的是数组首元素a的地址，abcdfe可以被修改，因为p指向的是数组
	*p = 'w';// 可以很好打印出来
	printf("%s\n", arr);打印wbcdfe
  return 0;
}

1.例题讲解

#include<stdio.h>
int main()
{
	char str1[] = "hello bit.";str1和str2是两个不同数组  占有的空间不同
	char str2[] = "hello bit.";所以输出not same
	const char* str3 = "hello bit.";常量字符串 const修饰不能被修改
	const char* str4 = "hello bit.";所以str3和str4相等
	从编译器的角度来讲 他们指向的空间是一份 所以输出same
	如果比较&str3和&str4不相同 因为取得是各自的地址 地址占有的空间不同
	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;
}

 (二)指针数组

指针数组是存放指针的数组。

#include<stdio.h>
int main()
{
	char* arr[5]; 存放字符指针的数组。
	int* arr1[5]; 存放整形指针的数组。
	char* arr[] = { "abc","hehe","haha" };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%s\n", arr[i]);输出 abc hehe haha
	}
	return 0;
}

char *= abc;
char *= hehe;
char *= haha;

#include<stdio.h>
int main()
{
	字符数组是一个存放字符的数组。
	整形数组是一个存放整型的数组。
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 4,5,6,7,8 };
	int arr3[] = { 6,7,8,9,0 };
	arr是一个存放整形指针的数组
	int* arr[] = { arr1,arr2,arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int  j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);  arr[i][j]==*(arr[i]+j))
			printf("%d ", *(arr[i]+j));  选择其中一个都可以打印出来二维数组
		}
		printf("\n");
	}
	return 0;
}

(三)数组指针

#include<stdio.h>
int main()
{
	数组指针
	类比一下
	整形指针——指向整形的指针
	int a = 10;
	int *p=&a;
	字符指针——指向字符的指针
	char ch='w';
	char*p=&ch;
	数组指针——指向数组的指针
	 &arr取出的是数组的地址
	int arr[10]
	int*pa[10]=&arr; 指针数组 
	int(*pa)[10]=&arr; 数组指针
    解释：pa先和*结合，说明pa是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以pa是一 个指针，指向一个数组，叫数组指针。
这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证pa先和*结合。

	char arr[10];
	*pc=&arr;
	指针数组——是数组 是一种存放指针的数组
	数组指针--是指针 是一种指向数组的指针
	char*arr[5];
	int arr[5];
	*p=&arr;
	int(*p)[5]=&arr;
	return 0;
}

(四)数组名和&数组名的区别

#include<stdio.h>
int main()
{
	int arr[20]
	arr和&arr有什么区别？
	数组名绝大部情况下是数组首元素地址
	但有两个例外
	1.sizeof(数组名)-sizeof内部单独放一个数组名的时候，数组名表示的整个数组，计算得到的是数组的总大小
	2.&arr -这里的数组名表示整个数组，取出的是整个数组的地址，从地址值的角度来讲和数组首元素的地址是一样的，但是意义不一样

	int arr[10] = { 0 };
	printf("%p\n", arr); 相当于int*
	printf("%p\n", arr+1); 跳过一个字节 就是+4
	printf("%p\n", &arr[0]); 相当于int*
	printf("%p\n", &arr[0]+1); 跳过一个字节 就是+4
	printf("%p\n", &arr); int(*p)[10] p是一个数组指针
	printf("%p\n", &arr+1); 跳过整个数组的大小
	return 0;
}

运行结果如下图 

 通过计算&arr+1地址是D54和计算结果相同，所以&arr -这里的数组名表示整个数组，取出的是整个数组的地址，从地址值的角度来讲和数组首元素的地址是一样的，但是意义不一样。

这句话是正确的。

实际上:&arr表示的是数组的地址，而不是首元素的地址。

数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40。

(五)数组指针的使用

include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int(*p)[10] = &arr; 有点复杂了
	int i = 0;
	p==&arr
	*p==*&arr
	*p==arr
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *((*p) + i)); 有点脱裤子放屁了 虽然可以打印 但不推荐
	}
	int* p = arr;使用指针访问
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));这种打印简洁易懂
	}
	return 0;
}

(六)一维数组传参和二维数组传参 一级指针传参和二级指针传参

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

一维 数组传参，形参可以是数组，也可以是指针的，当形参是指针的时候，要注意类型。

#include<stdio.h>
二维数组传参，形参是数组
void print(int arr[3][5], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
		printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
二维数组传参，形参是数组指针
void print(int(*arr)[5], int row, int col)  （*arr）指向第一行的地址，是一维数组的地址
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			*printf("%d ", *(*(arr + i)+j)); arr[i]
			printf("%d ", arr[i][j]); arr[i] 没有太大区别
		}
		printf("\n");
	}
}
int main()

{
	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,7,8,9,0,6 };
二维数组的数组名，也表示首元素的地址
二维数组的首元素是第一行
首元素的地址就是第一行的地址，是一个一维数组的地址
	 print(arr, 3, 5);
	 return 0;
}

 

二维数组传参，参数可以是指针，也可以是数组，如果是数组，行可以省略，但列不可以省略 

如果是指针，传过去的是第一行的地址，形参就应该是数组指针 int(*arr)[5]。

一级指针传参
#include <stdio.h>
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(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;
}

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
int a;
print(&a,10);
int*p1=&a;
print(p1,10);
int arr[10];
print(arr,10);

二级指针传参
#include <stdio.h>
void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}

当函数的参数为二级指针的时候，可以接收什么参数？
test(二级指针)
test(一级指针变量的地址）
int*arr[10];
test(arr);

 (七)函数指针

#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()
{
	pf就是函数指针
	int (*pf)(int,int) = Add; 函数的地址要存放起来，就得放在【函数指针变量中】
	加不加x y都无所谓
	int ret = (*pf)(3, 5);
	int ret = Add(3, 5);
	int ret = pf(3, 5);
	int ret = (*******pf)(3, 5); *写不写都无所谓 只是为了好理解 *相当于摆设
	printf("%d", ret);
	return 0;
}

 

char* test(int c, float* pf)
{

}
int main()
{
	char* (*pt)(int,float*)=test;
	return 0;
}

接下来我们看两个有趣的代码

代码1
(*(void (*)())0)();
代码2
void (*signal(int , void(*)(int)))(int);




  char *(*)(int,float*)=test;
1.将0强制类型转换为void(*)()类型的函数指针
2.这就是意味着0地址处放着一个函数，函数没参数，返回类型是void
3.调用0地址的这个函数
下面代码是一次函数调用
(*(void (*)())0)();

代码2
void (*signal(int, void(*)(int) ) )(int);

signal是一个函数的声明
函数的名字是signal
函数的参数第一个是int，第二个参数是void(*)(int)类型的指针
该函数指针指向的函数参数是int，返回类型是void
signal函数的返回类型也是一个函数指针
该函数指针指向的函数参数是int，返回类型是void
void (*)(int) signal(int, void(*)(int));
void (* signal(int, void(*)(int)))(int);
void (*)(int);
 
怎么简化这两个代码呢？

typedef int* ptr_r;
typedef void(*pf_t)(int); 将void(*)(int)类型重新起个别名叫pf_t

typedef void(*pf_t2)(int); pt_t2是类型

代码1
void(*pf)(int); pf是函数指针变量的名字
代码2
pf_t signal(int, pf_t);