嵌入式之指针

在嵌入式系统中指针是一种非常重要的概念。它们用于直接访问内存地址，能够提高程序的灵活性和效率。

一、基本概念

1. 指针的基本概念

• 定义：指针是一个变量，其值为另一个变量的地址。通过指针，可以间接访问和修改该变量的值。
• 声明：在C语言中，指针的声明格式为 类型 *指针名，例如 int *p 表示 p 是一个指向整数的指针。

2. 指针的使用

• 动态内存分配：在嵌入式系统中，动态内存分配（如使用 malloc）可以根据需要分配内存，但要注意内存的管理，避免内存泄漏。
• 数组和指针：数组名在大多数情况下可以看作是指向数组首元素的指针。通过指针可以方便地遍历数组。
• 函数参数：使用指针作为函数参数，可以实现对原始数据的修改，避免数据的复制，提高效率。

3. 指针的类型

• 普通指针：指向基本数据类型（如 int、char 等）。
• 结构体指针：指向结构体类型，可以方便地访问结构体中的各个成员。
• 函数指针：指向函数的指针，可以实现回调机制，增加程序的灵活性。

4. 指针的注意事项

• 指针的初始化：使用指针前应确保其已被初始化，避免出现野指针（即指向未知地址的指针）。
• 内存管理：在嵌入式系统中，内存资源往往有限，因此要谨慎使用动态内存，尽量避免频繁分配和释放内存。
• 越界访问：使用指针时要注意数组的边界，避免越界访问，导致未定义行为。

二、指针类型

1. 普通指针

普通指针用于指向基本数据类型（int、char）。它们可以用于动态内存管理、数组操作和函数参数传递等场景。

例子：普通指针的基本用法

#include <stdio.h>int main() {int a = 10;          // 定义一个整数int *p = &a;        // 声明一个指针并初始化为 a 的地址printf("Value of a: %d\n", a);     // 输出 a 的值printf("Value via pointer: %d\n", *p); // 通过指针访问 a 的值*p = 20; // 通过指针修改 a 的值printf("New value of a: %d\n", a); // 输出修改后的 a 的值return 0;
}

应用场景

• 动态内存分配：使用 malloc 和 free 进行动态内存管理。
• 数组操作：通过指针遍历和操作数组元素。
• 函数参数传递：避免大数据结构的复制，提高性能。

2. 结构体指针

结构体指针用于指向结构体类型，可以方便地访问结构体中的各个成员。

例子：结构体指针的用法

#include <stdio.h>
#include <string.h>typedef struct {char name[20];int age;
} Person;int main() {Person person;               // 定义一个结构体变量Person *pPerson = &person;  // 声明一个指向结构体的指针// 使用结构体指针访问和修改成员strcpy(pPerson->name, "Alice");pPerson->age = 30;printf("Name: %s, Age: %d\n", pPerson->name, pPerson->age);return 0;
}

应用场景

• 数据组织：使用结构体指针管理复杂数据结构（如链表、树等）。
• 函数参数传递：通过结构体指针传递大型结构体，避免复制，提高效率。

3. 函数指针

函数指针是指向函数的指针，可以用来实现回调机制、事件处理等。

例子：函数指针的用法

#include <stdio.h>// 定义一个函数类型
typedef void (*Operation)(int, int);// 加法函数
void add(int a, int b) {printf("Sum: %d\n", a + b);
}// 减法函数
void subtract(int a, int b) {printf("Difference: %d\n", a - b);
}// 执行操作的函数
void executeOperation(Operation op, int x, int y) {op(x, y); // 调用传入的函数指针
}int main() {// 声明函数指针并指向加法和减法函数Operation op1 = add;Operation op2 = subtract;// 执行操作executeOperation(op1, 10, 5); // 调用加法executeOperation(op2, 10, 5); // 调用减法return 0;
}

应用场景

• 回调函数：在事件驱动编程中，使用函数指针作为回调。
• 策略模式：根据不同的条件选择不同的函数执行。
• 状态机：通过函数指针实现不同状态下的行为。

三、易混辨别

1. 常量指针与指针常量

1.1 常量指针

常量指针是指指针所指向的内容是常量，不能通过该指针修改其指向的值。常量指针的语法是 const 类型 *指针名。

#include <stdio.h>void printValue(const int *ptr) {// ptr指向的值是常量，不能通过ptr修改printf("Value: %d\n", *ptr);// *ptr = 20; // 错误：不能修改常量
}int main() {int a = 10;const int *p = &a; // p是一个常量指针，指向整数printValue(p); // 输出值// *p = 15; // 错误：不能通过常量指针修改值return 0;
}

• 保护数据：常量指针用于保护指向的数据不被修改，适合于需要只读访问的场景。
• 函数参数：在函数参数中使用常量指针，可以避免不小心修改传入的变量。

1.2 指针常量

指针常量是指指针本身的值是常量，不能改变指向的地址。指针常量的语法是 类型 * const 指针名。

#include <stdio.h>int main() {int a = 10;int b = 20;int * const p = &a; // p是一个指针常量，指向整数printf("Value pointed by p: %d\n", *p); // 输出a的值*p = 15; // 可以通过指针修改指向的值printf("New value of a: %d\n", a); // 输出修改后的a的值// p = &b; // 错误：不能改变指针常量的指向return 0;
}

• 固定指针：指针常量用于确保指针在其生命周期内指向同一地址，适合需要固定指向某个数据的场景。
• 避免意外更改：在复杂的函数中，确保指针不被意外更改，增加代码的可读性和安全性。

1.3 常量指针与指针常量的区别

特性	常量指针 (const T*)	指针常量 (T* const)
修改指向的内容	不可修改	可修改
修改指针的地址	可修改	不可修改
语法	const int *p	int * const p

• 常量指针：指向的内容不可修改，但指针本身可以指向其他地址。
• 指针常量：指针本身不可修改，但可以通过指针修改指向的内容。
• 结合使用：可以创建一个指向常量的指针常量，既不能修改指向的内容，也不能改变指针的指向。

1.4 结合使用

常量指针和指针常量可以结合使用，形成一个指向常量的指针常量，语法为 const 类型 * const 指针名。

#include <stdio.h>int main() {int a = 10;const int * const p = &a; // p是一个指向常量的指针常量printf("Value pointed by p: %d\n", *p); // 输出a的值// *p = 15; // 错误：不能通过常量指针修改值// p = &b; // 错误：不能改变指针常量的指向return 0;
}

2. 函数指针与指针函数

2.1 函数指针

概念

• 函数指针是一个变量，它存储的是一个函数的地址。通过函数指针，可以调用指向的函数，就像直接调用函数一样。

#include <iostream>// 定义两个简单的函数
int add(int a, int b) {return a + b;
}int subtract(int a, int b) {return a - b;
}// 定义一个函数指针类型
typedef int (*Operation)(int, int);void performOperation(Operation op, int x, int y) {std::cout << "Result: " << op(x, y) << std::endl;
}int main() {// 使用函数指针调用不同的函数performOperation(add, 5, 3);      // 输出: Result: 8performOperation(subtract, 5, 3); // 输出: Result: 2return 0;
}

用途

• 动态函数调用：可以在运行时决定调用哪个函数。
• 回调机制：将函数指针作为参数传递给另一个函数，实现回调。
• 实现策略模式：通过函数指针选择不同的算法或策略。

2.2 指针函数

概念

• 指针函数是一个返回指针的函数。函数的返回类型是一个指针类型。

例子

#include <iostream>// 返回一个指向数组中最大元素的指针
int* findMax(int* arr, int size) {if (size <= 0) return nullptr;int* max = &arr[0];for (int i = 1; i < size; ++i) {if (arr[i] > *max) {max = &arr[i];}}return max;
}int main() {int numbers[] = {1, 5, 3, 9, 2};int size = sizeof(numbers) / sizeof(numbers[0]);int* maxPtr = findMax(numbers, size);if (maxPtr != nullptr) {std::cout << "Max value: " << *maxPtr << std::endl; // 输出: Max value: 9}return 0;
}

用途

• 返回动态内存地址：指针函数常用于返回动态分配的内存地址。
• 返回复杂数据结构的地址：例如返回数组中某个元素的地址。
• 链表或树结构的导航：在数据结构中，指针函数可以用于遍历或查找节点。

总结如下：

特性	函数指针	指针函数
定义	存储函数地址的指针变量。	返回指针类型的函数。
语法	return_type (*pointer_name)(parameter_list);	return_type* function_name(parameter_list);
用途	用于动态调用函数、实现回调机制、策略模式等。	用于返回动态内存地址或复杂数据结构的地址。
应用场景	- 回调函数实现 - 动态函数选择 - 策略模式实现	- 返回数组或对象的地址 - 链表或树节点的导航
调用方式	通过解引用指针来调用所指向的函数。	直接调用函数以获得返回的指针。
示例	int (*funcPtr)(int, int) = add;	int* findMax(int* arr, int size);
灵活性	高，因为可以在运行时选择不同的函数进行调用。	提供了一种返回复杂数据结构或动态内存的方式。