【C语言】指针全局变量

指针全局变量的定义与使用详解

指针全局变量是指在程序的全局作用域（即所有函数之外）定义的指针变量。这种变量在整个程序的生命周期内存在，可被所有函数访问。以下是其核心概念、使用场景及示例：

---

一、指针全局变量的本质

1. 定义形式

   int *global_ptr;  // 未初始化的全局指针（默认初始化为 NULL）
   char *str = "Hello";  // 指向字符串常量的全局指针

2. 内存特性

   • 存储位置 ：指针变量本身位于程序的全局数据区（.data 或 .bss 段）。
   • 指向内容：指针指向的数据可能位于堆（动态分配）、全局区（静态数据）或只读区（如字符串常量）。

---

二、典型使用场景

1. 共享动态分配的内存

• 场景：多个函数需要操作同一块堆内存。

• 优点：避免重复传递指针参数。

• 示例 ：

  #include <stdlib.h>
  int *data_ptr = NULL;  // 全局指针
  
  void init_data() {
      data_ptr = malloc(100 * sizeof(int));  // 分配堆内存
  }
  
  void process_data() {
      if (data_ptr != NULL) {
          data_ptr[0] = 42;  // 其他函数直接使用全局指针
      }
  }
  
  void free_data() {
      free(data_ptr);
      data_ptr = NULL;  // 防止悬垂指针
  }

2. 访问硬件或固定地址

• 场景：嵌入式系统中操作硬件寄存器或内存映射设备。

• 示例 ：

  // 假设 0xFFFF0000 是某硬件寄存器的物理地址
  volatile uint32_t *hw_register = (volatile uint32_t*)0xFFFF0000;
  
  void enable_device() {
      *hw_register |= 0x1;  // 写寄存器
  }

3. 实现单例或全局配置

• 场景：全局唯一的数据结构（如配置参数、日志句柄）。

• 示例 ：

  typedef struct {
      int log_level;
      FILE *log_file;
  } Config;
  
  Config *global_config = NULL;  // 全局配置指针
  
  void load_config() {
      global_config = malloc(sizeof(Config));
      global_config->log_level = 1;
      global_config->log_file = fopen("app.log", "w");
  }
  
  void log_message(const char *msg) {
      if (global_config && global_config->log_file) {
          fprintf(global_config->log_file, "%s\n", msg);
      }
  }

---

三、使用注意事项

1. 线程安全问题

• 风险：多线程同时修改指针或指向的数据可能导致竞态条件。
• 解决方案 ：

  • 使用互斥锁（Mutex）保护访问：

    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    int *shared_ptr = NULL;
    
    void thread_safe_update() {
        pthread_mutex_lock(&lock);
        if (shared_ptr) {
            *shared_ptr += 1;  // 受锁保护的写操作
        }
        pthread_mutex_unlock(&lock);
    }

  • 使用原子操作（C11 stdatomic.h）：

    #include <stdatomic.h>
    atomic_int *atomic_ptr = NULL;

2. 内存管理

• 风险：未正确释放内存导致泄漏，或访问已释放内存（悬垂指针）。
• 最佳实践 ：

  • 初始化时置为 NULL。

  • 释放后立即置 NULL。

  • 使用前检查指针有效性：

    if (global_ptr != NULL) {
        // 安全操作
    }

3. 替代方案对比

方式	优点	缺点
全局指针	跨函数共享数据方便	耦合性高，难以维护
参数传递	明确数据流向，降低耦合	多次传递大结构体效率低
静态局部变量+Getter	封装性好	需额外函数接口

---

四、实际代码示例

示例 1：多线程安全操作全局指针

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

int *counter = NULL;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void init_counter() {
    counter = malloc(sizeof(int));
    *counter = 0;
}

void *increment(void *arg) {
    pthread_mutex_lock(&lock);
    if (counter) (*counter)++;
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    init_counter();
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Final value: %d\n", *counter);  // 输出 2
    free(counter);
    return 0;
}

示例 2：动态数组全局管理

float *sensor_data = NULL;
size_t data_size = 0;

void add_data(float value) {
    data_size++;
    sensor_data = realloc(sensor_data, data_size * sizeof(float));
    sensor_data[data_size - 1] = value;
}

void clear_data() {
    free(sensor_data);
    sensor_data = NULL;
    data_size = 0;
}

---

五、总结

• 适用场景：

  • 跨多个函数共享动态数据。
  • 访问固定地址（如硬件寄存器）。
  • 实现全局唯一实例（配置、资源句柄）。

• 慎用情况：

  • 多线程环境未同步。
  • 需要高内聚低耦合的模块化设计。

• 替代方案优先级：

  1. 参数传递或结构体封装。
  2. 静态局部变量 + Getter/Setter。
  3. 全局指针（仅在必要时使用）。

指针全局变量是指在全局作用域中定义的指针变量。这种变量可以在整个程序的任何地方访问和修改，通常用于指向动态分配的内存或需要在多个函数之间共享的数据。指针全局变量在多线程编程、资源管理、配置数据等方面非常有用。

指针全局变量的定义和使用

定义

指针全局变量通常在所有函数之外定义，可以初始化为 NULL 或指向某个特定的内存地址。

// 定义一个指向 int 的全局指针
int* global_ptr = NULL;

使用

1. 初始化：通常在程序启动时初始化。
2. 访问和修改：在多个函数中访问和修改该指针所指向的数据。
3. 清理：在程序结束前释放指针指向的内存，避免内存泄漏。

常见使用场景

1. 资源共享：在多线程环境中共享资源。
2. 配置数据：存储和访问全局配置信息。
3. 动态内存管理：管理动态分配的内存块。

举例说明

1. 多线程环境中的资源共享

假设我们有一个多线程程序，其中多个线程需要共享一个整数数组。

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

// 全局指针
int* shared_array = NULL;

// 互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_func(void* arg) {
    int thread_id = *(int*)arg;
    
    // 访问和修改共享数组
    for (int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mutex);
        shared_array[i] += thread_id;  // 修改共享数组
        pthread_mutex_unlock(&mutex);
    }
    
    return NULL;
}

int main() {
    const int array_size = 10;
    int thread_ids[2] = {1, 2};

    // 动态分配内存
    shared_array = (int*)malloc(array_size * sizeof(int));
    if (shared_array == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

    // 初始化共享数组
    for (int i = 0; i < array_size; i++) {
        shared_array[i] = 0;
    }

    // 创建线程
    pthread_t threads[2];
    for (int i = 0; i < 2; i++) {
        pthread_create(&threads[i], NULL, thread_func, &thread_ids[i]);
    }

    // 等待线程结束
    for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }

    // 打印结果
    for (int i = 0; i < array_size; i++) {
        printf("shared_array[%d] = %d\n", i, shared_array[i]);
    }

    // 释放内存
    free(shared_array);

    return 0;
}

2. 配置数据

假设我们需要在整个程序中访问一些配置参数。

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

// 全局指针
char* config_path = NULL;

void set_config_path(const char* path) {
    if (config_path != NULL) {
        free(config_path);  // 释放旧的内存
    }
    config_path = strdup(path);  // 分配新内存并复制字符串
}

const char* get_config_path() {
    return config_path;
}

int main() {
    // 设置配置路径
    set_config_path("/path/to/config");

    // 获取并打印配置路径
    printf("Config Path: %s\n", get_config_path());

    // 释放内存
    free((void*)config_path);

    return 0;
}

3. 动态内存管理

假设我们需要在多个函数中管理和操作一个动态分配的链表。

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

// 链表节点结构
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 全局指针
Node* list_head = NULL;

void add_node(int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    if (new_node == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return;
    }
    new_node->data = data;
    new_node->next = list_head;
    list_head = new_node;
}

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

void free_list() {
    Node* current = list_head;
    while (current != NULL) {
        Node* next = current->next;
        free(current);
        current = next;
    }
    list_head = NULL;
}

int main() {
    // 添加节点
    add_node(10);
    add_node(20);
    add_node(30);

    // 打印链表
    print_list();

    // 释放链表
    free_list();

    return 0;
}

总结

• 指针全局变量：在全局作用域中定义的指针变量，用于指向动态分配的内存或共享数据。
• 使用场景：多线程资源共享、配置数据管理、动态内存管理等。
• 注意事项：确保正确初始化和释放内存，避免内存泄漏；在多线程环境中使用同步机制（如互斥锁）避免竞态条件。