指针
定义
指针是一个变量,存储另一个变量的内存地址,它允许直接访问和操作内存中的数据,使得程序能够以更灵活和高效的方式处理数据和内存。
获取变量地址:使用取地址符 &
。
访问地址上的数据:使用解引用符 *
。
例子1
指针是存储另一个变量地址的变量。通过使用取地址符 &
和解引用符 *
,我们可以灵活地访问和操作内存中的数据 。
#include <stdio.h>
int main() {
int var = 10; // 定义一个整数变量
int *p = &var; // 定义一个指向整数的指针,并将其初始化为变量 var 的地址
printf("Address of var: %p\n", &var); // 输出变量 var 的地址
printf("Address stored in pointer p: %p\n", p); // 输出指针 p 中存储的地址
printf("Value of var using pointer: %d\n", *p); // 通过指针 p 解引用获取 var 的值
// 修改 var 的值,通过指针 p
*p = 20;
printf("New value of var: %d\n", var); // 输出修改后的 var 的值
return 0;
}
例子2
指针类型决定了它指向的变量类型,以及通过指针可以访问的数据大小。不同类型的指针在操作时会有不同的步长,比如:
int *p = (int *)a;
:将 char
类型数组的首地址强制转换为 int
指针类型。由于 int
类型通常占用 4 个字节,因此通过 p
访问数据时,每次会读取 4 个字节的数据。
char *q = a;
:将 char
类型数组的首地址赋值给 char
指针类型。char
类型占用 1 个字节,因此通过 q
访问数据时,每次只会读取 1 个字节的数据。
#include <stdio.h>
int main() {
char a[12] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C};
int *p = (int *)a; // 将 char 数组的地址赋值给 int 指针
char *q = a; // 将 char 数组的地址赋值给 char 指针
// 使用 int 指针访问数据
printf("Using int pointer:\n");
for (int i = 0; i < 3; i++) {
printf("p[%d]: 0x%08x\n", i, *(p + i));
}
// 使用 char 指针访问数据
printf("Using char pointer:\n");
for (int i = 0; i < 12; i++) {
printf("q[%d]: 0x%02x\n", i, *(q + i));
}
return 0;
}
/*
输出
Using int pointer:
p[0]: 0x04030201
p[1]: 0x08070605
p[2]: 0x0c0b0a09
Using char pointer:
q[0]: 0x01
q[1]: 0x02
q[2]: 0x03
q[3]: 0x04
q[4]: 0x05
q[5]: 0x06
q[6]: 0x07
q[7]: 0x08
q[8]: 0x09
q[9]: 0x0a
q[10]: 0x0b
q[11]: 0x0c
*/
一级指针和二级指针
一级地址(一级指针)
定义
一级地址指的是指向普通变量的指针,也就是直接存储变量的地址的指针。在C中,通常我们操作的是一级地址,例如指向整数、浮点数或其他基本数据类型的指针。
例子
int *ptr; // ptr 是一个指向整数的指针,是一级地址
float *ptr_float; // ptr_float 是一个指向浮点数的指针,也是一级地址
二级地址(二级指针)
定义
二级地址是指向指针的指针,也就是存储另一个指针的地址的指针。在C中,可以通过二级指针来操作指向指针的指针,用来间接修改指针指向的值或者传递指针的引用。
例子
int x = 10;
int *ptr1 = &x; // ptr1 是一个指向 x 的指针,是一级地址
int **ptr2 = &ptr1; // ptr2 是一个指向 ptr1 的指针,是二级地址
例子
分析表达式 *(*(&arr + 1) - 1)
的值:
int arr[5] = {1, 2, 3, 4, 5};
arr[5] = {1, 2, 3, 4, 5}
:这定义了一个包含 5 个整数的数组 arr
,其元素分别是 {1, 2, 3, 4, 5}
。
&arr
:这是数组 arr
的地址。需要注意的是,&arr
的类型是 int (*)[5]
,即指向一个包含 5 个整数的数组的指针。
&arr + 1
:这是 &arr
指针加 1。在这个上下文中,&arr
被看作是一个指向整个数组的指针,因此 &arr + 1
将指向紧随 arr
之后的内存位置。也就是说,它指向 arr
后面的内存地址,而不是数组中的下一个元素。&arr + 1
的类型仍然是 int (*)[5]
。
*(&arr + 1)
:这是对 &arr + 1
解引用。&arr + 1
是一个指向数组的指针,对其解引用后,得到的仍然是一个指向数组末尾之后的指针。它的类型是 int *
,即指向数组末尾之后的指针。
*(&arr + 1) - 1
:这将刚才得到的指针减去 1。由于指针的减法是以元素为单位的,这个操作将指针向后移动一个 int
的大小。因为 *(&arr + 1)
指向的是数组 arr
末尾之后的位置,减去 1 后,这个指针将指向数组 arr
的最后一个元素。
*(*(&arr + 1) - 1)
:最后,对指针 *(&arr + 1) - 1
解引用,即获取这个指针所指向的值。这个指针现在指向 arr
的最后一个元素,所以这个表达式的值就是 arr
的最后一个元素的值。
因此,*(*(&arr + 1) - 1)
的值是 5
,即数组 arr
的最后一个元素。
指针的自增运算
*++p
这个表达式是先对指针 p
进行自增操作,然后对新的指针进行解引用,得到新的指针所指向的值。
步骤:
++p
:指针 p
先自增,指向下一个元素( 自增的是指针 )。
*
:对自增后的指针解引用,得到新指针所指向的值。
++*p
这个表达式是对指针 p
所指向的值进行解引用,然后对解引用得到的值进行自增操作。
步骤:
*p
:对指针 p
进行解引用,得到指向的值。
++
:对解引用得到的值进行自增操作( 自增的是指针指向的值 )。
函数地址与数组地址
函数地址
函数名就是函数的入口地址,因此可以直接把函数名赋给函数指针,也可以加上取地址符号 &
。取地址符号 &
是可选的,它只是显式地说明了编译器隐式执行的任务。获取函数的地址时,加不加取地址符号 &
都可以。
#include <stdio.h>
int test(int i) {
return i;
}
int main(void) {
int (*p1)(int) = test;
int (*p2)(int) = &test;
printf("%p, %p\n", (void *)p1, (void *)p2);
return 0;
}
数组地址
数组名本身是数组第一个元素的地址。例如,对于 int
类型的数组来说,数组名 arr
的类型是 int*
,它是一个整型指针,不是数组指针。如果要取整个数组的地址,必须在数组名前面加上取地址符号 &
,这样才能赋值给数组指针。获取数组的地址时,必须加上取地址符号 &
。
在下面的例子中, p1
是一个整型指针,指向数组的第一个元素,而 p2
是一个数组指针,指向整个数组。对 p1
和 p2
分别进行加 1 操作,p1
会加 4 个字节(假设 int
为 4 字节),而 p2
会加 20 个字节(5 个 int
)。
#include <stdio.h>
int main(void) {
int array[5] = {1, 2, 3, 4, 5};
int* p1 = array; // 指向数组第一个元素
int(*p2)[5] = &array; // 指向整个数组
printf("p1 %p\n", (void*)p1);
printf("p2 %p\n", (void*)p2);
printf("p1+1 %p\n", (void*)(p1+1)); // p1 加 1,增加 4 个字节(假设 int 为 4 字节)
printf("p2+1 %p\n", (void*)(p2+1)); // p2 加 1,增加 20 个字节(5 个 int)
return 0;
}
指针和数组
不需要严格区分的情况
访问数组元素
对于数组和指针,都可以使用下标形式或指针形式来访问元素。
#include <stdio.h>
int main(void) {
char array[] = "hello world!";
char* p = array;
array[1] = 'x'; // 使用下标访问数组
*(array + 1) = 'x'; // 使用指针形式访问数组
p[1] = 'y'; // 使用下标访问指针
*(p + 1) = 'y'; // 使用指针形式访问指针
printf("%s\n", array); // 输出: hyllo world!
printf("%s\n", p); // 输出: hyllo world!
return 0;
}
作为函数参数传递
实参传递数组时,形参可以是数组或指针。实参传递指针时,形参也可以是数组或指针。编译器会将数组参数退化为指针。
#include <stdio.h>
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main(void) {
int array[] = {1, 2, 3, 4, 5};
printArray(array, 5); // 传递数组
return 0;
}
需要严格区分的情况
使用 sizeof
计算长度
sizeof(array)
返回数组的字节数。sizeof(pointer)
返回指针的大小(在64位系统中为8字节,在32位系统中为4字节)。
#include <stdio.h>
int main(void) {
char array[] = "hello world!";
char* p = array;
printf("sizeof(array) = %lu\n", sizeof(array)); // 输出: 13
printf("sizeof(p) = %lu\n", sizeof(p)); // 输出: 8 (在64位系统中)
return 0;
}
计算数组长度
当数组作为参数传递时,在函数内部不能使用 sizeof
计算数组长度,因为数组会退化为指针。
#include <stdio.h>
void test(int arg[]) {
printf("sizeof(arg) = %lu\n", sizeof(arg)); // 输出指针大小,例如在64位系统中为8
}
int main(void) {
int array[10];
test(array); // 传递数组
return 0;
}
声明外部变量
在一个文件中定义指针 p
,在另一个文件中不能声明为数组。
//file1.c:
int* p;
// file2.c
extern int* p; // 正确:声明为指针
// extern int p[]; // 错误:不能声明为数组
指针常量和常量指针
指针常量
定义
不能改变指向的指针。也就是说,一旦初始化后,就不能再改变指向其它地址,但可以修改指针所指向地址上的内容。
例子
比如指针 p
,因为它被 const
修饰,所以 p
不能被修改,它只能指向 str
。如果强行对 p
进行 p++
操作,编译时就会报错。我们称指针 p
为指针常量。尽管 p
本身不能被修改,但可以通过 p
来修改 str
的内容,例如 *p = 'H';
。
char str[] = "hello world!";
char *const p = str;
常量指针
定义
不能改变所指向的值的指针。也就是说,通过这个指针不能修改它所指向的值,但可以修改指针的指向。
例子
p
是一个指向 char
类型常量的指针。可以修改 p
的指向,例如 p = another_str;
,但不能通过 p
修改其指向的内容,例如 *p = 'H';
是不允许的。
const char *p = "hello world!";
char const *p = "hello world!";
指针数组和数组指针
指针数组
定义
本质是一个数组,数组的每个元素都是指针。
例子1
int *p[4];
这一声明中,p
先与中括号结合,表示 p
是一个有四个元素的数组,每个元素的类型都是 int *
(指向整型的指针)。因此,我们称 p
为指针数组。
int *p[4];
例子2
int a = 1, b = 2, c = 3, d = 4;
int *p[4] = { &a, &b, &c, &d };
for (int i = 0; i < 4; i++) {
printf("%d ", *p[i]);
}
// 输出:1 2 3 4
数组指针
定义
本质是一个指针,指向一个数组。
例子1
int (*p)[4];
这一声明中,p
先与 *
结合,表示 p
是一个指针,然后与中括号结合,表示 p
指向一个有四个元素的数组,每个元素的类型都是 int
。因此,我们称 p
为数组指针。
int (*p)[4];
例子2
int arr[4] = {1, 2, 3, 4};
int (*p)[4] = &arr;
for (int i = 0; i < 4; i++) {
printf("%d ", (*p)[i]);
}
// 输出:1 2 3 4
函数指针和指针函数
函数指针
定义
本质是一个指针,指向一个函数。每个函数在内存中都有一个地址,函数调用就是跳转到这个地址开始执行,函数指针记录了这个地址的变量。
例子
p
是一个指针,指向一个函数,该函数有一个 int
类型的参数,返回值是 int
。可以通过函数名 test(1)
来调用函数,也可以通过指针 p
来调用 p(1)
或者(*p)(1)
。
#include <stdio.h>
int test(int i) {
return i;
}
int main(void) {
int res = 0;
int (*p)(int) = test;
res = test(1);
printf("%d\n", res);
res = p(1);
printf("%d\n", res);
res = (*p)(1);
printf("%d\n", res);
return 0;
}
应用
往结构体中放入函数
C语言的结构体不支持成员函数,但可以通过函数指针实现类似的功能。结构体中可以定义一个函数指针,用来保存函数地址。函数名可以直接赋值给函数指针。C语言的结构体在使用时必须加上 struct
关键字,而 C++ 可以省略。
#include <stdio.h>
#include <stdlib.h>
// 定义一个打印函数
void print(int a, int b) {
printf("%d %d\n", a, b);
}
// 定义一个结构体,其中包含一个函数指针
struct Test {
void (*p)(int, int);
};
int main(void) {
// 动态分配结构体内存
struct Test* t = (struct Test *)malloc(sizeof(struct Test));
if (t == NULL) {
fprintf(stderr, "Memory allocation failed\n");
return 1;
}
// 将函数指针指向打印函数
t->p = print;
// 调用函数指针
t->p(3, 4); // 输出: 3 4
// 释放动态分配的内存
free(t);
return 0;
}
回调函数
是一种通过函数指针实现的技术,允许在一个函数中调用另一个函数。通常用于事件驱动编程或处理异步操作。
#include <stdio.h>
// 定义一个回调函数类型
typedef void (*Callback)(int);
// 定义一个回调函数
void myCallback(int value) {
printf("Callback called with value: %d\n", value);
}
// 定义一个执行操作并调用回调函数的函数
void performOperation(int x, Callback callback) {
printf("Performing operation with value: %d\n", x);
// 调用回调函数
callback(x);
}
int main(void) {
// 使用回调函数
performOperation(5, myCallback);
return 0;
}
动态函数调用
在需要根据某些条件动态选择和调用不同函数时,函数指针非常有用。例如,在一个计算器程序中可以动态选择不同的操作函数。
#include <stdio.h>
// 定义操作函数
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return a / b; }
int main(void) {
// 定义一个函数指针数组
int (*operations[4])(int, int) = { add, subtract, multiply, divide };
int a = 10, b = 5;
char op = '+';
// 根据操作符选择对应的函数
int (*operation)(int, int) = NULL;
switch (op) {
case '+': operation = operations[0]; break;
case '-': operation = operations[1]; break;
case '*': operation = operations[2]; break;
case '/': operation = operations[3]; break;
}
if (operation != NULL) {
printf("Result: %d\n", operation(a, b));
} else {
printf("Invalid operation\n");
}
return 0;
}
实现多态行为
通过函数指针数组,可以在C语言中实现类似C++的多态行为。这种技术广泛应用于设计模式和框架中。
#include <stdio.h>
// 定义一个基类结构体
struct Shape {
void (*draw)(struct Shape*);
};
// 定义一个派生类结构体
struct Circle {
struct Shape base; // 基类
int radius;
};
// 定义一个绘制函数
void drawCircle(struct Shape* shape) {
struct Circle* circle = (struct Circle*)shape;
printf("Drawing a circle with radius: %d\n", circle->radius);
}
int main(void) {
// 创建一个 Circle 对象
struct Circle c;
c.base.draw = drawCircle;
c.radius = 5;
// 调用绘制函数
c.base.draw((struct Shape*)&c);
return 0;
}
实现状态机
是一种在不同状态之间转换的编程模式。可以通过函数指针实现状态之间的动态切换。
#include <stdio.h>
// 定义状态函数类型
typedef void (*StateFunction)();
// 定义状态函数
void stateA() {
printf("State A\n");
}
void stateB() {
printf("State B\n");
}
void stateC() {
printf("State C\n");
}
int main(void) {
// 定义一个状态函数指针数组
StateFunction states[3] = { stateA, stateB, stateC };
int currentState = 0;
for (int i = 0; i < 5; i++) {
// 调用当前状态函数
states[currentState]();
// 切换到下一个状态
currentState = (currentState + 1) % 3;
}
return 0;
}
代码跳转到指定位置执行
比如((void(*)())0)();
代表让程序跳转到地址为0的地方去运行。
解析步骤
(void (*)())
:这是一个类型转换,表示一个指向返回类型为 void
、无参数的函数的指针。具体来说,void (*)()
是一种函数指针类型,它指向的函数没有参数并返回 void
。
0
:这是一个整数常量 0
。在C中,可以将整数常量 0
作为空指针常量。
(void (*)())0
:这将整数 0
转换为类型为 void (*)()
的函数指针。换句话说,这是将 0
解释为一个指向无参数、返回类型为 void
的函数的指针。
((void (*)())0)
:这只是对前面步骤的类型转换进行一次包裹,结果仍然是一个类型为 void (*)()
的函数指针,指向 0
地址。
((void (*)())0)()
:这表示对 0
地址的函数指针进行调用。具体来说,这是试图调用位于地址 0
处的函数。
指针函数
定义
本质是一个函数,其返回值是一个指针。
例子
错误示例
下面这个例子是一个典型的错误,因为不能返回一个局部变量的地址。函数调用完毕后,局部变量的内存会被释放,即使返回了这个地址也不能使用。
int* test() {
int array[5] = {0}; // 局部变量
return array; // 错误:返回局部变量的地址
}
int main(void) {
int* p = test(); // 不安全
return 0;
}
返回堆空间地址
#include <stdio.h>
#include <stdlib.h>
int* test() {
int* array = (int*)malloc(sizeof(int) * 5); // 动态分配堆空间
if (array != NULL) {
for (int i = 0; i < 5; ++i) {
array[i] = i; // 初始化数组
}
}
return array; // 返回堆空间地址
}
int main(void) {
int* p = test();
if (p != NULL) {
for (int i = 0; i < 5; ++i) {
printf("%d ", p[i]); // 输出:0 1 2 3 4
}
free(p); // 释放动态分配的内存
}
return 0;
}
返回全局变量地址
#include <stdio.h>
int array[5]; // 全局变量
int* test() {
for (int i = 0; i < 5; ++i) {
array[i] = i; // 初始化数组
}
return array; // 返回全局变量地址
}
int main(void) {
int* p = test();
for (int i = 0; i < 5; ++i) {
printf("%d ", p[i]); // 输出:0 1 2 3 4
}
return 0;
}
返回静态变量地址
#include <stdio.h>
int* test() {
static int array[5]; // 静态变量
for (int i = 0; i < 5; ++i) {
array[i] = i; // 初始化数组
}
return array; // 返回静态变量地址
}
int main(void) {
int* p = test();
for (int i = 0; i < 5; ++i) {
printf("%d ", p[i]); // 输出:0 1 2 3 4
}
return 0;
}
指针函数指针
定义
是一个指向返回指针的函数的指针。它不仅是一个指向函数的指针,而且该函数返回的也是一个指针。
例子
#include <stdio.h>
#include <stdlib.h>
// 定义一个返回整数指针的函数
int* allocateArray(int size) {
int* array = (int*)malloc(size * sizeof(int)); // 动态分配内存
if (array != NULL) {
for (int i = 0; i < size; ++i) {
array[i] = i; // 初始化数组
}
}
return array; // 返回堆空间地址
}
// 定义一个指向返回整数指针的函数的指针类型
typedef int* (*ArrayAllocator)(int);
int main(void) {
// 定义一个指向返回整数指针的函数的指针
ArrayAllocator allocator = allocateArray;
int size = 5;
// 使用指针函数指针调用函数
int* array = allocator(size);
if (array != NULL) {
for (int i = 0; i < size; ++i) {
printf("%d ", array[i]); // 输出:0 1 2 3 4
}
printf("\n");
free(array); // 释放动态分配的内存
}
return 0;
}
悬挂指针和野指针
悬挂指针
定义
悬挂指针是指向已经释放(通过 free
函数释放)或者已经超出作用域的内存的指针。当我们试图通过这样的指针访问或操作内存时,可能会导致未定义行为,因为那块内存可能已经被操作系统重新分配给其它程序使用了。
#include <stdio.h>
#include <stdlib.h>
void dangling_pointer_example() {
int *p = (int *)malloc(sizeof(int));
*p = 42;
printf("Value: %d\n", *p); // 输出42
free(p); // 释放内存
// p现在是悬挂指针,访问*p将导致未定义行为
// printf("Value: %d\n", *p); // 不安全,可能导致崩溃或未定义行为
}
int main() {
dangling_pointer_example();
return 0;
}
解决方法
立即将指针设为NULL:在释放内存后,将指针设置为NULL。
free(p);
p = NULL;
避免返回局部变量的指针:不要返回局部变量的指针,因为它们在函数返回后将超出作用域。
int* incorrect_function() {
int x = 42;
return &x; // 返回局部变量的指针,错误
}
野指针
定义
野指针是一个未初始化的指针,它的值是未知的,可能指向任意内存地址。当我们试图通过这样的指针访问或操作内存时,可能会导致未定义行为。
#include <stdio.h>
void wild_pointer_example() {
int *p; // 未初始化的指针
// *p = 42; // 不安全,可能导致崩溃或未定义行为
}
int main() {
wild_pointer_example();
return 0;
}
解决方法
在声明指针时初始化:声明指针时将其初始化为NULL或有效地址。
int *p = NULL;
确保在使用前分配内存:在使用指针之前,确保它已经被正确初始化和分配内存。
int *p = (int *)malloc(sizeof(int));
if (p != NULL) {
*p = 42;
}