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("%sn", p);
	printf("%cn", *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 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和str2是创建的两个数组,各自有独立的空间,两个数组虽然存放的相同的字符串,但地址是不相同的。str1和str2是数组名,数组名表示首元素地址,所以str1!=str2

二、指针数组

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

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

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

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

2.1指针数组的一般形式

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

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

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

#include <stdio.h>
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;
}

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

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇

)">
下一篇>>