C指针使用

指针的基本概念

指针是一个变量，其值为另一个变量的地址。在 C 语言中，通过使用取地址运算符&可以获取一个变量的地址，而通过指针变量可以存储和操作这些地址。例如：

1
2
int num = 10;
int *ptr = &num;

在上述代码中，num是一个整型变量，&num表示获取num的地址，ptr是一个指向整型的指针变量，它存储了num的地址。

指针的声明与初始化

声明指针变量：指针变量的声明形式为**数据类型 *指针变量名;**，其中数据类型表示指针所指向的数据类型，*表示这是一个指针变量。例如：

1
2
3
int *p;  // 声明一个指向整型的指针变量 p
float *q;  // 声明一个指向浮点型的指针变量 q
char *r;  // 声明一个指向字符型的指针变量 r

初始化指针变量：指针变量在使用之前必须进行初始化，使其指向一个有效的内存地址。可以在声明指针变量的同时进行初始化，也可以先声明后再进行赋值操作。例如：

1
2
3
4
5
6
int a = 5;
int *pa = &a;  // 在声明时初始化指针变量 pa，使其指向变量 a

int b = 10;
int *pb;
pb = &b;  // 先声明指针变量 pb，然后再将其赋值为变量 b 的地址

指针的操作

解引用指针：通过解引用指针，可以访问指针所指向的变量的值。解引用指针使用*运算符，例如：

1
2
3
int num = 20;
int *ptr = &num;
printf("%d\n", *ptr);  // 输出 20，通过解引用指针 ptr 访问到变量 num 的值

指针的算术运算：指针可以进行算术运算，但这种运算的意义与普通变量的算术运算不同。对于指针的算术运算，其结果与指针所指向的数据类型有关。例如，对于一个指向整型的指针p，p + 1表示将指针向后移动sizeof(int)个字节的地址，而对于一个指向字符型的指针q，q + 1表示将指针向后移动sizeof(char)个字节的地址。指针的算术运算通常用于遍历数组等数据结构。例如：
1 2 3
int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; // 指针 p 指向数组 arr 的首元素 printf("%d\n", *(p + 2)); // 输出 3，通过指针的算术运算访问数组中的元素

指针的比较运算：指针可以进行比较运算，通常用于判断两个指针是否指向同一个内存地址，或者判断一个指针是否指向某一特定的内存区域等。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
int a = 10, b = 20;
int *pa = &a, *pb = &b;
if (pa == pb) {
    printf("pa and pb point to the same memory location.\n");
} else {
    printf("pa and pb point to different memory locations.\n");
}

int arr[5] = {1, 2, 3, 4, 5};
int *p1 = arr;
int *p2 = &arr[3];
if (p1 < p2) {
    printf("p1 points to an earlier memory location than p2.\n");
}

指针与数组

在 C 语言中，数组名本身就是一个指针常量，它指向数组的首元素。因此，可以使用指针来访问和操作数组元素。例如：

1
2
3
4
5
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;  // 指针 p 指向数组 arr 的首元素
for (int i = 0; i < 5; i++) {
    printf("%d ", *(p + i));  // 通过指针访问数组元素
}

指针和数组在很多情况下可以相互替换使用，但需要注意它们之间的一些细微差别。例如，指针可以进行赋值操作，而数组名是一个常量指针，不能进行赋值操作。

指针与函数

指针可以作为函数的参数传递，使得函数能够直接操作外部变量的值，从而实现数据的双向传递。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

在上述代码中，swap函数接受两个指向整型的指针作为参数，通过解引用指针来交换两个变量的值。

函数也可以返回指针类型的值，但需要注意返回的指针必须指向有效的内存地址，否则可能会导致程序出现错误。

指针的高级应用

动态内存分配：C 语言中的动态内存分配函数malloc、calloc和realloc等返回的都是指针类型的值，通过这些指针可以操作动态分配的内存空间。例如：

1
2
3
4
5
6
7
int *p = (int *)malloc(sizeof(int) * 5);  // 动态分配 5 个整型元素的内存空间
if (p!= NULL) {
    for (int i = 0; i < 5; i++) {
        p[i] = i + 1;  // 通过指针访问动态分配的内存空间
    }
    free(p);  // 释放动态分配的内存空间
}

指针数组和数组指针：指针数组是一个数组，其元素为指针类型；而数组指针是一个指针，它指向一个数组。例如：

1
2
3
int *ptr_array[3];  // 指针数组，包含 3 个指向整型的指针元素
int arr[3][4];
int (*ptr_to_arr)[4] = arr;  // 数组指针，指向一个包含 4 个整型元素的一维数组

函数指针：函数指针是指向函数的指针变量，它可以存储函数的入口地址，并通过该指针来调用函数。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
int add(int a, int b) {
    return a + b;
}

int main() {
    int (*func_ptr)(int, int) = add;  // 函数指针，指向 add 函数
    int result = func_ptr(3, 5);
    printf("Result: %d\n", result);
    return 0;
}

指针的注意事项

指针必须先初始化后使用，否则可能会导致程序出现未定义行为。
避免指针越界访问，否则可能会导致程序崩溃或产生错误的结果。
在动态分配内存后，一定要记得及时释放内存，否则可能会导致内存泄漏问题。
注意指针的类型匹配，不同类型的指针之间不能随意赋值或进行算术运算等操作。

指针的基本概念#

指针的声明与初始化#

指针的操作#

指针与数组#

指针与函数#

指针的高级应用#

指针的注意事项#