【C语言】第八期——指针、二维数组与字符串

目录

1 初始指针
2 获取变量的地址
3 定义指针变量、取地址、取值
3.1 定义指针变量
3.2 取地址、取值
4 对指针变量进行读写操作
5 指针变量作为函数参数
6 数组与指针
6.1 指针元素指向数组
6.2 指针加减运算（了解）
6.2.1 指针加减具体数字 
6.2.2 指针加减指针
6.3 数组名与数组元素首地址的关系
6.4 数组作为函数参数
7 二维数组以及字符串与指针
7.1 二维数组的定义方法
7.1.1 定义一个二维数组 
7.1.2 访问二维数组
7.2 定义字符串的几种方法
7.3 字符串数组
7.4 strcat 毗连字符串
7.5 strcpy 字符串复制（拷贝）函数

---

1 初始指针

通过前面的教程我们知道变量是用来存储数据的，变量的本质是给存储数据的内存地址起了一个好记的别名
好比我们定义了一个变量 int a= 10 ,这个时候可以直接通过a这个变量来读取内存中保存的10 这个值，在计算机底层a这个变量实在对应了一个内存地址
指针也是一个变量，但它是一种特别的变量，它存储的数据不是一个普通的值，而是另一个变量的内存地址
每一个变量都有一个内存位置，每一个内存位置都定义了可利用连字号（&）运算符访问的地址，它表 示了在内存中的一个地址

   刚开始学C语言的指针操作，我们只必要记住两个符号 ：&（取地址） 和 *（根据地址取值 /定义指针变量）
  

---

2 获取变量的地址

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。C语言中利用&字符放在变量 前面对变量进行取地址操作

1. #include <stdio.h>
2. int main(void)
3. {
4.         int a = 10;
5.         printf("a的地址是:%p\n", &a);
6.         return 0;
7. }

复制代码

---

3 定义指针变量、取地址、取值

3.1 定义指针变量

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，必须在利用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般情势为：

1. type *var-name;

复制代码

在这里，type 是指针的基类型，它必须是一个有用的 C 数据类型，var-name 是指针变量的名称。用 来声明指针的星号 * 与乘法中利用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是 指针
以下是有用的指针声明：

1. int* ip;    //一个整型的指针
2. double* dp; //一个 double 型的指针
3. float* fp;  //一个浮点型的指针
4. char* ch    //一个字符型的指针

复制代码

所有指针的值都是一个地址，不管是整型、浮点型、字符型，照旧其他的数据类型，都是一样的，都是 一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同

---

3.2 取地址、取值

1. #include <stdio.h>
2. int main(void)
3. {
4.         // 定义一个int变量a
5.         int a = 10;
6.         printf("a的地址是:%p\n", &a);
7.         // 定义int类型的指针变量p
8.         int* p_a = &a;
9.         printf("指针p_a的值:%p\n", p_a);
10.         printf("指针p_a的地址:%p\n", &p_a);
11.         printf("a的值:%d\n", a);
12.         printf("根据指针p_a的值去内存取值得到的结果为：%d", *p_a);
13.         return 0;
14. }

复制代码

  总结：
  

• 取地址操作符&和取值操作符是一对互补操作符， & 取出地址， 根据地址取出地址指向的值
  
• 对变量进行取地址（&）操作，可以获得这个变量的地址
  
• 指针变量的值是地址
  
• 对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值
  

  

---

4 对指针变量进行读写操作

1. #include <stdio.h>
2. int main(void)
3. {
4.         int a = 10;
5.         int b = 20;
6.         int* p1, * p2; // 定义指针变量 p1、 p2
7.         p1 = &a;
8.         // p1 指向变量 a
9.         p2 = p1;
10.         // p2 指向变量 a
11.         printf("&a=%p p1=%p p2=%p\n", &a, p1, p2);
12.         *p1 = 20;
13.         printf("a的值%d,取指针得到的值%d", a, *p1);
14.         return 0;
15. }

复制代码

  运行结果：
  &a=000000612A17FA74 p1=000000612A17FA74 p2=000000612A17FA74
a的值20,取指针得到的值20
  

---

5 指针变量作为函数参数

在C语言中，函数参数不仅可以是字符型、整型、浮点型等，还可以是指针类型，作用是将变量地址传递给函数形参

1. #include <stdio.h>
2. void modify1(int *c)
3. {
4.         *c = 20;
5. }
6. int main(void) {
7.         int a = 10;
8.         modify1(&a);
9.         printf("%d", a);
10.         return 0;
11. }

复制代码

---

6 数组与指针

6.1 指针元素指向数组

数组本质上是一片连续的内存空间，每个数组元素都对应一块独立的内存空间，它们都有相应的地址。
因此，指针变量既然可以指向变量，也就可以指向数组元素
   数组的构成本质上是：数组名[偏移量]
  数组名就代表第一个元素的地址，偏移量就是在此根本上偏移
  数组的元素本质上完全可以当做是单独的变量对待，只不过没闻名称而已

1. int a[5]={1,2,3,4,5}; //定义长度为5的int数组
2. int *p_a=&a[0]; //定义指向int变量的指针变量p_a，把a数组第0个元素地址赋给指针变量p_a

复制代码

留意：&a[0]等价于&(a[0])，由于[ ]运算符比取地址运算符&优先级高，因此&(a[0])中的小括号可以省略，简写为：&a[0]

在计算机中内存的最小单元是字节，每个字节都对应一个地址
如果一个变量占用多个字节，就会占用 多个内存地址
比方: char 类型变量占1字节就对应1个地址，short 类型变量占2字节对应2个地址，int 类型变量占4 字节对应4个地址.....·其他类型依次类推
同理，数组元素类型不同占用的内存地址也不同
下面通过例子来验证以上分析

1. #include<stdio.h>
2. int main(void)
3. {
4.         char c[5];
5.         short s[5];
6.         int i;
7.         for (i = 0; i < 5; i++)
8.         {
9.                 printf("&c[%d]=%p ", i, &c[i]);
10.                 printf("&s[%d]=%p \n", i, &s[i]);
11.         }
12.         return 0;
13. }

复制代码

  运行结果：
  &c[0]=000000000061FE17 &s[0]=000000000061FE0C
  &c[1]=000000000061FE18 &s[1]=000000000061FE0E
  &c[2]=000000000061FE19 &s[2]=000000000061FE10
  &c[3]=000000000061FE1A &s[3]=000000000061FE12
  &c[4]=000000000061FE1B &s[4]=000000000061FE14
  说明：不同设备上面输出的地址大概不一样的，数组中每个元素地址都是连续的

---

6.2 指针加减运算（了解）

6.2.1 指针加减具体数字 

指针本质上就是内存地址，在32 位操作体系下，内存地址是 4 字节的整数。既然是整数就可以进行 加、减、乘、除等算术运算。不过必要留意的是，在 C 语言中一般只讨论指针加、减运算，乘、除等其 他算术运算都没故意义
   在实际开发中，指针加、减运算多用于数组(或连续内存空间)。当指针变量p 指向数组元素时，p+1 表 示指向下一个数组元素，p-1 表示指向上一个数组元素

1. #include <stdio.h>
2. int main(void)
3. {
4.         int a[3] = { 1, 2, 3 };
5.         int* p = &a[0];// 指针 p 指向 a[0]
6.         printf("%p %d\n", p, *p); // 输出 a[0] 的地址 和 a[0] 的值
7.        
8.         p = p + 1;// p 加 1
9.         printf("%p %d\n", p, *p); // 输出 a[1] 的地址 和 a[1] 的值
10.         return 0;
11. }

复制代码

  运行结果：
  000000811557F968 1
000000811557F96C 2
  留意：实现指针加减的时候必要留意越界题目

---

6.2.2 指针加减指针

在C语言中，两个指针相加是没故意义的，而两个指针相减却有特别的意义，不过只有当两个指针都指向同一数组中的元素时才故意义
   一个数组中的元素时，对它们进行减法运算，得到的结果是这两个指针所指向元素之间相隔的元素个数 (不是之间有的个数，之间有的元素数要在此根本上减一)，而不是它们地址差值的字节数。其计算方式是用两个指针的地址差值除以指针所指向数据类型的巨细
  用公式表示为：(指针2的地址 - 指针1的地址) / sizeof(指针所指向的数据类型)
  

---

6.3 数组名与数组元素首地址的关系

C语言中，数组名与数组首元素地址等价。也就是说，在步伐中，输出数组名与输出数组首元素地址是相同的

1. #include <stdio.h>
2. int main(void)
3. {
4.     int num[5];
5.     printf("%p\n", num);     // 输出数组名
6.     printf("%p\n", &num[0]); // 输出数组首元素地址
7.     return 0;
8. }

复制代码

  输出结果：
  000000000061FE00
  000000000061FE00
  我们就可以通过把数组名复制给指针变量，来把数组首地址给指针变量

1. #include <stdio.h>
2. int main(void)
3. {
4.     int num[5] = {1, 2, 3, 4, 5};
5.     int *p_num = num; // 把num的首地址赋值给指针变量
6.     printf("p_num指针的值=%p \n p_num对应数组元素的值%d", p_num, *p_num);
7.     return 0;
8. }

复制代码

我们也可以通过p_num来访问数组里面的每个元素

1. #include <stdio.h>
2. int main(void)
3. {
4.     int num[5] = {1, 2, 3, 4, 5};
5.     int *p_num = num; // 把num的首地址赋值给指针变量
6.     printf("p_num指针的值=%p ，num的地址是=%p  p_num对应数组元素的值%d\n", p_num, num,
7. *p_num);
8.     printf("p_num访问第一个元素=%d\n", p_num[0]);
9.     printf("p_num访问第二个元素=%d\n", p_num[1]);
10.     return 0;
11. }

复制代码

  运行结果：
  p_num指针的值=000000000061FE00 ，num的地址是=000000000061FE00  p_num对应数组元素的值1
  p_num访问第一个元素=1 p_num访问第二个元素=2
  

---

6.4 数组作为函数参数

函数参数不仅可以是变量，也可以是数组，数组作函数参数的作用是将数组首元素地址传给函数作形参。 在 C 语言中，数组作函数参数时，是没有副本机制的，只能传递地址。也可以认为，数组作函数参数时，会退化为指针

1. #include <stdio.h>
2. void getSize(int nums[10]) // 定义 getSize 函数
3. {
4.         int size = sizeof(nums); // 计算数组 nums 的总字节数
5.         printf("指针 size=%d\n", size);
6. }
7. int main(void)
8. {
9.         int nums[10] = { 1, 2, 3, 4, 5 };
10.         int size = sizeof(nums); // 计算数组 nums 的总字节数
11.         printf("外部 size=%d\n", size);
12.         getSize(nums); // 调用 getSize 函数
13.         return 0;
14. }

复制代码

   运行结果：
  外部 size=40
  指针 size=8
  所以直接把函数的形参的类型设置为指针，来吸取数组的第一个地址： 

1. #include <stdio.h>
2. void getSize(int* nums) // 定义 getSize 函数
3. {
4.         int size = sizeof(nums); // 计算数组 nums 的总字节数
5.         printf("指针 size=%d\n", size);
6. }
7. int main(void)
8. {
9.         int nums[10] = { 1, 2, 3, 4, 5 };
10.         int size = sizeof(nums); // 计算数组 nums 的总字节数
11.         printf("外部 size=%d\n", size);
12.         getSize(nums); // 调用 getSize 函数
13.         return 0;
14. }

复制代码

  运行结果：
  外部 size=40
  指针 size=8
    分析：
  32位体系中指针变量占4个字节，64位体系中指针变量占8个字节，所以getSize中num的字节数是8。在 C 语言中，数组作函数参数时，是没有副本机制的，只能传递地址，所以 的形参 int *nums应该是指针变量， void getSize方法 getSize(nums) 传入的nums并不是数组的副本，而是数组首元素的地址 
  留意：因为没有副本机制，所以如果在函数内部修改数组内容，数组的内容会直接被修改，而不是修改副本

1. #include <stdio.h>
2. void getSize(int* nums) // 定义 getSize 函数
3. {
4.         nums[0] = 3;
5. }
6. int main(void)
7. {
8.         int nums[10] = { 1, 2, 3, 4, 5 };
9.         printf("%d\n", nums[0]);    //加\n是为了换行
10.         getSize(nums); // 调用 getSize 函数
11.         printf("%d", nums[0]);
12.         return 0;
13. }

复制代码

练习：封装比力数组最大值函数

1. #include <stdio.h>
2. int getMax(int* nums, int length) // 定义函数 getMax
3. {
4.         int i;
5.         int max = nums[0]; // 默认 nums[0] 为最大值
6.         for (i = 1; i < length; i++) // 下标从 1 开始遍历
7.         {
8.                 if (max < nums[i]) // 比较大小
9.                 {
10.                         max = nums[i]; // 覆盖最大值
11.                 }
12.         }
13.         return max; // 返回最大值
14. }
17. int main(void)
18. {
19.         int nums[10] = { 11, 22, 3, 24, 15, 8, 99, 21, 35, 0 };
20.         int length = sizeof(nums) / sizeof(nums[0]); // 计算数组长度
21.         int max = getMax(nums, length); // 返回最大值
22.         printf(" 最大值为 :%d\n", max);
23.         return 0;
24. }

复制代码

---

7 二维数组以及字符串与指针

7.1 二维数组的定义方法

C语言中二维数组和一维数组类似，简单明白就是：二维数组由多个一维数组构成
7.1.1 定义一个二维数组 

1. type arrayName[x][y];

复制代码

例：

1. int a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};

复制代码

内部嵌套的括号是可选的，下面的初始化与上面是等同的：

1. int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

复制代码

---

7.1.2 访问二维数组

1. #include <stdio.h>
2. #include <string.h>
3. void main(void)
4. {
5.         int a[3][4] = { {1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23} };
6.         printf("a[0][2]=%d", a[0][2]);
7. }

复制代码

  运行代码：
  a[0][2]=5
  

---

7.2 定义字符串的几种方法

我们已经学习的定义方法：

1. #include <stdio.h>
2. int main(void)
3. {
4.         char chs1[] = { 'i', 't', 'y', 'i', 'n', 'g', '\0' };
5.         char chs2[] = "itying";
6.         printf("%s\n", chs1);// 以 %s 格式输出 str
7.         printf("%c\n", chs1[2]); // 以 %c 格式输出一个字符
8.         printf("%s\n", chs2);  // 以 %s 格式输出 str
9.         printf("%c", chs2[2]); // 以 %c 格式输出一个字符
10.         return 0;
11. }

复制代码

我们也可以利用字符指针引用字符串：

1. #include <stdio.h>
2. int main(void)
3. {
4.         char chs1[] = "itying";
5.         char* str1 = chs1;
6.         printf("%s\n", str1);  // 以 %s 格式输出 str
7.         printf("%c\n", str1[2]);   // 以 %c 格式输出一个字符
8. //---------------------------------------------------------------------------
9.         char* str2 = "this is str";
10.         printf("%s\n", str2);  // 以 %s 格式输出 str
11.         printf("%c\n", str2[2]); // 以 %c 格式输出一个字符
12.         return 0;
13. }

复制代码

通过上面示例我们可以通过三种方法定义字符串了

1. char chs1[] = {'i', 't', 'y', 'i', 'n', 'g', '\0'};
2. char chs2[] = "itying";
3. char *chs3 = "itying";

复制代码

---

7.3 字符串数组

定义了一个指针数组，即数组中的每个元素都是一个 char 类型的指针：

1. char *arr[] 

复制代码

例：

1. char *s[]={ "马总", "张总", "王麻子" };

复制代码

当利用 { "马总", "张总", "王麻子" } 对这个数组进行初始化时，会把每个字符串常量的首字符地址分别赋给数组 arr 的各个元素：
   

• arr[0] 被赋值为字符串 "马总" 的首字符地址，通过这个指针，就可以访问该字符串的所有字符
  
• arr[1] 被赋值为字符串 "张总" 的首字符地址
  
• arr[2] 被赋值为字符串 "王麻子" 的首字符地址
  

   在实际处理中文时，通常会利用多字节字符编码，好比常见的 UTF - 8 编码或 GBK 编码
UTF - 8 是一种变长编码，一个中笔墨符通常用 3 个字节来表示。对于字符串 "张总"，“张” 字在 UTF - 8 编码下会占用 3 个字节的存储空间，arr[1] 指向的就是这 3 个字节中第一个字节的存储地址

---

7.4 strcat 毗连字符串

前面我们已经学习了 strlen 计算字符串数组有用长度、sprintf 字符串格式化函数、字符串拼接、整型转换成字符串等字符串知识，详细见【C语言】第七期——字符数组、字符串、类型转换
现在我们继承学习相关知识
原型：

1. char *strcat(char *dest, const char *src);    //使用前需先引入头文件<string.h>

复制代码

参数：
   

• dest：目标字符串的指针，拼接后的结果将存储在这个字符串中。dest 必须有足够的空间来容纳 src 字符串的内容以及拼接后的结果
  
• src：源字符串的指针，它将被追加到 dest 字符串的末了。src 字符串本身不会被修改
  

  返回值：
   函数返回一个指向目标字符串 dest 的指针
  工作原理：
   strcat 函数会从 dest 字符串的第一个空字符 '\0' 开始，将 src 字符串的内容复制到 dest 的末了，直到遇到 src 字符串的空字符 '\0' 为止，最后，dest 字符串会以空字符 '\0' 结尾

1. #include <stdio.h>
2. #include <string.h>
4. int main() {
5.     // 定义目标字符串和源字符串
6.     char dest[50] = "Hello, ";
7.     const char src[] = "World!";
9.     // 使用 strcat 函数将 src 追加到 dest 的末尾
10.     strcat(dest, src);
12.     // 输出结果
13.     printf("拼接后的字符串: %s\n", dest);
15.     return 0;
16. }

复制代码

留意事项：
   

• 内存空间：dest 数组必须有足够的空间来容纳 src 字符串的内容，否则会导致缓冲区溢出，这大概会引发步伐崩溃或安全漏洞
  
• 空字符：dest 字符串必须以空字符 '\0' 结尾，否则 strcat 函数无法确定从哪里开始追加
  
• 字符串重叠：dest 和 src 所指向的字符串不能重叠，否则会导致未定义举动
  

  

---

7.5 strcpy 字符串复制（拷贝）函数

原型：

1. char *strcpy(char *dest, const char *src);

复制代码

参数：
   

• dest：指向目标字符数组的指针，用于存储复制后的字符串。目标数组必须有足够的空间来容纳源字符串及其终止的空字符 '\0'
  
• src：指向源字符串的指针，即要被复制的字符串。该参数被声明为 const，表示在函数内部不会修改源字符串
  

  返回值：
   strcpy 函数返回指向目标字符数组 dest 的指针
  工作原理：
   strcpy 函数会将 src 指向的字符串（包括终止的空字符 '\0'）复制到 dest 指向的字符数组中
  复制过程会一直进行，直到遇到源字符串的终止空字符 '\0'，并将该空字符也复制到目标数组中

1. #include <stdio.h>
2. #include <string.h>
4. int main() {
5.     // 定义源字符串
6.     char src[] = "Hello, World!";
7.     // 定义目标字符数组，确保有足够的空间
8.     char dest[20];
10.     // 使用 strcpy 函数复制字符串
11.     strcpy(dest, src);
13.     // 输出复制后的字符串
14.     printf("Copied string: %s\n", dest);
16.     return 0;
17. }

复制代码

留意事项：
   

• 缓冲区溢出风险：利用 strcpy 时必要确保目标数组有足够的空间来容纳源字符串及其终止空字符，否则大概会导致缓冲区溢出，引发未定义举动，为了制止这种风险，可以利用更安全的 strncpy 函数
  
• 目标数组的初始化：在利用 strcpy 之前，不必要对目标数组进行初始化，因为 strcpy 会覆盖目标数组中的原有内容
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。