我们使用指针操作数组的 **重要思想是：  数组在内存中是连续存放元素的** 
我们使用指针操作数组的 **重要运算是：  数组 + - 整数** 


## 数组名的理解

**数 组 名 就 是 数 组 首 元 素 (第 ⼀ 个 元 素) 的 地 址。** 

**但是有两个例外：** 
**• sizeof(数组名)** 这里的数组名表示整个数组，sizeof中单独放数组名， 计算的是整个数组的大小 ，单位是字节
**• &数组名** 这里的数组名表示整个数组， 取出的是整个数组的地址 



#### 辨析 数组名，数组首元素，&数组名

对于一个 int  类型的数组 arr[10] , 我们有：
arr  /  &arr[0]  /  &arr在初次使用时，它们三个的值一样，但 &arr 和另外两个如此比较没意义


&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，是因为&arr[0] 和 arr 都是首元素的地址，+1跳过了⼀个元素。


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



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



## 使用指针访问数组

我们学习完上面的知识，现在完全很方便的用指针访问数组了


```cs
#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);
            //scanf("%d", arr+i);//也可以这样写
        }
 //输出
      for(i=0; i<sz; i++)
        {
           printf("%d ", *(p+i));
        }
 return 0;
}
```

我们现在应该意识到 上面的*(arr + i) == *(i + arr),简单解释就是i 和 arr 都是整数，可以交换加法， 解引用 * 看中的是（）中的结果，运算方式不限。


在编译器里，对于数组下标指向的 arr[i] 访问时就是将它改成上面的 *（arr + i)的解引用形式
所以 *(p+i) ----------> p[i]--------->arr[i]--------->*(arr+i)



#### 几个问题

那么我们更进一步既然*(arr + i) == *(i + arr)  那么  arr[i] --- ？---i[arr]，这里i是整数，那等式相等吗
先说结论，相等 ：arr[i] == i[arr]
*我们首先怀疑  整数 i 能否运用 [ ] ,为了解决这个问题，我们先来想这里 [ ] 是什么？* 
*我们潜意识里觉得 [ ] 跟在数组后面，既可以指示元素的个数，也可以做下标引用操作符，指示第几号元素
这里， [ ] 很明显是下标引用操作符，这时候它是可以应用到常数上的 ，这个事我会在最后解答为什么* 

*对于 arr[i] == i [arr] 他们在编译器里都会转化为 *(arr + i)和 *(i + arr)* ，这两个相等是没有疑问的。
再解释一下：这就类似于 1+2 = 2+1，对1和2应用+操作符，1和2哪个在前都无所谓，所以 i 和 arr 那个在前都无所谓
*只是 i [arr] 的形式真的没什么可读性，更没什么人写* 


那为什么下标引用操作符[ ] 里既可以放数组名，也可以放常数呢？
我们其实也已经做出了解释， **下标引用操作符其实在编译的时候 :  A [B] 会变成 *(A+B) ,这是下标引用操作符的实质** 
具体的是因为，下标引用操作符指向的是地址，是在地址层面进行操作，它实际上是对地址进行加减整数运算，只要求有整数和地址即可，数组名就是地址所以有数组名和常数就行



看到 p [i] == arr [i]的形式，我们更加困惑数组和指针(变量)的关系，数组是指针(变量)吗？
不是，数组就是数组，一块连续的空间，数组的大小跟数组元素个数和数组类型有关
指针（变量）就是指针（变量）,是一个变量，指针变量的大小不是4Byte就是8Byte (32位环境是4字节，64位环境是8字节)
**数组名是数组首元素的地址，可以用指针来访问数组，找到首元素地址在顺藤摸瓜上找，这是他们唯一的可联系之处** 

补充知识：还记得怎么快速计算出数组元素个数么？ int sz = sizeof(arr)/sizeof(arr[0]),上一章（1）中指针加减整数讲过



## ⼀维数组传参的本质

我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给⼀个函数后，函数内部求数组的元素个数吗？
闲话少说，放码过来

```cs
#include <stdio.h>
void test(int arr[    ])       //也可以写成void text （int arr[10]);   
{
   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]);
   printf("sz1 = %d\n", sz1);
   test(arr);
     return 0;
}
```


运行后，我们可以发现，main函数的 sz1 是10，没问题，但外部函数 test 中的 sz2 是1，我们预想它应该是要和sz1一样为10，但不对，这说明我们按text函数敲码是做不到题目要求的


通过调试，监视，我们能很简单地发现问题所在：sz2 = 1, 原来
test接受的是arr第一个元素的地址，sizeof(arr)/sizeof(arr[0])的计算相当于sizeof(arr[0])/sizeof(arr[0])；自然是1， **这也警醒我们，sizeof(arr)/sizeof(arr[0])尽量在main函数里写** 


这里我们先等等，思考既然 test 接受的是 arr 第一个元素的地址，那么怎么形参的形式是int arr[ ]?

答：因为我们完全是可以将形参写成数组形式的，但，形参本质上还是一个指针变量



先别急着改，我们先往下看


这么看来传入数组到函数上还是要有注意事项的，我们应该注意什么呢？也很简单：


函数不只针对数组首元素进行操作的时候，我们不要把传完值的形参当作数组本身，而只是当第一个元素，我们可以顺藤摸瓜地扩展到这个数组本身，但不能开门见山地把形参当作数组本身操作
像是第一个text函数，把传入的arr形参当做是有10个元素的arr本身，就错了，我们要把它看作是首元素地址，这时候使用sizeof就完全没问题，这就是第二个text函数的所为

正是因为函数的参数部分是本质是指针，所以在函数内部是没办法用sizeof求的数组元素个数的。


我们用这个思想有一个text函数可以写

```cs
text ( int arr[ ] , int sz1)
{
 int i = 0 ;
 for ( i = 0 ; i < sz1 ; i++)
   {
       printf ( "%d  " ,*(arr+i) ) ;
   }
}
```

这就没问题了


## 冒泡排序

计算机编程中的排序算法有很多，冒泡、插入、选择、快速、希尔排序，堆排序等等，这里学习的冒泡排序算简单的。



#### 结论 / 记忆

**冒泡排序的核心思想就是：两两相邻的元素进行比较** 

**从头到尾对比一次数字大小的过程叫做一趟
一趟冒号排序解决一个数字** 


如果有n个元素要排序，就要走n-1趟
每个排好的元素放在两端中的一端（一般数组我们从第一个元素逐次往后比，所以固定的元素一般在后端）


如果已经走了i趟，对剩下的元素我们还要比 n-1-i 个，令 a[j] 和 a[j+1] 比较，j=o, j<n-1-i.



这上面的文字大都是结论，要想真正深刻的理解要自己举例尝试，语言阐释清楚要占太长篇幅，但原理又很简单，所以在此略过解释



#### 例子

下面是一个利用冒泡排序升序打印数组的例子

```cs
void bubble_sort(int arr[ ], int sz)//参数接收数组元素个数
{
     int i = 0;
    for(i=0; i<sz-1; i++)
     {
        int j = 0;
           for(j=0; j<sz-i-1; j++)
           {
                 if(arr[j] > arr[j+1])
                {
                  int tmp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = tmp;
                }
           }
      }
}
int main()
{
     int arr[] = {3,1,7,5,8,9,0,2,4,6};
     int sz = sizeof(arr)/sizeof(arr[0]);
     bubble_sort(arr, sz);
     int i = 0;
        for(i=0; i<sz; i++)
       {
         printf("%d ", arr[i]);
       }
  return 0;
}
```





#### 优化

当一组数据本身或者经过排序后已经接近有序了，再进行少次数的冒泡排序就有序后，我们要适时地限制排序，避免算力浪费
比如5，0，1，2，3，4 让他们正序打印，我们只要排序5，排完后已经完成要求，若不加限制，我们的排序算法会继续比较，遍历完所有能比较的元素，这就很不好了


所以我们要优化我们的冒泡排序算法

```cs
 
void bubble_sort(int arr[], int sz){
     int i = 0;
    for(i=0; i<sz-1; i++)
     {
        int j = 0;
                 int  flage = 1;
  //标识 a[j] 和 a[j+1] 是否进行对换值操作，即数组有没有已经有序
 
           for(j=0; j<sz-i-1; j++)
           {
                 if(arr[j] > arr[j+1])
                {
                  int tmp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = tmp;
                            flage = 0;   
  //只要对换了值，就说明还没有排好序，这一步正在排序，就让flage = 0
 
                }
                  if(flage = 1 )
                      {
                            break;    
 //flage=1,没变成零，说明上面所有未排序的 a[j] 都大于 a[j+1] ，已经排序的更不用想，说明这时我们已经完成了顺序的目的，不必要再继续进行无所谓的排序，直接跳出
                      }
           }
      }
}
```



## ⼆级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

这就是二级指针 。

**一级指针存其他变量（不是指针的），二级指针存一级指针的地址** 



一级指针就是我们上面一直讲的指针（地址编码）
如果说一级指针定义的时候要一个星号，比如 int * p1 ;
那么二级指针定义的时候要两个星号 ，比如 int ** p2 ;
**int ** 是二级指针类型，是一种专业的变量类型** 

三四级指针等更高级指针就是像这样无限套娃，这些也根本不好用


#### **二级指针加减整数** 

一级指针加减整数要看它指向对象的单位，如指向对象是char则加减1时只跳过1个字节，指向int 则加减一时跳过4个字节
二级指针加减整数的时候，看指向的一级指针的单位，我们之前说过，指针的大小只有4/8字节，这只和运行环境有关（x32或x64)


#### **二级指针解应用** 

假设有

```cs
int a ;
int * p = &a;
int ** pp = &p ;
```

我们开始pp的解应用，我们定义二级指针时有两个星号，对应的我们解应用的时候也用两个星号


*pp == p == &a
** pp == *p == a


## 指针数组

**指针数组是存放指针的数组，这个数组的每个元素都是指针类型的变量，指针变量又各自指向了一个地址，这就间接地指向了各个变量** 



指针数组模拟⼆维数组

```cs
#include <stdio.h>
int main()
{
    int arr1[] = {1,2,3,4,5};
    int arr2[] = {2,3,4,5,6};
    int arr3[] = {3,4,5,6,7};
 //数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中
    int* parr[3] = {arr1, arr2, arr3};
    int i = 0;
    int j = 0;
   for(i=0; i<3; i++)
   {
       for(j=0; j<5; j++)
       {
          printf("%d ", parr[ i ] [ j ]);
       }
       printf(" \n ");
    }
   return 0;
}
```

输入parr[i][j]的翻译过程是，拿parr[0][j]举例，取值范围 j：0~4

parr[0][ j ]  -------->  arr1[ j ] ------->  *(arr1+j) ------>  arr1[ j ]的确切数值




*注意：我们这里只是模拟二维数组，不是还原，我们做的不是真的二维数组，因为每一行并非是连续的。* 



二级指针，指针数组我觉得自己敲代码理解会才会很深。

我们使用指针操作数组的 重要思想是：  数组在内存中是连续存放元素的 我们使用指针操作数组的 重要运算是：  数组 + - 整数

C语言指针学习（2）- 指针和数组

编程语言

算法

指针操作数组的核心在于理解数组名即首元素地址，但sizeof和&操作例外。通过指针加减整数可遍历数组，arr[i]等价于i[arr]。冒泡排序需注意优化算法，避免无效比较。二级指针存储一级指针地址，指针数组则存放指针变量。掌握这些技巧能高效操作数组和指针。

编译器

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

C语言指针学习（2）- 指针和数组-腾讯云开发者社区-腾讯云

C语言指针学习（2）- 指针和数组

C语言指针学习（2）- 指针和数组

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐