C语言指针和结构体实例分析

发布时间：2022-03-22 16:03:26 作者：iii
来源：亿速云阅读：222

# C语言指针和结构体实例分析

## 引言

指针和结构体是C语言中两个极其重要的概念。指针提供了直接访问内存地址的能力，而结构体则允许将不同类型的数据组合成一个整体。本文将深入探讨指针和结构体的基本概念，并通过多个实例展示它们的实际应用。

## 一、指针基础

### 1.1 什么是指针

指针是一个变量，其值为另一个变量的内存地址。通过指针，我们可以间接访问和操作内存中的数据。

```c
int var = 20;    // 实际变量
int *ptr = &var; // 指针变量

1.2 指针的基本操作

取地址运算符(&): 获取变量的内存地址
解引用运算符(*): 访问指针指向的内存内容

printf("var的地址: %p\n", &var); // 输出var的地址
printf("*ptr的值: %d\n", *ptr);  // 输出20

1.3 指针的算术运算

指针支持加减运算，其移动的步长取决于指针所指向的数据类型。

int arr[3] = {10, 20, 30};
int *p = arr;
printf("%d\n", *(p+1)); // 输出20

二、结构体基础

2.1 什么是结构体

结构体是C语言中一种用户自定义的数据类型，允许将不同类型的数据项组合在一起。

struct Student {
    char name[50];
    int age;
    float score;
};

2.2 结构体的声明和使用

struct Student stu1; // 声明结构体变量
strcpy(stu1.name, "张三");
stu1.age = 20;
stu1.score = 89.5;

2.3 结构体数组

struct Student class[30]; // 结构体数组
class[0].age = 19;       // 访问第一个学生的年龄

三、指针与结构体的结合

3.1 指向结构体的指针

struct Student *ptr = &stu1;
printf("姓名: %s\n", (*ptr).name); // 传统写法
printf("年龄: %d\n", ptr->age);    // 更简洁的箭头写法

3.2 动态内存分配

结合指针和结构体，可以实现动态内存分配。

struct Student *p = (struct Student*)malloc(sizeof(struct Student));
if(p == NULL) {
    // 处理内存分配失败
}
p->age = 21;
free(p); // 记得释放内存

3.3 结构体包含指针成员

struct Person {
    char *name; // 指针成员
    int age;
};

struct Person p1;
p1.name = (char*)malloc(50 * sizeof(char));
strcpy(p1.name, "李四");
free(p1.name); // 释放指针成员的内存

四、综合实例分析

4.1 学生管理系统

下面是一个简单的学生管理系统示例，展示了指针和结构体的综合应用。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_STUDENTS 100

typedef struct {
    int id;
    char name[50];
    float score;
} Student;

void addStudent(Student *s, int *count) {
    if(*count >= MAX_STUDENTS) {
        printf("学生数量已达上限!\n");
        return;
    }
    
    printf("输入学号: ");
    scanf("%d", &s[*count].id);
    printf("输入姓名: ");
    scanf("%s", s[*count].name);
    printf("输入分数: ");
    scanf("%f", &s[*count].score);
    
    (*count)++;
}

void printStudents(Student *s, int count) {
    printf("\n学生列表:\n");
    printf("ID\t姓名\t分数\n");
    for(int i = 0; i < count; i++) {
        printf("%d\t%s\t%.1f\n", s[i].id, s[i].name, s[i].score);
    }
}

int main() {
    Student students[MAX_STUDENTS];
    int count = 0;
    int choice;
    
    do {
        printf("\n1. 添加学生\n");
        printf("2. 显示所有学生\n");
        printf("3. 退出\n");
        printf("选择: ");
        scanf("%d", &choice);
        
        switch(choice) {
            case 1:
                addStudent(students, &count);
                break;
            case 2:
                printStudents(students, count);
                break;
            case 3:
                printf("退出系统\n");
                break;
            default:
                printf("无效选择!\n");
        }
    } while(choice != 3);
    
    return 0;
}

4.2 链表实现

链表是数据结构中指针和结构体结合的经典案例。

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node* createNode(int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    if(newNode == NULL) {
        printf("内存分配失败!\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

void appendNode(Node **head, int data) {
    Node *newNode = createNode(data);
    
    if(*head == NULL) {
        *head = newNode;
        return;
    }
    
    Node *current = *head;
    while(current->next != NULL) {
        current = current->next;
    }
    current->next = newNode;
}

void printList(Node *head) {
    Node *current = head;
    while(current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

void freeList(Node *head) {
    Node *current = head;
    while(current != NULL) {
        Node *temp = current;
        current = current->next;
        free(temp);
    }
}

int main() {
    Node *head = NULL;
    
    appendNode(&head, 10);
    appendNode(&head, 20);
    appendNode(&head, 30);
    
    printList(head);
    
    freeList(head);
    
    return 0;
}

五、常见问题与注意事项

野指针问题: 指针未初始化或释放后未置空
```
int *p; // 未初始化
*p = 10; // 危险!
```

内存泄漏: 分配的内存未释放

int *p = malloc(sizeof(int));
// 忘记free(p)

结构体对齐问题: 结构体成员可能存在内存对齐

struct Example {
   char c;   // 1字节
   int i;    // 4字节
}; // 可能占用8字节而非5字节

指针与数组的区别: 虽然相似但有本质区别

int arr[10];
int *p = arr;
// sizeof(arr) != sizeof(p)

六、总结

指针和结构体是C语言的核心概念，掌握它们对于编写高效、灵活的代码至关重要。通过本文的讲解和实例分析，我们了解了：

指针的基本概念和操作
结构体的定义和使用方法
指针与结构体的结合应用
实际编程中的综合案例
常见问题和注意事项

希望本文能帮助读者深入理解并熟练运用C语言中的指针和结构体。在实际开发中，建议多实践、多调试，逐步掌握这些重要概念的精髓。 “`