详解C语言指针变量

郎哥
C语言
28天前
158热度
0评论

什么是C语言指针变量

C语言指针变量是一种特殊的变量，它存储的不是普通的数据值，而是内存地址。在计算机中，内存的每个存储单元都有一个唯一的地址，这个地址就是内存地址。指针变量存放的就是内存地址。

在 C 语言中，定义指针变量需要指定其类型，语法如下：

类型标识符 *指针变量名;

例如，要定义一个指向整型变量的指针变量，可以这样写：

int *p;

这里的int表示指针指向的变量类型是整型，*表示这是一个指针变量，p是指针变量的名字。

下面来看一个简单的例子，展示如何定义和使用指针变量：

#include <stdio.h>
int main() {
    int num = 10;  // 定义一个整型变量num，值为10
    int *p;        // 定义一个指向整型变量的指针变量p
    p = &num;      // 将num的地址赋给指针变量p，这里&是取地址运算符
    
    printf("num的值是：%d\n", num);
    printf("num的地址是：%p\n", &num);
    printf("指针变量p的值是：%p\n", p);
    printf("通过指针p访问的值是：%d\n", *p);  // *是取值运算符，通过指针p访问其指向的变量的值
    
    return 0;
}

在这个例子中，首先定义了一个整型变量num并初始化为 10，然后定义了一个指针变量p。通过p = #将num的地址赋给p，此时p就指向了num。接着，使用printf函数分别输出num的值、num的地址、指针变量p的值以及通过指针p访问到的值。

从这个例子可以看出，指针变量连接了变量的地址和变量的值，通过它可以间接地访问和操作变量。

指针变量的特点

指针变量与普通变量的区别

存储内容不同：指针变量存储的是数据的内存地址，普通变量存储的是数据内容；

访问方式不同：普通变量通过变量名可以直接访问数据，指针变量是间接访问，需要通过*运算符来进行；

声明方式不同：普通变量：类型变量名;，如int num；指针变量：类型 *指针变量名;如int *p;

赋值方式不同：普通变量：直接赋值，如num = 10; 指针变量：赋地址值，如p = #

下面通过一段代码示例来理解它们的区别：

#include <stdio.h>
int main() {
    int num = 10;  // 普通变量，存储整数10
    int *p;        // 指针变量，尚未指向任何地址
    
    p = &num;      // 将num的地址赋给指针变量p
    
    printf("普通变量num的值：%d\n", num);
    printf("指针变量p的值（即num的地址）：%p\n", p);
    printf("通过指针p访问的值：%d\n", *p);  // 通过解引用运算符*访问指针指向的值
    
    return 0;
}

从这个代码中可以看出，普通变量num直接存储了数据 10，而指针变量p存储的是num的地址。访问num的值直接使用num即可，而访问指针变量p指向的值则需要使用*p。

强大的灵活性

指针变量具有独特的灵活性，可以操作不同类型数据的。它可以指向多种数据类型，无论是整型、浮点型还是字符型等。例如：

#include <stdio.h>
int main() {
    int num = 10;
    float f = 3.14;
    char c = 'A';
    
    int *p1 = &num;
    float *p2 = &f;
    char *p3 = &c;
    
    printf("通过p1访问的值：%d\n", *p1);
    printf("通过p2访问的值：%f\n", *p2);
    printf("通过p3访问的值：%c\n", *p3);
    
    return 0;
}

在这段代码中，p1是指向整型变量num的指针，p2是指向浮点型变量f的指针，p3是指向字符型变量c的指针，通过它们可以分别访问对应类型的数据。
此外，指针变量还可以通过指针运算来移动指针的位置，从而访问不同位置的数据。例如，在数组中，指针可以方便地遍历数组元素。来看下面这个例子：

#include <stdio.h>
int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *p = arr;  // 指针p指向数组arr的首元素
    
    for (int i = 0; i < 5; i++) {
        printf("arr[%d]的值：%d\n", i, *p);
        p++;  // 指针p指向下一个元素
    }
    
    return 0;
}

在这个例子中，指针p首先指向数组arr的首元素，通过*p可以访问该元素的值。然后通过p++让指针p指向下一个元素，从而实现对数组元素的遍历。这种灵活性使得指针在处理数组、链表等数据结构时效率非常高。

指针变量的使用方法

基本操作

指针变量的基本操作主要涉及取地址运算符&和指针运算符*。取地址运算符&用于获取变量的内存地址，而指针运算符*则用于访问指针所指向的数据。例如：

#include <stdio.h>
int main() {
    int num = 10;
    int *p;
    
    p = &num;  // 使用取地址运算符&获取num的地址，并赋给指针变量p
    printf("num的地址是：%p\n", p);
    
    printf("通过指针p访问num的值是：%d\n", *p);  // 使用指针运算符*访问指针p指向的数据
    return 0;
}

在这段代码中，首先定义了一个整型变量num和一个指针变量p。然后通过p = #将num的地址赋给p，此时p就指向了num。接着，使用printf函数分别输出num的地址和通过指针p访问到的num的值。通过取地址运算符&和指针运算符*，可以在程序中灵活地操作变量的地址和数据。

操作数组

在 C 语言中，数组名可以看作是一个指向数组首元素的指针，这使得指针与数组之间建立了紧密的联系。利用指针可以更加高效地遍历数组。例如：

#include <stdio.h>
int main() {
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr; // 数组名arr作为指针，指向数组首元素，将其赋给指针变量p
for (int i = 0; i < 5; i++) {
printf("arr[%d]的值是：%d\n", i, *p);
p++; // 指针p指向下一个元素
}
return 0;
}

在这个例子中，首先定义了一个包含 5 个元素的整型数组arr，然后定义了一个指针变量p，并将数组名arr赋给p，此时p就指向了数组arr的首元素。通过for循环和指针操作，每次循环中通过*p访问当前指针指向的数组元素的值，并将指针p向后移动一位，从而实现对数组元素的遍历。这种利用指针遍历数组的方式，在某些情况下比使用数组下标更加灵活和高效，尤其是在处理复杂的数据结构时，指针的优势更加明显。

在函数中的应用

指针在函数中的应用非常广泛，其中一个重要的用途是通过指针传递参数，使得函数能够修改外部变量的值。以交换两个数的函数为例：

#include <stdio.h>
// 定义交换函数，接受两个整型指针作为参数
void swap(int *a, int *b) {
int temp;
temp = *a; // 临时保存*a的值
*a = *b; // 将*b的值赋给*a
*b = temp; // 将临时保存的值赋给*b
}
int main() {
int num1 = 5;
int num2 = 10;
printf("交换前：num1 = %d, num2 = %d\n", num1, num2);
swap(&num1, &num2); // 调用swap函数，传递num1和num2的地址
printf("交换后：num1 = %d, num2 = %d\n", num1, num2);
return 0;
}

在这个代码中，定义了一个swap函数，它接受两个整型指针a和b作为参数。在函数内部，通过指针操作实现了对两个指针所指向的变量值的交换。在main函数中，定义了两个整型变量num1和num2，并调用swap函数，传递它们的地址。由于传递的是地址，swap函数可以直接修改num1和num2的值，从而实现了两个数的交换。这种通过指针传递参数的方式，打破了函数参数值传递的局限，为函数间的数据交互提供了方便。

常见错误
未初始化指针
使用未初始化的指针就像是驾驶一辆没有校准方向的汽车，后果不堪设想。未初始化的指针变量会指向一个随机的内存地址，当我们对其进行解引用操作时，就可能访问到一些非法的内存区域，从而导致程序崩溃。例如：

#include <stdio.h>
int main() {
int *p; // 未初始化的指针
printf("%d\n", *p); // 试图访问未初始化指针指向的值，这是非常危险的
return 0;
}

在这段代码中，p是一个未初始化的指针，当执行printf("%d\n", *p);时，由于p指向的地址是不确定的，所以程序很可能会崩溃。为了避免这种情况，我们在使用指针变量之前，一定要对其进行初始化，可以将其初始化为NULL（在 C 语言中，NULL通常被定义为 0）或者指向一个有效的内存地址。例如：

#include <stdio.h>
int main() {
int num = 10;
int *p = &num; // 将指针p初始化为指向num的地址
// 或者 int *p = NULL; 先初始化为空指针，后续再根据需要赋值
return 0;
}

这样，我们就可以确保指针在使用时指向的是一个合法的内存位置，从而避免程序出现异常。

指针类型不匹配

指针变量的类型必须与它所指向的变量类型一致，就像钥匙和锁必须匹配才能正常使用一样。如果类型不匹配，在进行指针操作时就会出现错误。例如：

#include <stdio.h>
int main() {
int num = 10;
float *p = &num; // 错误：指针类型不匹配，p是float*类型，而num是int类型
return 0;
}

在这个例子中，p被定义为float*类型的指针，却试图指向一个int类型的变量num，这就导致了指针类型不匹配的错误。正确的做法是将指针类型与所指向变量的类型保持一致，修改后的代码如下：

#include <stdio.h>
int main() {
int num = 10;
int *p = &num; // 正确：指针类型与变量类型匹配
return 0;
}

通过确保指针类型与指向变量类型的一致性，我们可以避免因类型不匹配而引发的错误，让程序能够正确地运行。

空指针与野指针问题

空指针是指值为NULL的指针，它表示指针不指向任何有效的内存地址。例如：

#include <stdio.h>
int main() {
int *p = NULL; // 定义一个空指针
return 0;
}

而野指针则是指指针指向的是无效的或已释放的内存地址。野指针的出现通常是由于以下几种情况：一是指针变量未初始化，它会指向一个随机的地址；二是在释放内存后，没有将指针置为NULL，导致指针仍然指向已释放的内存区域。例如：

#include <stdio.h>
#include <stdlib.h>
int main() {
int *p = (int *)malloc(sizeof(int)); // 分配内存
if (p != NULL) {
*p = 10;
free(p); // 释放内存
// 此时p成为野指针，如果后续不小心使用p，就会导致错误
}
return 0;
}

为了避免野指针问题，我们在释放内存后，应及时将指针置为NULL，这样可以清楚地表明指针不再指向有效的内存地址。修改后的代码如下：

#include <stdio.h>
#include <stdlib.h>
int main() {
int *p = (int *)malloc(sizeof(int)); // 分配内存
if (p != NULL) {
*p = 10;
free(p); // 释放内存
p = NULL; // 将指针置为NULL，避免成为野指针
}
return 0;
}

同时，在使用指针之前，一定要检查指针是否为NULL，以防止对空指针进行解引用操作。例如：

#include <stdio.h>
int main() {
int *p = NULL;
if (p != NULL) {
printf("%d\n", *p); // 避免对空指针解引用
}
return 0;
}