C语言 指针进阶（一）

目录

一、字符指针

二、指针数组

 通过类比的方法来认识指针数组

2.1指针数组的一般形式

2.2指针数组模拟实现二维数组

三、数组指针

 通过类比的方法来认识数组指针

3.1数组指针的一般形式

3.2&数组名VS数组名

3.3数组指针的使用

四、数组参数、指针参数

4.1一维数组传参

4.2 二维数组传参

4.3一级指针传参 

4.4二级指针传参

---

前言：在初阶指针中，我们了解了指针的概念。指针就是个变量，用来存放地址，地址唯一标识一块内存空间，同时指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。接下来就让我带领大家认识各种类型的指针。

一、字符指针

字符指针的一般形式：

        char* 变量名

 字符指针的一般使用

int main()
{
	char ch = 'w';
	char* pc = &ch;       //pc就是字符指针

    ch='a';
	*pc = 'a';

	return 0;
}

可以直接改变变量ch的值，也可以通过指针来改变变量ch的值。

int main()
{
    char arr[]="abcdef";
    //创建一个数组，用字符串来初始化这个数组
    const char* p="abcdef"；  //常量字符串
    //本质是将字符串首元素的地址赋给指针变量p
}

本质是将字符串首元素的地址赋给指针变量p。因为是常量字符串，不能被修改，所以加上const防止*p修改字符串。

通过打印验证p中存放的是字符串首元素的地址

int main()
{
	const char* p = "abcedf";

	printf("%s\n", p);
	printf("%c\n", *p);
}

 例题分析：

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 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;
}

 str1和str2是创建的两个数组，各自有独立的空间，两个数组虽然存放的相同的字符串，但地址是不相同的。str1和str2是数组名，数组名表示首元素地址，所以str1！=str2

二、指针数组

 通过类比的方法来认识指针数组

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

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

指针数组--存放指针的数组

2.1指针数组的一般形式

        int* arr1[10];              //整形指针数组

        char* arr2[10];          //字符型指针数组

2.2指针数组模拟实现二维数组

#include 
int main()
{
	int arr1[] = { 1,2,3,4,5 };		//arr1 - 数组名 - 首元素地址 int*
	int arr2[] = { 2,3,4,5,6 };		//arr2 - 数组名 - 首元素地址 int*
	int arr3[] = { 3,4,5,6,7 };		//arr3 - 数组名 - 首元素地址 int*

	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]);
		}
		printf("\n");
	}
	return 0;
}

 

创建的三个数组在内存中空间不是连续的，所以并不是真正的二维数组。

三、数组指针

 通过类比的方法来认识数组指针

整型指针--指向整型变量的指针。即存放整型变量地址的指针变量

字符指针--指向字符变量的指针。即存放字符变量地址的指针变量

数组指针--指向数组变量的指针。即存放数组变量地址的指针变量

3.1数组指针的一般形式

        int (*p)[10]; 

解释：p先和*结合，说明p是一个指针变量，然后指向一个大小为10个整型的数组（指向的类型  int [10]）。所以p是一个指针，指向一个数组，叫数组指针。

注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

3.2&数组名VS数组名

数组名通常情况下是首元素地址，但有两个例外

1. sizeof(数组名)   数组名单独放在sizeof()内部，这里的数组名表示整个数组，计算的是整个数组的大小

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

3.3数组指针的使用

int main()
{
     int arr[10] = {1,2,3,4,5,6,7,8,9,0};
     int (*p)[10] = &arr;    //把数组arr的地址赋值给数组指针变量p
     return 0;
}

void Print(int(*arr)[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("%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;
}

代码解读：

printf("%d ", *(*(arr+i)+j));

*&arr==arr   首元素地址

*(arr+i)==arr+i   等价于第i行的首元素地址，+j跳过j个元素  

二维数组的每一行可以理解为二维数组的一个元素，每一行又是一个一维数组。 

数组名arr，表示首元素的地址，二维数组的首元素是二维数组的第一行所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址可以数组指针来接收。

补充：

一维数组传参，形参的部分可以是数组，也可以是指针

void test1(int arr[5], int sz)
{}

void test2(int* arr, int sz)
{}

int main()
{
	int arr[5] = { 0 };
	test1(arr, 5);
	test2(arr, 5);
	return 0;
}

 二维数组传参，形参的部分可以是数组，也可以是指针

void test1(int arr[3][5], int r,int c)
{}

void test2(int (*p)[5], int r,int c)
{}

int main()
{
	int arr[3][5] = { 0 };
	test1(arr,3, 5);
	test2(arr,3, 5);
	return 0;
}

注意：形参写成数组形式是为了让人更容易理解，本质上是指针。

四、数组参数、指针参数

4.1一维数组传参

void test(int arr[10])//ok?
{}

void test(int *arr)//ok?
{}

int main()
{
     int arr[10] = {0};
     test(arr);
}

第一个是正确的，数组传参用数组接收，但形参的本质是指针。元素个数可以省略。

第二个是正确的，数组名传递的是首元素地址，所以可以用指针接收。

void test(int* arr[20])//ok?
{}

void test(int **arr)//ok?
{}

int main()
{
     int *arr2[20] = {0};
     test(arr2);
}

第一个是正确的，指针数组可以用指针数组接收。

第二个是正确的， 变量的类型是指针数组，数组中存放的是地址，每个元素类型为int*，数组名是首元素的地址，实参传递的是指针的地址，所以用二级指针接收。

4.2 二维数组传参

void test(int arr[3][5])//ok？
{}

void test(int arr[][])//ok？
{}

void test(int arr[][5])//ok？
{}

void test(int *arr)//ok？
{}

void test(int* arr[5])//ok？
{}

void test(int (*arr)[5])//ok？
{}

void test(int **arr)//ok？
{}

int main()
{
     int arr[3][5] = {0};
     test(arr);
}

 第一个是正确的，数组传参用数字接收。

注意：：二维数组传参，函数形参的设计只能省略第一个[]的数字。

因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。

 第四个是错误的，二维数组的数组名是一行的地址，类型是int(*)[]，不能用int* arr接收。

第六个是错误的，整形变量的地址不能用二级指针接收。

4.3一级指针传参 

       当一个函数的参数部分为一级指针的时，函数的实参可以传递的参数

void test(int* p)
{}

int main()
{
	int n = 10;
	test(&n);

	int* p = &n;
	test(p);

	int arr[5] = { 0 };
	test(arr);
	return 0;
}

4.4二级指针传参

          当一个函数的参数部分为二级指针的时，函数的实参可以传递的参数

void test(int** p)
{}

int main()
{
	int n = 10;
    int* p=&n;
	test(&p);

	int** pp = &p;
	test(pp);

	int* arr[5] = { 0 };
	test(arr);
	return 0;
}

本次的内容到这里就结束啦。希望大家阅读完可以有所收获，同时也感谢各位读者的支持。文章有问题可以在评论区留言，博主一定认真认真修改，以后写出更好的文章。