深⼊理解指针-通过指针引用数组

原创 已于 2024-06-29 21:39:04 修改
· 2.3k 阅读 · 45 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #学习 #算法

于 2024-05-23 16:35:31 首次发布

1. 数组名的理解(补充知识点)

使用指针访问数组的内容时，有这样的代码：

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

这里我们使用&arr[0]的方式拿到了数组第一个元素的地址，但是其实数组名本来就是地址，而且是数组首元素的地址，我们来做个测试。

#include <stdio.h>

int main()
{                   
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; //数组在内存中是连续存放的,所以只用找到数组首元素的地址即可找到整个数组
	//int* p = &arr[0]; //数组名是数组首元素的地址
	printf("&arr[0] = %p\n", &arr[0]); //取出首元素，得到数组首元素的地址
	printf("arr     = %p\n", arr); //数组名就是数组首元素的地址

	return 0;
}

输出结果(一下是在x86(打印的地址较短)架构下编译的)：

请添加图片描述

我们发现数组名和数组首元素的地址打印出的结果一模一样，数组名就是数组首元素(第一个元素)的地址。

这时候有同学会有疑问？数组名如果是数组首元素的地址，那下面的代码怎么理解呢？

#include <stdio.h>
int main()
{
    int arr[ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };
    printf("%d\n", sizeof(arr)); //sizeof是就是计算数组大小的，如果数组名表示首元素地址,x86——>4,x64——>8,但是在x86打印出的是40，x64打印出的是80，这时候就有点迷糊了。
    return 0 ;
}

请添加图片描述
输出的结果是： 40 ，如果arr是数组首元素的地址，那输出应该的应该是 4 / 8 才对。

其实数组名就是数组首元素(第一个元素)的地址是对的，但是有两个例外：

  • sizeof(数组名) ，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节，所以打印出来的结果是40。

  • &数组名 ，这里的数组名表示整个数组，取出的是 整个数组的地址 （整个数组的地址和数组首元素的地址是有区别的）

除此之外，任何地方使用数组名，数组名都表示首元素的地址。

这时有好奇的同学，再试一下这个代码：

#include <stdio.h>
int main()
{
    int arr[ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };
    printf("&arr[0] = %p\n", &arr[ 0 ]); //打印数组首元素的地址
    printf("arr = %p\n", arr); //数组名打印数组首元素的地址
    printf("&arr = %p\n", &arr); //打印整个数组的地址
    return 0 ;
}

请添加图片描述

三个打印结果一模一样，这时候又纳闷了，那arr和&arr有啥区别呢？

总结

指针类型决定了指针的差异

#include <stdio.h>
int main()
{
    int arr[ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };
    printf("&arr[0] = %p\n", &arr[ 0 ]); //打印数组首元素的地址
    printf("&arr[0]+1 = %p\n", &arr[ 0 ]+ 1 ); //int*类型指针，地址加1，跳过第一个元素，4个字节

    printf("arr = %p\n", arr); //数组名打印数组首元素的地址
    printf("arr+1 = %p\n", arr+ 1 ); //int*类型指针，地址加1，跳过第一个元素，4个字节

    printf("&arr = %p\n", &arr); //打印整个数组的地址
    printf("&arr+1 = %p\n", &arr+ 1 ); //int*类型指针，地址加1，跳过整个数组，40个字节

    return 0 ;
}

输出结果：

&arr[ 0 ] = 0077F 820
&arr[ 0 ]+ 1 = 0077F 824

arr = 0077F 820
arr+ 1 = 0077F 824

&arr = 0077F 820
&arr+ 1 = 0077F 848

这里我们发现&arr[ 0 ]和&arr[ 0 ]+ 1 相差 4 个字节，arr和arr+ 1 相差 4 个字节，是因为&arr[ 0 ] 和 arr都是首元素的地址，+ 1 就是跳过一个元素。

但是&arr和&arr+ 1 相差 40 个字节，这就是因为&arr是数组的地址，+ 1 操作是跳过整个数组的。

到这里大家应该搞清楚数组名的意义了吧。

数组名是数组首元素的地址，但是有 2 个例外。

2.使用指针访问数组

有了前面知识的支持，再结合数组的特点，我们就可以很方便的使用指针访问数组了。

以下是使用数组下标访问数组元素的过程：

#include <stdio.h>
int main()
{
    int arr[ 10 ] = { 0 };
    int sz = sizeof(arr)/sizeof(arr[ 0 ]); //整个数组大小/一个元素的大小=数组的元素个数

    //输入
    int i = 0;
    for(i= 0 ; i<sz; i++)
    {
       scanf("%d", &arr[i]);
    }
    //输出
    for(i= 0 ; i<sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0 ;
}

输出结果:

输出结果

以下是使用指针访问数组元素的过程：

#include <stdio.h>
int main()
{
    int arr[ 10 ] = { 0 };
    int sz = sizeof(arr)/sizeof(arr[ 0 ]); //整个数组大小/一个元素的大小=数组的元素个数

    //输入
    int i = 0 ;
    int* p = arr;

    for(i= 0 ; i<sz; i++)
    {
       scanf("%d", p+i);//p+i是下标为i的元素的地址
    }
    //输出
    for(i= 0 ; i<sz; i++)
    {
        printf("%d ", *(p+i)); //对(p+i)进行指针加法，解引用，得到元素的值
    }
    return 0 ;
}

输出结果:

请添加图片描述

数组名arr是数组首元素的地址，可以赋值给p，其实数组名arr和p在这里是等价的。那我们可以使用arr[i]可以访问数组的元素，那p[i]是否也可以访问数组呢？

#include <stdio.h>
int main()
{
    int arr[ 10 ] = { 0 };
    //输入
    int i = 0 ;
    int sz = sizeof(arr)/sizeof(arr[ 0 ]); //整个数组大小/一个元素的大小=数组的元素个数

    //输入
    int* p = arr;
    for(i= 0 ; i<sz; i++)
    {
        //scanf("%d", p+i); //p+i是下标为i的元素的地址
        scanf("%d", arr+i);//也可以这样写
    }

    //输出
    for(i= 0 ; i<sz; i++)
    {        
        //printf("%d ", *(p+i));
        printf("%d ", *(arr+i)); //也可以这样写
    }
    return 0 ;
}

输出结果:
请添加图片描述

在第 18 行的地方，将(p+i)换成p[i]也是能够正常打印的，所以本质上p[i]是等价于(p+i)**。

同理arr[i]应该等价于(arr+i)，数组元素的访问在编译器处理的时候，也是转换成首元素的地址+偏移量求出元素的地址，然后解引用来访问的*。

总结

请添加图片描述

内容总结

请添加图片描述

3.一维数组传参的本质

首先从一个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给一个函数后，函数内部求数组的元素个数吗？

#include <stdio.h>

//数组传参的时候，形参可以写成指针形式，也可以写成数组形式
//写成数组形式，最简单，是为了方便理解，容易接受这种语法
//但是即使写成数组形式，本质上还是指针变量

          //int * arr
void test(int arr[]) //参数写成数组形式，本质上还是指针
{
    int sz2 = sizeof(arr)/sizeof(arr[ 0 ]); //计算一个指针变量的大小
    printf("sz2 = %d\n", sz2);
}

int main()
{
    int arr[ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };
    int sz1 = sizeof(arr)/sizeof(arr[ 0 ]); //szl=10
    printf("sz1 = %d\n", sz1); //10
    
    test(arr); //arr是数组名，本质上是数组首元素的地址
    //数组传参的本质，传递的是数组首元素的地址
    //所以形参即使写成数组形式，本质上也是一个指针变量

    return 0 ;
}

输出的结果：

请添加图片描述

总结:

数组名是数组首元素的地址；

那么在数组传参的时候，传递的是数组名，也就是说 本质上数组传参传递的是数组首元素的地址 。

所以函数形参的部分理论上应该使用指针变量来接收首元素的地址。 那么在函数内部我们写sizeof(arr)计算的是一个地址的大小（单位字节）而不是数组的大小（单位字节）。 正是因为函数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

void test(int arr[])//参数写成数组形式，本质上还是指针
{
    printf("%d\n", sizeof(arr));
}

void test(int* arr)//参数写成指针形式
{
printf("%d\n", sizeof(arr));//计算一个指针变量的大小
}

int main()
{
int arr[ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };
test(arr);
return 0 ;
}

总结： 一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

4.冒泡排序

冒泡排序的核心思想就是：两两相邻的元素进行比较,不满足顺序就交换位置，满足顺序就找下一个数字。

void input(int *arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", arr + i);
	}
}

int count = 0;
void bubble_sort(int *arr, int sz)
{
	//确定趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设已经满足顺序
		//每一趟内部的比较
		int j = 0;
		for (j = 0; j < sz-1-i; j++)
		{
			count++;
			if (arr[j] > arr[j + 1])
			{
				flag = 0;//还不是有序
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[10] = { 0 };
	//输入一些值
	//1 2 3 4 5 6 7 8 9 10
	//9 8 7 6 5 4 3 2 1 0
	//2 1 9 7 0 3 4 8 5 6 
	int sz = sizeof(arr) / sizeof(arr[0]);
	input(arr, sz);

	//排序 - 写一个函数完成数组的排序，排成升序
	bubble_sort(arr, sz);//使用冒泡排序
	print_arr(arr, sz);
	printf("\ncount = %d\n", count);
	return 0;
}

画图理解

请添加图片描述

5.二级指针

什么是二级指针？

char*
int*
double*
//一级指针

这就是二级指针。

#include <stdio.h>

int main()
{
    int a = 10 ;
    int* pa = &a ;//pa一级指针变量
    int** ppa = &pa ;//ppa是二级指针变量，指向一级指针

    printf("%d\n", **ppa); //输出10
    return 0 ;
}

**ppa == *pa == a ==10 //三者等价

请添加图片描述

请添加图片描述

对于二级指针的运算有：

  • *ppa通过对ppa中的地址进行解引用，这样找到的是pa，*ppa其实访问的就是pa.
int b = 20 ;
*ppa = &b;//等价于 pa = &b;
  • **ppa先通过*ppa找到pa,然后对pa进行解引用操作：*pa，那找到的是a.
**ppa = 30 ;
//等价于*pa = 30;
//等价于a = 30;

总结

二级指针变量是用来存放一级指针变量的地址的。

6.指针数组

指针数组是指针还是数组？

我们类比一下，整型数组，是存放整型的数组，字符数组是存放字符的数组。

char arr[10]; //字符数组-存储字符的数组
int arr[5]; //整型数组-存储整型的数组

那指针数组呢？

指针数组-存放指针的数组，数组的每个元素其实是指针类型，都是用来存放地址的。

char* arr[5]; //存放字符指针的数组
int* arr[5]; //存放整型指针的数组

是存放指针的数组。

请添加图片描述

指针数组的每个元素都是用来存放地址（指针）的。

如下图：

请添加图片描述

指针数组的每个元素是地址，又可以指向一块区域。

通过一个简单的例子来说明：

#include <stdio.h>

int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    
    //使用指针变量，这样太麻烦了，所以使用指针数组
    //int* p1 = &a;
    //int* p2 = &b;
    //int* p3 = &c;

    //使用指针数组    
    int* arr[3] = { &a, &b, &c }; //存放3个整型指针的数组
    //              0    1   2  //通过下标进行指针解引用

    int i = 0;
    for(i = 0; i < 3; i++)
    {
        printf("%d ", *(arr[i])); //解引用，输出地址的值
    }
    return 0;
}

*输出结果：

10 20 30

说明：

  1. 指针数组的每个元素是地址，解引用可以得到地址的值。

  2. 指针数组的本质就是存放指针的数组，数组的每个元素都是指针类型，都是用来存放地址的。

  3. 指针数组的每个元素都是地址，又可以指向一块区域。

7.指针数组模拟二维数组

#include <stdio.h>
int main()
{
    int arr1[5] = { 1 , 2 , 3 , 4 , 5 }; //定义3个整型一维数组
    int arr2[5] = { 2 , 3 , 4 , 5 , 6 };
    int arr3[5] = { 3 , 4 , 5 , 6 , 7 };
    //arr1 arr2 arr3 是三个数组的数组名，表示三个数组的首元素的地址

    //数组名是数组首元素的地址，类型是int*的，就可以存放在arr数组中
    int* arr[ 3 ] = {arr1, arr2, arr3};
    int i = 0 ;
    
    for(i= 0 ; i< 3 ; i++) //通过for循环，访问三个数组的数组名
    {
        int j = 0 ;
        for(j= 0 ; j< 5 ; j++) //通过for循环，访问三个数组中某个数组的元素
        {
            printf("%d ", arr[i][j]); //*(*(arr+i)+j)
        }
         printf("\n");
    }
    return 0 ;
}

输出结果：

1 2 3 4 5
2 3 4 5 6
3 4 5 6 7

下面是对上述第10~20行代码的解释：

请添加图片描述

arr[i]是访问arr数组的元素，arr[i]找到的数组元素指向了整型一维数组，arr[i][j]就是整型一维数组中的元素。

上述的代码模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行并非是连续的。

深⼊理解指针（1）
m0_70595067的博客
02-15 833
前⾯的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4个字节才能存储。上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n就⾏修改，就不符合语法规则，就报错，致使没法直接修改n。同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要8个字节的空间，指针变的⼤⼩就是8个字节。
使用指针访问数组元素
水镜の庐
08-02 1万+
C++语言中,指针和数组密切相关.特别是在表达式中使用数组名时,该名字会自动 转换为指向数组第一个元素的指针:int ia[]={0,2,4,6,8};int *ip=ia;  //ip points to ia[0]如果希望使指针指向数组中的另一个元素,则可使用下标操作符给某个元素定位,然后用取地址操作符&获取该元素的存储地址:ip=&ia[4];  //ip points to l
指针数组、数组指针——用指针访问数组方法总结
热门推荐
HerofH_的博客
01-14 8万+
目录 1.数组元素的访问 2.通过指针访问数组 2.1 通过指针访问一维数组 2.2 通过指针访问二维数组 2.2.1 指向元素的指针 2.2.2 指向每一行的指针（指针数组方式） 2.2.3 指向整个数组的指针（数组指针方式） 3 总结 1.数组元素的访问 数组中的各元素在内存中是连续分布的，要想访问数组中某一元素，那么就必须知道其地址。 在一...
C语言数组指针的用法详解（附带实例）
最新发布
zdoeo的博客
03-27 1376
数组（Array）是一系列具有相同类型的数据的集合，每一份数据叫做一个数组元素（Element）。数组中的所有元素在内存中是连续排列的，整个数组占用的是一块内存。以为例，该数组在内存中的分布如下图所示：定义数组时，要给出数组名和数组长度，数组名可以认为是一个指针，它指向数组的第 0 个元素。在C语言中，我们将第 0 个元素的地址称为数组的首地址。
C语言通过指针访问数组元素介绍
匠心码农
12-27 724
C语言通过指针访问数组元素介绍
C通过指针访问数组元素
匠心码农
11-05 808
在C/C++语言中，数组除了通过数组索引访问，也可以通过指针来访问数组中的元素。
c语言指针数组-·详解数组指针与指针数组
04-25
3. 通过指针引用数组元素：可以通过指针遍历数组，例如： ```c int a[10] = {1,2,3,4,5,6,7,8,9,0}; int *p; for(p=a; p<(a+10); p++) { printf("%d ", *p); } printf("\n"); ``` 这段代码会依次打印出数组`a`的...
学习笔记---二维数组-数组指针-指针数组
aketoshknight的博客
01-19 851
二维数组 基础使用 定义及初始化 定义： 类型标识符  数组名  [常量表达式] [常量表达式] 初始化： 分行： 例：int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; 特点：直观，方便。 不分行： 例：int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; 特点：展现二
程序设计-通过指针引用数组元素.pptx
10-23
这种通过数组名加下标来访问数组元素的方式，在内部也涉及到指针的计算过程，因此在执行效率上与下标法相似。同样，这种方式虽然直观，但在处理大量数据时，频繁的地址计算可能会影响程序性能。 最后，指针变量法...
再再论指针-分析指针与数组的好文
12-23
在处理指针时，我们需要理解指针的声明、初始化、解引用以及指针运算。例如，`int *p`声明了一个指向整数的指针`p`，`*p`则代表该指针所指向的值。指针可以递增或递减，以便移动到数组的下一个或上一个元素。然而，...
C++指针 数组 内存释放.docx
11-15
C++指针数组内存释放 C++指针是一种基本变量，包含一个实际的数据，该数据代表一个可以找到实际信息的内存地址。指针是C++编程中非常重要的概念，许多程序和思想...要理解指针的概念和使用方法，需要多次实践和练习。
指针操作数组
weixin_44502835的博客
01-31 2892
基本概念：指针操作数组的两种方式：     1：p+value     2：p[value]    指针数组与数组指针区别：     指针数组：一个数组，存放的全是指针；     数组指针:一个指向数组的指针；   1.一维数组与指针:      int*p=a[ ];是将a[ ]首地址传给p；      cout&lt;&lt;*p&lt;&lt; ;        将a[]的收地...
C语言 通过指针引用数组元素
NuYoaH502329的博客
02-14 4328
引用一个数组元素有两种方法： （1）**下标法**，如a[i]的形式； （2）**指针法**，如`*(a+i)`或`*(p+i)`。其中a是数组名，p是指向数组元素的指针变量，其初值p=a。 【注意】 在使用指针变量指向数组元素时，要注意以下问题： （1）可以通过改变指针变量的值指向不同的元素。例如，当用指针变量p指向数组中的某一元素，用p++使p的值不断改变从而指向不同的元素。 如果不用p变化的方法而用数组名a变化的方法（例如，用a++）是不行的。因为数组名a代表数组首元素的地址，它是一个指针型常量，所以
通过指针访问数组
weixin_45907018的博客
02-27 1025
指针与指针变量的区别 指针；一个变量的地址 指针变量；一种变量专门存放地址 指针变量的值是**（指针）**地址 一维数组 int a[4]={1,2,3,4}; 学过C++的都知道一维数组的名字就是首地址； 所以可以如下表，如果int *p=a; a==&a[0] p==&a[0] a+1==&a[1] p+1=&a[1] 可以说a与p等效...
指针与一维数组
RVETHR的博客
12-10 544
形参数组和实参数组是同一个数组。两个同类型指针的减法运算。指针与整数的加减运算。
深入了解指针，指针数组，数组指针。
qq_63943454的博客
08-14 1474
大家可能听说过这样一句话，没学过指针就是没学过C语言。指针确实时C语言的一大特色，更是C语言的一大核心。但是指针的学习也没有大家想象的这么难。今天就带大家一起来深入学习一下指针。...
用指针法访问数组元素
adsyzh的专栏
03-03 1245
数组的名字就相当于数组第一个元素的地址。 第一种方式：声明一个指针，用它遍历整个数组 source code: //head files #include #include #include #define SIZE 10 //main int main(int argc, const char * argv[]) { int dataList[SIZE]
用指针访问数组元素
沐埜专栏
09-15 1245
数组是一组连续存储的同类型数组，可以通过指针的算术运算，使指针一次指向数组的各个元素，进而可以遍历数组。 定义指向数组元素的指针：  ·定义与赋值：             例：int a[10],*pa;                    pa = &a[0];或 pa = a;    等效的形式：         1、经过上述定义及赋值后：           *pa
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值