PIC单片机C语言指针应用：深入理解内存管理，释放单片机性能

# 1. 指针基础**

指针是一种变量，它存储另一个变量的地址。它允许我们间接访问其他变量的内容，从而为我们提供了强大的内存管理和数据操作功能。

在 C 语言中，指针使用星号（*）符号来表示。例如，`int *ptr;` 声明了一个指向整型变量的指针。要获取指针指向的变量的值，我们使用解引用运算符（&）。例如，`*ptr` 获取指针 `ptr` 指向的整型变量的值。

指针可以大大提高代码的效率和灵活性。它们允许我们动态分配内存，优化数据结构，并实现更高级别的编程技术，例如动态内存分配和链表。

# 2. 指针在内存管理中的应用

### 2.1 指针的内存分配和释放

#### 2.1.1 malloc()和free()函数

**malloc()函数**

malloc()函数用于动态分配内存，它接受一个参数，表示要分配的字节数。如果分配成功，它返回指向分配内存块的指针；如果分配失败，它返回NULL。

#include <stdlib.h>

int *ptr = (int *)malloc(sizeof(int) * 10);
if (ptr == NULL) {
    // 分配失败
}

**free()函数**

free()函数用于释放先前由malloc()分配的内存块。它接受一个参数，指向要释放的内存块。

free(ptr);

#### 2.1.2 指针数组的分配和释放

**分配指针数组**

可以使用malloc()函数分配指针数组，每个元素都指向一个内存块。

int **ptr_array = (int **)malloc(sizeof(int *) * 10);
if (ptr_array == NULL) {
    // 分配失败
}

**释放指针数组**

释放指针数组时，需要先释放每个元素指向的内存块，然后再释放指针数组本身。

for (int i = 0; i < 10; i++) {
    free(ptr_array[i]);
}
free(ptr_array);

### 2.2 指针的数组应用

#### 2.2.1 指针数组的定义和初始化

指针数组是一个数组，其元素是指针。每个指针指向一个不同的内存块。

int *ptr_array[10];

// 初始化指针数组
for (int i = 0; i < 10; i++) {
    ptr_array[i] = (int *)malloc(sizeof(int));
}

#### 2.2.2 指针数组的遍历和操作

可以使用指针数组遍历和操作多个内存块。

// 遍历指针数组
for (int i = 0; i < 10; i++) {
    *ptr_array[i] = i;
}

// 访问指针数组中的元素
int value = *ptr_array[5];

### 2.3 指针的结构体应用

#### 2.3.1 指针结构体的定义和初始化

指针结构体是一个结构体，其中至少一个成员是指针。

struct student {
    char *name;
    int age;
};

struct student *ptr_student;

// 初始化指针结构体
ptr_student = (struct student *)malloc(sizeof(struct student));
ptr_student->name = (char *)malloc(sizeof(char) * 20);

#### 2.3.2 指针结构体的访问和修改

可以使用指针结构体访问和修改结构体成员。

// 访问指针结构体的成员
char *name = ptr_student->name;

// 修改指针结构体的成员
ptr_student->age = 20;

# 3.1 指针优化代码执行效率

指针可以通过优化代码执行效率来提高单片机的性能。主要有以下两种方式：

#### 3.1.1 减少函数调用开销

函数调用会产生一定的开销，包括压栈、出栈、跳转等操作。使用指针可以减少函数调用次数，从而降低代码执行时间。

例如，以下代码使用指针优化了函数调用：

#include <stdio.h>

void func(int *p) {
    *p += 1;
}

int main() {
    int a = 10;
    func(&a);
    printf("%d\n", a);
    return 0;
}

在这个例子中，`func`函数通过指针参数`p`直接修改了变量`a`的值，避免了函数调用带来的开销。

#### 3.1.2 优化数组访问速度

数组访问通常涉及到指针运算。通过使用指针，可以优化数组访问速度，减少代码执行时间。

例如，以下代码使用指针优化了数组访问：

#include <stdio.h>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int *p = arr;
    for (int i = 0; i < 5; i++) {
        printf("%d ", *p++);
    }
    return 0;
}

在这个例子中，指针`p`指向数组`arr`的第一个元素。通过使用指针运算`p++`，可以快速访问数组中的每个元素，避免了每次访问数组元素都进行指针运算的开销。

### 3.2 指针优化数据存储空间

指针还可以通过优化数据存储空间来提高单片机的性能。主要有以下两种方式：

#### 3.2.1 使用指针减少内存占用

使用指针可以减少内存占用，提高单片机的存储空间利用率。

例如，以下代码使用指针减少了内存占用：

#include <stdio.h>

struct Student {
    int id;
    char name[20];
};

int main() {
    struct Student *p = malloc(sizeof(struct Student));
    p->id = 10;
    strcpy(p->name, "John");
    printf("%d %s\n", p->id, p->name);
    free(p);
    return 0;
}

在这个例子中，通过使用指针`p`，动态分配了`Student`结构体所需要的内存空间。这样可以避免为每个`Student`结构体分配独立的内存空间，从而减少了内存占用。

#### 3.2.2 优化结构体存储布局

指针还可以优化结构体存储布局，提高单片机的存储空间利用率。

例如，以下代码优化了结构体存储布局：

#include <stdio.h>

struct Student {
    int id;
    char name[20];
};

struct Student2 {
    char name[20];
    int id;
};

int main() {
    struct Student s1;
    struct Student2 s2;
    printf("sizeof(s1) = %d\n", sizeof(s1));
    printf("sizeof(s2) = %d\n", sizeof(s2));
    return 0;
}

在这个例子中，`Student`结构体和`Student2`结构体具有相同的成员，但存储布局不同。`Student`结构体按照成员声明的顺序存储，而`Student2`结构体将`name`成员放在前面。通过优化存储布局，`Student2`结构体比`Student`结构体节省了4个字节的内存空间。

# 4. 指针在单片机外设编程中的应用

### 4.1 指针操作外设寄存器

#### 4.1.1 指针访问外设寄存器地址

在单片机中，外设寄存器通常映射到特定的内存地址。我们可以使用指针来访问这些地址，从而操作外设寄存器。

例如，假设一个单片机的外设寄存器名为 `GPIOA_ODR`，其内存地址为 `0x40020014`。我们可以使用以下代码访问该寄存器：

volatile uint32_t *GPIOA_ODR = (uint32_t *)0x40020014;

通过这个指针，我们可以直接读写 `GPIOA_ODR` 寄存器。

#### 4.1.2 指针修改外设寄存器值

一旦我们访问了外设寄存器，就可以使用指针修改其值。例如，要将 `GPIOA_ODR` 寄存器的第 5 位设置为高电平，我们可以使用以下代码：

*GPIOA_ODR |= (1 << 5);

其中，`*GPIOA_ODR` 解引用了指针，指向 `GPIOA_ODR` 寄存器。`|=` 运算符将 `1 << 5` 与寄存器值进行按位或运算，从而将第 5 位设置为高电平。

### 4.2 指针操作中断向量表

#### 4.2.1 指针修改中断向量表地址

中断向量表是一个存储中断处理程序地址的表。我们可以使用指针修改中断向量表中的地址，从而自定义中断处理程序。

例如，假设我们想要自定义 `USART1` 中断处理程序。`USART1` 中断向量表的地址为 `0x00000024`。我们可以使用以下代码修改该地址：

volatile uint32_t *USART1_ISR = (uint32_t *)0x00000024;
*USART1_ISR = (uint32_t)自定义中断处理程序地址;

#### 4.2.2 指针实现自定义中断处理程序

自定义中断处理程序是一个函数，当发生特定中断时被调用。我们可以使用指针实现自定义中断处理程序，并将其地址存储在中断向量表中。

例如，以下是一个自定义 `USART1` 中断处理程序：

void USART1_IRQHandler(void) {
  // 自定义中断处理代码
}

我们可以将该处理程序的地址存储在中断向量表中，如下所示：

*USART1_ISR = (uint32_t)&USART1_IRQHandler;

这样，当发生 `USART1` 中断时，就会调用 `USART1_IRQHandler` 函数。

# 5. 指针在单片机高级应用中的实践

### 5.1 指针实现动态内存分配

#### 5.1.1 自定义内存管理函数

// 分配内存块
void* my_malloc(size_t size) {
    void* ptr = malloc(size);
    if (ptr == NULL) {
        // 内存分配失败，返回 NULL
    }
    return ptr;
}

// 释放内存块
void my_free(void* ptr) {
    if (ptr != NULL) {
        free(ptr);
    }
}

#### 5.1.2 动态分配和释放内存块

// 分配一个大小为 10 字节的内存块
uint8_t* data = (uint8_t*)my_malloc(10);

// 使用分配的内存块

// 释放分配的内存块
my_free(data);

### 5.2 指针实现链表和树等数据结构

#### 5.2.1 链表的指针实现

typedef struct node {
    int data;
    struct node* next;
} node_t;

// 创建一个新的节点
node_t* create_node(int data) {
    node_t* node = (node_t*)my_malloc(sizeof(node_t));
    node->data = data;
    node->next = NULL;
    return node;
}

// 将节点添加到链表末尾
void add_to_list(node_t** head, int data) {
    node_t* new_node = create_node(data);
    if (*head == NULL) {
        *head = new_node;
    } else {
        node_t* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = new_node;
    }
}

#### 5.2.2 树的指针实现

typedef struct node {
    int data;
    struct node* left;
    struct node* right;
} node_t;

// 创建一个新的节点
node_t* create_node(int data) {
    node_t* node = (node_t*)my_malloc(sizeof(node_t));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 将节点插入到树中
void insert_into_tree(node_t** root, int data) {
    if (*root == NULL) {
        *root = create_node(data);
    } else {
        if (data < (*root)->data) {
            insert_into_tree(&(*root)->left, data);
        } else {
            insert_into_tree(&(*root)->right, data);
        }
    }
}