IT评测·应用市场-qidao123.com

标题: 前端学习C语言 - 初级指针 [打印本页]
作者: 杀鸡焉用牛刀    时间: 2023-6-25 18:57
标题: 前端学习C语言 - 初级指针
初级指针

本篇主要介绍：指针和变量的关系、指针类型、指针的运算符、空指针和野指针、指针和数组、指针和字符串、const 和指针、以及gdb 调试段错误。
基础概念

指针是一种特殊的变量。存放地址的变量就是指针。
int num = 1; 会申请4个字节的内存来存放数字1，每次访问 num 就是访问这4个字节。
访问内存中的这4个字节，不仅可以通过名称（例如 num），还可以通过地址。
Tip：& 不仅是位运算符，还是取地址操作符。例如 int* ptr = #，就是取变量 num 的地址并将其保存到指针变量 ptr 中
请看示例：
  1. #include <stdio.h>
  3. int main() {
  4.     int num = 10;
  6.     // num 的地址：0x7fff4dbf01d8
  7.     printf("num 的地址：%p\n", &num);
  8.     // num 的地址加1 ：0x7fff4dbf01dc。
  9.     printf("num 的地址加1 ：%p\n", &num + 1);
  11.     // j 存放连续内存的第一个字节地址
  12.     int *j = &num;
  14.     // 10。通过地址访问
  15.     printf("%d", *j);
  17.     return 0;
  18. }
复制代码
&num 和 &num + 1 相差4个字节，说明 &num 表示整数。
普通变量存放值，而指针用于存放地址。
通过 int *j = &num 将变量num的首地址给到指针 j(j的类型是 int *)，最后通过地址(*j) 访问整数1。
int *j 是一个int类型的指针，还有 char、float等指针类型。指针类型必须匹配，比如将 j 的指针类型换成 char，则会警告。就像这样：
  1. - int *j = &num;
  2. + char *j = &num;
复制代码
运行：
  1. /workspace/CProject-test/main.c:12:11: warning: incompatible pointer types initializing 'char *' with an expression of type 'int *' [-Wincompatible-pointer-types]
  2.     char *j = &num;
  3.           ^   ~~~~
  4. 1 warning generated.
  5. num 的地址：0x7ffddcfe5328
  6. num 的地址加1 ：0x7ffddcfe532c
  7. 10
复制代码
Tip: 指针 j 也有地址，也就是指针的指针。现在不研究
练习

题目：请问输出什么？
  1. #include <stdio.h>
  3. int main() {
  4.     int num = 10;
  5.     int *p = &num;
  6.     printf("用指针访问数据 num :%d\n", *p);
  8.     *p = 11;
  9.     printf("用过指针修改 num 数据:%d\n", num);
  11.     return 0;
  12. }
复制代码
提示：数据可以通过变量访问，也能使用地址（指针）访问。就像通知同学去嵌入式实验室上课，或者是 303 上课。其中*p = 11; 等价于 num = 11;
输出：
  1. 用指针访问数据 num :10
  2. 用过指针修改 num 数据:11
复制代码
星号的作用

指针 * 有两个主要作用（根据* 前面有无类型做区分）：
请看示例：
  1. #include <stdio.h>
  3. int main() {
  4.     int num = 10;
  5.     // 指针类型声明
  6.     int *p = &num;
  8.     // 取值
  9.     printf("%d\n", *p); // 10
  11.     // 取值
  12.     *p = 11;
  13.     printf("%d\n", num); // 11
  15.     return 0;
  16. }
复制代码
指针类型

所占字节

在32位系统上，指针通常占用4个字节；而在64位系统上，指针通常占用8个字节。请看示例：
  1. #include <stdio.h>
  3. int main() {
  4.     printf("char类型指针所占字节数为：%zu\n", sizeof(char*));
  5.     printf("short类型指针所占字节数为：%zu\n", sizeof(short*));
  6.     printf("int类型指针所占字节数为：%zu\n", sizeof(int*));
  7.     printf("long类型指针所占字节数为：%zu\n", sizeof(long*));
  8.     printf("float类型指针所占字节数为：%zu\n", sizeof(float*));
  9.     printf("double类型指针所占字节数为：%zu\n", sizeof(double*));
  10.     printf("long long类型指针所占字节数为：%zu\n", sizeof(long long*));
  11.     return 0;
  12. }
复制代码
输出：
  1. char类型指针所占字节数为：8
  2. short类型指针所占字节数为：8
  3. int类型指针所占字节数为：8
  4. long类型指针所占字节数为：8
  5. float类型指针所占字节数为：8
  6. double类型指针所占字节数为：8
  7. long long类型指针所占字节数为：8
复制代码
练习

题目：请问整数类型的指针和字符类型的指针加1分别是几个字节？
  1. #include <stdio.h>
  3. int main() {
  4.     int num = 10;
  6.     printf("num 的地址：%p\n", &num);
  7.     printf("num 的地址加1 ：%p\n", &num + 1);
  9.     char ch = 'a';
  11.     printf("ch 的地址：%p\n", &ch);
  12.     printf("ch 的地址加1 ：%p\n", &ch + 1);
  13.     return 0;
  14. }
复制代码
输出：
  1. num 的地址：0x7fffe8244288
  2. num 的地址加1 ：0x7fffe824428c
  3. ch 的地址：0x7fffe8244287
  4. ch 的地址加1 ：0x7fffe8244288
复制代码
答案：int * 加1是4个字节；char * 加1是1个字节。&num 和 &ch 分别代表该变量的全部字节。
指针交换数据

比如这段代码是不能实现 a、b 两数交换。请看示例：
  1. #include <stdio.h>
  3. void swap(x, y){
  4.     int tmp = x;
  5.     x = y;
  6.     y = tmp;
  7. }
  8. int main() {
  9.     int a = 1;
  10.     int b = 2;
  11.     swap(a, b);
  12.     printf("a：%d\n", a);
  13.     printf("b：%d\n", b);
  14.     return 0;
  15. }
复制代码
  1. a：1
  2. b：2
复制代码
分析：调用 swap(a, b) 这里是一个值传递，找到函数入口地址，对参数 x、y 申请空间和赋值，通过 tmp 变量完成了 x和y的交换，最后回收局部变量 x、y和tmp，释放空间。而 a,b数据没有变化。
可以通过指针来实现两数的交换。请看示例：
  1. #include <stdio.h>
  3. void swap(int* x, int* y){
  4.     int tmp = *x;
  5.     *x = *y;
  6.     *y = tmp;
  7. }
  8. int main() {
  9.     int a = 1;
  10.     int b = 2;
  11.     swap(&a, &b);
  12.     printf("a：%d\n", a);
  13.     printf("b：%d\n", b);
  14.     return 0;
  15. }
复制代码
  1. a：2
  2. b：1
复制代码
分析：通过 swap(&a, &b) 将 a b 的地址传给 x 和 y，通过 x 和 y 指针对 a 和 b 进行交换，虽然最后会销毁swap中的局部变量，但 a 和 b的值已经完成了交换。
指针的运算符

指针和变量的关系
练习1

题目：输出什么？
  1. #include <stdio.h>
  3. int main() {
  4.     int a = 10, *pa = &a, *pb;
  5.     printf("%d\n", *pa);
  6.     pb = pa;
  7.     printf("%d\n", *pb);
  8.     return 0;
  9. }
复制代码
输出：10 10
分析：
  1. int a = 10,
  2. // pa 指向变量 a
  3. *pa = &a,
  4. // 定义一个整数型的指针 pb
  5. *pb;
  6. printf("%d\n", *pa);
  8. // pb 也指向变量 a
  9. pb = pa;
  10. printf("%d\n", *pb);
  11. return 0;
复制代码
练习2

题目：输出什么？
  1. #include <stdio.h>
  3. int main() {
  4.     int x = 3, y = 0, *px = &x;
  6.     y = *px + 5;
  7.     printf("%d\n", y);
  9.     y= ++*px;
  10.     printf("%d\n", y);
  12.     printf("%p\n", px);
  14.     y = *px++;
  15.     printf("%p\n", px);
  16.     printf("%d\n", y);
  18.     return 0;
  19. }
复制代码
输出：
  1. 8
  2. 4
  3. 0x7ffc48b9be38
  4. 0x7ffc48b9be3c
  5. 4
复制代码
分析：
  1. 类似 y = ++i，等于先执行 ++，在执行 y = i，
  2. 这里先对 (*px) 执行 ++，在返回  *px 的值
复制代码
  1. 先执行 y = *px，然后是 px++。px是整数类型的地址，加1就是加4个字节。
复制代码
练习3

题目：输出什么？
  1. #include <stdio.h>
  3. int main() {
  4.     int x = 3, y = 0, *px = &x;
  5.     printf("%p\n", px);
  6.     y = (*px)++;
  7.     printf("%p\n", px);
  8.     printf("%d\n", x);
  10.     return 0;
  11. }
复制代码
输出：
  1. 0x7ffef1dc4d58
  2. 0x7ffef1dc4d58
  3. 4
复制代码
分析：*px++ 表示指针加1，(*px)++ 表示值加1。
指针初始化

指针初始化有两种方法：已经存在的空间和自己申请空间。
已经存在的空间，例如：
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int main() {
  4.     int num;
  5.     int* p = &num;
  6.     *p = 10;
  8.     char *str = "abc";
  9.     printf("%s\n", str); // abc。把字符串的地址赋值给指针变量
  10.     return 0;
  11. }
复制代码
自己申请空间可以使用 malloc 函数。申请的是 void 类型指针，也称为通用类型指针。请看示例：
  1. #include <stdio.h>
  2. // malloc 需要引入 <stdlib.h>
  3. #include <stdlib.h>
  4. int main() {
  5.     // 申请16个字节
  6.     int* q = malloc(sizeof(int) * 4); // 在堆里申请了16个字节
  7.     // int* q = (int *)malloc(sizeof(int) * 4); // 推荐
  8.    
  9.     *q = 10;
  10.     // 释放申请的16个字节
  11.     free(q);
  12.     return 0;
  13. }
复制代码
申请空间，使用完需要使用 free() 释放。
Tip：根据 C99 标准以及更高版本的标准，显式的类型转换是建议的做法，以确保类型的安全性和可读性。
空指针和野指针

下面这段代码 p 就是一个野指针，运行报错：段错误 (核心已转储)：
  1. #include <stdio.h>
  3. int main() {
  4.     int* p;
  5.     *p = 1;
  6.     return 0;
  7. }
复制代码
这里声明一个指针 p，里面是一个随机数，例如 0x7ffe71df3f40，接着往指向的内存放1，由于这块内存不知道是否存在，即使存在也不能访问，于是报段错误。
直接手写一个地址也不可以。就像这样：
  1. #include <stdio.h>
  3. int main() {
  4.    
  5.     // warning: incompatible integer to pointer conversion initializing 'int *' with an expression of type 'long' [-Wint-conversion]
  6.     // 这个警告是因为你正在将一个 long 类型的表达式赋值给一个 int* 类型的指针变量，导致类型不匹配。
  7.     // int* p = 0x7ffe71df3f40;
  8.     int* p = (int *)0x7ffe71df3f40;
  9.     *p = 100;
  10.     return 0;
  11. }
复制代码
  1. // 分段错误 (核心已转储)"
  2. Segmentation fault (core dumped)
复制代码
空指针也不能使用：
  1. int* p = NULL;
  2. *p = 100;
  4. // 输出：`Segmentation fault (core dumped)`
复制代码
但空指针会让你可控。就像这样：
  1. int* p = NULL;
  3. if (p != NULL) {
  4.     printf("p is not NULL\n");
  5. }else{
  6.     printf("p is NULL\n");
  7. }
  9. // 输出：p is NULL
复制代码
指针和数组

指针当数组用
遍历一个数组，可以这样：
  1. #include <stdio.h>
  3. int main() {
  4.     int arr[] = {1, 2, 3, 4, 5};
  5.     int length = sizeof(arr) / sizeof(arr[0]);  // 计算数组的长度
  6.     // 1 2 3 4 5
  7.     for (int i = 0; i < length; ++i) {
  8.         printf("%d ", arr[i]);
  9.     }
  11.     return 0;
  12. }
复制代码
使用指针遍历数组有两种方式（效果相同）。请看示例：
  1. #include <stdio.h>
  3. int main() {
  4.     int arr[] = {1, 2, 3, 4, 5};
  5.     int length = sizeof(arr) / sizeof(arr[0]);  // 计算数组的长度
  7.     // 指针遍历方式1
  8.     /*
  9.     int* pArr = arr;
  10.     for (int i = 0; i < length; ++i) {
  11.         printf("%d ", *(pArr + i));
  12.     }
  13.     */
  15.     // 指针遍历方式2
  16.     int* pArr = arr;
  17.     for (int i = 0; i < length; ++i) {
  18.         printf("%d ", pArr[i]);
  19.     }
  21.     return 0;
  22. }
复制代码
Tip：在数组一文中我们知道数组名表示首元素地址，这里*(pArr + i)会依次遍历数组或许是因为指针是int类型吧！
总结：pArr 等于 *(pArr + i)。在这里[]不再是取某个索引，而是表示取值。
指针和字符数组

题目：分析 char a[] = "Hello"; 和 char *b = "World";
  1. #include <stdio.h>
  3. int main() {
  4.     char a[] = "Hello";
  5.     char *b = "World";
  7.     // Iterating over 'a'
  8.     printf("Characters in 'a':\n");
  9.     for (int i = 0; a[i] != '\0'; i++) {
  10.         printf("%c\n", a[i]);
  11.     }
  13.     // Iterating over 'b'
  14.     printf("\nCharacters in 'b':\n");
  15.     for (int i = 0; b[i] != '\0'; i++) {
  16.         printf("%c\n", b[i]);
  17.     }
  19.     return 0;
  20. }
复制代码
输出：
  1. 开始运行...
  3. Characters in 'a':
  4. H
  5. e
  6. l
  7. l
  8. o
  10. Characters in 'b':
  11. W
  12. o
  13. r
  14. l
  15. d
  17. 运行结束。
复制代码
练习

题目：下面代码中 p1[0]、p2[0]、p3[0]的值分别是多少？
  1. // 申请4*4个字节，每个字节地址假如是:0x100（存放1） 0x104（存放2） 0x108 0x10c
  2. int a[] = {1,2,3,4};
  4. int *p1 = (int*)(&a + 1);
  6. int *p2 = (int*)((int)a + 1);
  8. int *p3 = (int*)(a + 1);
复制代码
分析：
结论：只有p3[0]（等价于 *(p3 + 0)）是一个正常的元素，也就是2.
指针和字符串

题目：用数组和指针定义字符串有什么区别？
  1. #include <stdio.h>
  3. int main() {
  4.     char str[] = "HelloWorld";
  5.     // HelloWorld
  6.     printf("%s\n", str);
  8.     char* s = "HelloWorld";
  9.     // HelloWorld
  10.     printf("%s\n", s);
  12.     return 0;
  13. }
复制代码
Tip: 字符串的输出都是首地址，比如这里的 str 是数组的首地址，s 指针指向的也是首地址。
分析：
char str[] = "HelloWorld"; 在栈中定义一个数组，用11个字节存储HelloWorld（还有一个 \0）。请看示例：
  1. #include <stdio.h>
  3. int main() {
  4.     char str[] = "HelloWorld";
  5.     str[0]++;
  6.     // IelloWorld
  7.     printf("%s\n", str);
  8.     // error: cannot increment value of type 'char[11]'
  9.     str++;
  10.     // printf("%s\n", str);
  11.     return 0;
  12. }
复制代码
数组名（str++）不可以修改，str 就是数组首元素地址，已经固定了，可认为它是常量。但数组内容可以修改。
char* s = "helloWorld"; 将 helloWorld 放在只读数据区，s 是局部变量，放在栈中，占8个字节。请看示例：
  1. #include <stdio.h>
  3. int main() {
  4.     char* s = "helloWorld";
  5.    
  6.     s++;
  7.     // elloWorld
  8.     printf("%s\n", s);
  10.     // 报错：Segmentation fault (core dumped)
  11.     s[0]++;
  13.     return 0;
  14. }
复制代码
指针可以加加，但指针指向的内容不能修改。
str 只是个名字，不占空间，如果一定要说占多少，那就是它执行的数组占11个字节。而 s 是8个字节，指向一个只读区，占 11 个字节。
练习

题目：分析以下示例。
  1. #include <stdio.h>
  3. int main() {
  4.     char str[20];
  5.     str = "HelloWorld";
  7.     char* s;
  8.     s = "HelloWorld";
  9.     // HelloWorld
  10.     printf("%s\n", s);
  12.     return 0;
  13. }
复制代码
分析：
  1. // 分配20个字节的内存，并把首地址给 str
  2. char str[20];
  3. // str 是只读的，不能再赋值。报错：`error: array type 'char[20]' is not assignable`
  4. str = "HelloWorld";
  6. // 定义一个指针 s
  7. char* s;
  8. // 将 HelloWorld 的首地址给 s
  9. s = "HelloWorld";
复制代码
扩展

自定义strcpy()函数

题目：实现原生字符串拷贝方法strcpy。strcpy 其用法如下：
  1. #include <stdio.h>
  2. #include <string.h>
  4. int main() {
  5.     char source[] = "Hello";
  6.     char destination[10]; // 目标字符串需要足够的空间来容纳 source 字符串
  8.     strcpy(destination, source);
  10.     printf("Source string: %s\n", source);
  11.     printf("Destination string: %s\n", destination);
  13.     return 0;
  14. }
复制代码
实现：
  1. #include <stdio.h>
  3. char* strcpy_custom(char* destination, const char* source) {
  4.     // 字符串数组末尾有一个特殊的空字符 '\0' 来表示字符串的结束。逐个复制字符，直到遇到源字符串的结束标志 '\0'
  5.     while (*source != '\0') {
  6.         *destination = *source;
  7.         destination++;
  8.         source++;
  9.     }
  11.     *destination = '\0'; // 在目标字符串末尾添加结束标志 '\0'
  13.     return destination;
  14. }
  16. int main() {
  17.     // 定义两个字符数组
  18.     char source[] = "Hello";
  19.     char destination[10]; // 目标字符串需要足够的空间来容纳 source 字符串
  21.     // 数组名。表示首元素的地址，加 1 是加一个元素（比如这里1个字节）
  22.     strcpy_custom(destination, source);
  24.     printf("Source string: %s\n", source);
  25.     printf("Destination string: %s\n", destination);
  27.     return 0;
  28. }
复制代码
Tip：const char* source 中 const 的作用请看const 和指针
输出：
  1. 开始运行...
  3. Source string: Hello
  4. Destination string: Hello
  6. 运行结束。
复制代码
将 while 替换成下面一行代码效果也相同：
  1. char* strcpy_custom(char* destination, const char* source) {
  2.     /*
  3.     while (*source != '\0') {
  4.         *destination = *source;
  5.         destination++;
  6.         source++;
  7.     }
  9.     *destination = '\0';
  10.     */
  12.     // 替换成
  13.     while((*destination++ = *source++) != '\0');
  14.     return destination;
  15. }
复制代码
分析：(*destination++ = *source++) != '\0':
  1. 之前的是首先判断，在赋值。`*source != '\0'`、`*destination = '\0';`，这里是先赋值
  3. 后置++会放在表达式最后，所以等于：
  5. (*destination = *source) != '\0';
  6. destination++;
  7. source++;
复制代码
const 和指针

首先补充下(int*)的作用。之前说到 const 定义的变量可以被修改，我们写了如下代码：
  1. #include <stdio.h>
  3. int main() {
  4.     const int val =5;
  6.     int *ptr= (int*)&val;
  7.     *ptr=10;
  9.     printf("val = %d\n",val);
  10.     printf("*ptr = %d\n", *ptr);
  12.     return 0;
  13. }
复制代码
其中 int *ptr= (int*)&val; 是将一个 const int 类型的变量 val 地址强制转换为 int* 类型的指针，并将指针存储在 ptr 中。这种类型转换是不安全的，因为它丢失了 val 的常量性质。
const char* source 声明一个常量指针，以下代码仅做示意：
  1. #include <stdio.h>
  3. int main() {
  4.     const char* source = "Hello";
  5.     char* mutableSource = "World";
  7.     printf("%c\n", source[0]);
  8.     printf("%c\n", mutableSource[0]);
  10.     // 以下操作是非法的，会导致编译错误
  11.     // source[0] = 'h'; // 不能修改字符数据
  13.     // 合法
  14.     // 尽管mutableSource是一个非常量指针，看起来可以进行修改，但修改字符串常量是不被允许的，并且这可能导致未定义行为。
  15.     mutableSource[4] = 'w'; // 可以修改字符数据
  16.     return 0;
  17. }
复制代码
运行：
  1. 开始运行...
  3. H
  4. W
  5. Segmentation fault (core dumped)
  7. 运行结束。
复制代码
就近原则

const 有个就近原则：
请看示例：
  1. #include <stdio.h>
  3. int main() {
  4.     int num = 1;
  5.     const int* p1 = &num; // const 修饰的是 *，所以 *p1 不能修改, p1 可以修改
  7.     p1++;
  8.     // (*p1)++;
  10.     int* const p2 = &num; // const 修饰 p2，所以 p2 不能修改，*p2 可以修改
  12.     // p2++;
  13.     (*p2)++;
  15.     const int* const p3 = &num; // 两个都不能修改
  16.     // p3++;
  17.     // (*p3)++;
  19.     return 0;
  20. }
复制代码
gdb 调试段错误

GDB（GNU Debugger）是一款强大的调试器，用于帮助开发者查找和解决程序中的错误。通过与源代码交互，并提供诸如断点设置、变量观察、内存检查等功能，GDB允许开发者逐行执行程序并分析其运行状态。
除了上文使用的 run，还有如下操作
使用 gdb 调试段错误的过程如下：
编写代码：
  1. pjl@pjl-pc:~/pjl$ cat demo-3.c#include <stdio.h>
  3. int main() {
  4.     int* p;
  5.     *p = 1;
  6.     return 0;
  7. }
复制代码
编译运行发现段错误：
  1. pjl@pjl-pc:~/pjl$ gcc demo-3.c -o demo-3
  2. pjl@pjl-pc:~/pjl$ ./demo-3
  3. 段错误 (核心已转储)
复制代码
将代码编译为可调试的可执行文件。在gcc或g++编译时，添加"-g"选项可以生成包含调试信息的可执行文件。
  1. // 增加 -g
  2. pjl@pjl-pc:~/pjl$ gcc demo-3.c -o demo-3 -g
  4. // 启动GDB并加载可执行文件
  5. pjl@pjl-pc:~/pjl$ gdb demo-3
  6. GNU gdb (Ubuntu 9.1-0kylin1) 9.1
  7. Copyright (C) 2020 Free Software Foundation, Inc.
  8. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
  9. This is free software: you are free to change and redistribute it.
  10. There is NO WARRANTY, to the extent permitted by law.
  11. Type "show copying" and "show warranty" for details.
  12. This GDB was configured as "x86_64-linux-gnu".
  13. Type "show configuration" for configuration details.
  14. For bug reporting instructions, please see:
  15. <http://www.gnu.org/software/gdb/bugs/>.
  16. Find the GDB manual and other documentation resources online at:
  17.     <http://www.gnu.org/software/gdb/documentation/>.
  19. For help, type "help".
  20. Type "apropos word" to search for commands related to "word"...
  21. Reading symbols from demo-3...
  23. (gdb)
复制代码
输入 run（还有其他操作） 找到是第5行代码报错：
  1. ...
  2. // run：运行程序。
  3. (gdb) run
  4. Starting program: /home/pjl/pjl/demo-3
  6. Program received signal SIGSEGV, Segmentation fault.
  7. 0x0000555555555135 in main () at demo-3.c:5
  8. 5           *p = 1;
  9. (gdb)
复制代码
高级指针

提前透露：指针遇上数组
题目：以下代码输出什么？
  1. #include <stdio.h>
  3. int main() {
  4.     char * string[] = {"Hello", "World" };
  5.     printf("%s\n", string);
  6.     return 0;
  7. }
复制代码
分析：
我们知道定义字符串有以下两种方法：
  1. char str[] = "HelloWorld";
  2. char* s = "HelloWorld";
复制代码
Tip: string 在 C 中不是关键字，也不是保留字，就是一个普通变量名。
[] 的优先级是非常高的，这里首先是定义一个数组(string[])，其次就是指针，合起来就是一个指针数组。
首先在只读区分配两块内存分别存放 Hello（地址比如是 0x100） 和 World（地址比如是 0x200），指针数组是16个字节，本质就是数组，只不过里面放的是指针，比如前8个字节的地址是0x1000，那么 string 就是 0x1000，因为数组名就是数组首元素地址。
所以要输出这两个字符串，可以这么写：
  1. #include <stdio.h>
  3. int main() {
  4.     char * string[] = {"Hello", "World" };
  6.     // Hello
  7.     printf("%s\n", string[0]);
  8.     // World
  9.     printf("%s\n", string[1]);
  10.     return 0;
  11. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4