当前位置：首页 > news >正文

C语言开发实战：从基础到嵌入式系统编程

news 2026/7/18 4:07:00

1. C语言的历史与核心特性

C语言诞生于1972年贝尔实验室，由丹尼斯·里奇（Dennis Ritchie）在开发UNIX操作系统时创造。它最初的设计目标是提供一种能够替代汇编语言进行系统编程的高级语言，同时保持接近硬件的执行效率。这种独特的定位使C语言迅速成为系统级开发的标杆语言。

C语言的核心特性主要体现在三个方面：

过程式编程范式：代码按顺序执行，通过函数组织逻辑
静态类型系统：变量类型在编译时确定
直接内存访问：指针机制提供了底层内存操作能力

提示：现代C语言标准已发展到C18（2018年发布），但实际开发中最广泛支持的仍是C11标准。新项目建议至少采用C11标准以获得更好的类型安全和多线程支持。

2. 开发环境配置实战

2.1 编译器选择与安装

主流C编译器包括：

GCC（GNU Compiler Collection）：Linux默认编译器，可通过sudo apt install build-essential安装
Clang：LLVM项目产物，错误提示更友好，MacOS默认编译器
MSVC：微软Visual Studio配套编译器

Windows平台推荐使用MinGW-w64项目提供的GCC移植版：

# 验证安装成功的示例 gcc --version gcc -v hello.c -o hello # 编译示例

2.2 VS Code配置指南

安装C/C++扩展包
创建c_cpp_properties.json配置编译器路径：

{ "configurations": [ { "name": "Win32", "includePath": ["${workspaceFolder}/**"], "defines": ["_DEBUG", "UNICODE"], "compilerPath": "C:/mingw64/bin/gcc.exe", "cStandard": "c11", "cppStandard": "c++17" } ] }

配置调试环境需添加launch.json文件

常见问题排查：

头文件找不到：检查includePath设置
链接错误：确认库文件路径正确
中文乱码：添加编译选项-fexec-charset=GBK

3. C语言核心语法精要

3.1 数据类型系统

C语言数据类型可分为：

基本类型：int、float、double、char等
派生类型：数组、指针、结构体、联合体
空类型：void

类型修饰符：

signed/unsigned：符号修饰
short/long：长度修饰

注意：C99标准引入了<stdint.h>头文件，提供了精确宽度整数类型如int32_t，建议在跨平台开发中使用。

3.2 指针深度解析

指针是C语言的灵魂特性，其核心要点包括：

指针运算：*(ptr + i)等价于ptr[i]
多级指针：用于处理指针数组等复杂结构
函数指针：实现回调机制的基础

// 典型指针使用场景 void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } // 函数指针示例 typedef int (*compare_func)(int, int); void sort_array(int *arr, int size, compare_func cmp);

3.3 内存管理实践

C语言手动内存管理要点：

malloc/calloc分配堆内存
realloc调整已分配内存大小
free释放内存

// 安全的内存分配模式 int *create_int_array(size_t count) { int *arr = calloc(count, sizeof(int)); if (!arr) { perror("Memory allocation failed"); exit(EXIT_FAILURE); } return arr; }

内存错误常见类型：

野指针：访问已释放内存
内存泄漏：未释放不再使用的内存
缓冲区溢出：数组越界访问

4. 标准库核心组件详解

4.1 文件IO操作

文件处理基本流程：

FILE *f = fopen("data.txt", "r+"); if (!f) { /* 错误处理 */ } // 读写操作 fprintf(f, "Record %d\n", 123); char buffer[256]; while (fgets(buffer, sizeof(buffer), f)) { // 处理每行数据 } fclose(f);

文件模式说明：

"r"：只读
"w"：创建/截断写
"a"：追加写
"+"：更新模式（可读写）

4.2 字符串处理技巧

<string.h>关键函数：

strcpy/strncpy：字符串复制
strcat/strncat：字符串连接
strcmp/strncmp：字符串比较
strstr：查找子串

安全实践：

始终使用带长度限制的版本（strncpy等）
确保目标缓冲区足够大
处理字符串前检查NULL指针

// 安全的字符串拼接 char path[256]; snprintf(path, sizeof(path), "%s/%s", dirname, filename);

5. 项目实战：温度传感器系统

5.1 硬件接口模拟

假设使用热敏电阻通过ADC读取温度值：

#define ADC_RESOLUTION 4096 // 12位ADC #define REF_VOLTAGE 3.3f #define R_REF 10000.0f // 分压电阻 float read_temperature() { int adc_value = read_adc_channel(0); float voltage = (adc_value * REF_VOLTAGE) / ADC_RESOLUTION; float r_thermistor = (voltage * R_REF) / (REF_VOLTAGE - voltage); // 使用Steinhart-Hart方程计算温度 float steinhart; steinhart = r_thermistor / R_REF; // (R/Ro) steinhart = log(steinhart); // ln(R/Ro) steinhart /= 3950.0; // 1/B * ln(R/Ro) steinhart += 1.0 / (25.0 + 273.15); // + (1/To) steinhart = 1.0 / steinhart; // 倒数 steinhart -= 273.15; // 转换为摄氏度 return steinhart; }

5.2 数据持久化实现

温度记录存储方案：

#pragma pack(push, 1) typedef struct { time_t timestamp; float temperature; uint8_t sensor_id; } TemperatureRecord; #pragma pack(pop) void save_record(FILE *db, const TemperatureRecord *rec) { fwrite(rec, sizeof(TemperatureRecord), 1, db); fflush(db); // 确保数据写入磁盘 } int load_records(FILE *db, TemperatureRecord *buffer, int max_records) { fseek(db, 0, SEEK_END); long size = ftell(db); rewind(db); int count = size / sizeof(TemperatureRecord); if (count > max_records) count = max_records; return fread(buffer, sizeof(TemperatureRecord), count, db); }

6. 性能优化与调试技巧

6.1 编译器优化选项

GCC常用优化级别：

-O0：无优化（调试用）
-O1：基础优化
-O2：推荐优化级别
-O3：激进优化（可能增加代码体积）
-Os：优化代码大小

优化实践：

gcc -O2 -march=native -pipe -Wall -o program source.c

6.2 调试工具链

GDB基本命令：

break：设置断点
run：启动程序
next：单步执行
print：查看变量值
backtrace：查看调用栈

Valgrind内存检查：

valgrind --leak-check=full ./program

7. 现代C语言开发实践

7.1 多线程编程

C11标准引入的线程支持：

#include <threads.h> int worker(void *arg) { printf("Thread running\n"); return 0; } int main() { thrd_t thread; thrd_create(&thread, worker, NULL); thrd_join(thread, NULL); return 0; }

7.2 安全编程实践

安全函数替代方案：

使用snprintf代替sprintf
strncpy替代strcpy
fgets替代gets

静态分析工具：

Clang静态分析器
Cppcheck
Coverity Scan

8. 嵌入式开发专项

8.1 寄存器操作模式

典型硬件寄存器访问：

#define GPIO_BASE 0x40020000 #define GPIO_MODE_OFFSET 0x00 volatile uint32_t *gpio_mode = (uint32_t *)(GPIO_BASE + GPIO_MODE_OFFSET); void set_gpio_mode(int pin, int mode) { *gpio_mode &= ~(0x3 << (pin * 2)); // 清除原有模式 *gpio_mode |= (mode & 0x3) << (pin * 2); // 设置新模式 }

8.2 低功耗编程技巧

省电模式实践：

合理使用__attribute__((section(".lowpower")))
外设时钟门控
中断唤醒替代轮询

void enter_low_power_mode() { // 保存关键状态 save_context(); // 配置唤醒源 configure_wakeup_source(); // 进入待机模式 __asm volatile("wfi"); // 恢复执行 restore_context(); }

9. 经典算法实现

9.1 快速排序优化版

void swap(int *a, int *b) { int tmp = *a; *a = *b; *b = tmp; } int partition(int *arr, int low, int high) { int pivot = arr[(low + high) / 2]; // 三数取中优化 swap(&arr[low], &arr[(low + high) / 2]); int i = low, j = high; while (i < j) { while (i < j && arr[j] >= pivot) j--; arr[i] = arr[j]; while (i < j && arr[i] <= pivot) i++; arr[j] = arr[i]; } arr[i] = pivot; return i; } void quick_sort(int *arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); quick_sort(arr, low, pi - 1); quick_sort(arr, pi + 1, high); } }

9.2 常用数据结构实现

动态数组实现示例：

typedef struct { int *data; size_t size; size_t capacity; } Vector; Vector *vector_create(size_t init_capacity) { Vector *v = malloc(sizeof(Vector)); v->data = malloc(init_capacity * sizeof(int)); v->size = 0; v->capacity = init_capacity; return v; } void vector_push_back(Vector *v, int value) { if (v->size >= v->capacity) { v->capacity *= 2; v->data = realloc(v->data, v->capacity * sizeof(int)); } v->data[v->size++] = value; }

10. 跨平台开发策略

10.1 条件编译技巧

#if defined(_WIN32) #include <windows.h> #define PLATFORM_NAME "Windows" #elif defined(__linux__) #include <unistd.h> #define PLATFORM_NAME "Linux" #elif defined(__APPLE__) #include <TargetConditionals.h> #if TARGET_OS_MAC #define PLATFORM_NAME "macOS" #endif #else #error "Unsupported platform" #endif

10.2 构建系统选择

CMake基础配置示例：

cmake_minimum_required(VERSION 3.10) project(MyProject C) set(CMAKE_C_STANDARD 11) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra") add_executable(main src/main.c src/utils.c) if(UNIX AND NOT APPLE) target_link_libraries(main m) # 链接数学库 endif()

11. 代码质量保障

11.1 单元测试框架

使用Unity测试框架示例：

#include "unity.h" #include "calculator.h" void setUp(void) { // 初始化代码 } void tearDown(void) { // 清理代码 } void test_addition(void) { TEST_ASSERT_EQUAL_INT(5, add(2, 3)); } int main(void) { UNITY_BEGIN(); RUN_TEST(test_addition); return UNITY_END(); }

11.2 静态分析集成

Clang静态分析器使用：

scan-build make

12. 性能关键代码优化

12.1 内联汇编应用

int32_t multiply_accumulate(int32_t *array, size_t count) { int32_t sum = 0; __asm__ volatile ( "mov %[count], %%ecx\n" "mov %[array], %%rsi\n" "xor %%eax, %%eax\n" "loop_start:\n" "add (%%rsi), %%eax\n" "add $4, %%rsi\n" "dec %%ecx\n" "jnz loop_start\n" : "=a"(sum) : [array]"r"(array), [count]"r"(count) : "ecx", "rsi", "cc" ); return sum; }

12.2 缓存友好编程

矩阵乘法优化示例：

void matrix_multiply(const double *A, const double *B, double *C, int n) { const int BLOCK_SIZE = 32; for (int i = 0; i < n; i += BLOCK_SIZE) { for (int j = 0; j < n; j += BLOCK_SIZE) { for (int k = 0; k < n; k += BLOCK_SIZE) { // 处理块 for (int ii = i; ii < i + BLOCK_SIZE; ++ii) { for (int kk = k; kk < k + BLOCK_SIZE; ++kk) { double a = A[ii * n + kk]; for (int jj = j; jj < j + BLOCK_SIZE; ++jj) { C[ii * n + jj] += a * B[kk * n + jj]; } } } } } } }

13. 嵌入式AI开发入门

13.1 TensorFlow Lite集成

模型部署基本流程：

转换Keras模型为TFLite格式
使用flatbuffer生成C头文件
实现推理逻辑

#include "tensorflow/lite/micro/all_ops_resolver.h" #include "tensorflow/lite/micro/micro_error_reporter.h" #include "tensorflow/lite/micro/micro_interpreter.h" void run_inference() { tflite::MicroErrorReporter error_reporter; const tflite::Model* model = ::tflite::GetModel(g_model); static tflite::AllOpsResolver resolver; static tflite::MicroInterpreter interpreter( model, resolver, tensor_arena, kTensorArenaSize, &error_reporter); interpreter.AllocateTensors(); // 填充输入数据 float* input = interpreter.input(0)->data.f; memcpy(input, input_data, input_size); interpreter.Invoke(); // 获取输出 float* output = interpreter.output(0)->data.f; }

13.2 模型量化技巧

后训练量化示例：

converter = tf.lite.TFLiteConverter.from_keras_model(model) converter.optimizations = [tf.lite.Optimize.DEFAULT] quantized_model = converter.convert()

14. 工业级项目架构

14.1 模块化设计

典型项目结构：

project/ ├── include/ │ ├── module1.h │ └── module2.h ├── src/ │ ├── module1.c │ ├── module2.c │ └── main.c ├── tests/ ├── third_party/ ├── CMakeLists.txt └── README.md

14.2 接口设计原则

最小化头文件依赖
使用不透明指针隐藏实现细节
提供明确的初始化和清理函数

// 模块接口示例 typedef struct Database_ Database; Database *db_create(const char *config); int db_insert(Database *db, const Record *rec); int db_query(Database *db, Record **results, int *count); void db_destroy(Database *db);

15. 调试与问题排查

15.1 核心转储分析

启用核心转储：

ulimit -c unlimited echo "core.%e.%p" > /proc/sys/kernel/core_pattern

使用GDB分析：

gdb ./program core.1234 bt full # 查看完整调用栈

15.2 日志系统实现

分级日志实现：

typedef enum { LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR } LogLevel; void log_message(LogLevel level, const char *file, int line, const char *fmt, ...) { const char *level_str[] = {"DEBUG", "INFO", "WARN", "ERROR"}; time_t now = time(NULL); struct tm *tm = localtime(&now); fprintf(stderr, "[%04d-%02d-%02d %02d:%02d:%02d][%s][%s:%d] ", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, level_str[level], file, line); va_list args; va_start(args, fmt); vfprintf(stderr, fmt, args); va_end(args); fputc('\n', stderr); } #define LOG(level, ...) log_message(level, __FILE__, __LINE__, __VA_ARGS__)

16. 现代C语言特性

16.1 C11新增特性

泛型选择：

#define cbrt(X) _Generic((X), \ long double: cbrtl, \ default: cbrt, \ float: cbrtf)(X)

匿名结构体/联合体：

struct person { char name[50]; union { int age; float height; }; };

16.2 多线程支持

线程创建示例：

#include <threads.h> int worker(void *arg) { printf("Thread %ld running\n", (long)arg); return 0; } int main() { thrd_t threads[4]; for (long i = 0; i < 4; i++) { thrd_create(&threads[i], worker, (void*)i); } for (int i = 0; i < 4; i++) { thrd_join(threads[i], NULL); } return 0; }

17. 安全编程进阶

17.1 防御性编程技巧

输入验证：

int safe_read_int(FILE *f, int *value) { char buffer[32]; if (!fgets(buffer, sizeof(buffer), f)) return 0; char *endptr; long tmp = strtol(buffer, &endptr, 10); if (endptr == buffer || *endptr != '\n') return 0; *value = (int)tmp; return 1; }

安全字符串处理：

size_t strlcpy(char *dst, const char *src, size_t size) { size_t src_len = strlen(src); if (size > 0) { size_t n = (src_len >= size) ? size - 1 : src_len; memcpy(dst, src, n); dst[n] = '\0'; } return src_len; }

17.2 静态分析集成

使用Clang静态分析器：

scan-build make

18. 嵌入式实时系统

18.1 RTOS集成

FreeRTOS任务创建：

#include "FreeRTOS.h" #include "task.h" void vTaskFunction(void *pvParameters) { for (;;) { // 任务逻辑 vTaskDelay(pdMS_TO_TICKS(100)); } } int main() { xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL); vTaskStartScheduler(); for (;;); return 0; }

18.2 中断处理最佳实践

volatile int irq_flag = 0; void __attribute__((interrupt)) timer_isr(void) { irq_flag = 1; TIMER_IRQ_CLEAR(); // 清除中断标志 } void init_timer_interrupt() { install_isr(TIMER_IRQn, timer_isr); NVIC_EnableIRQ(TIMER_IRQn); TIMER_ENABLE_INTERRUPT(); }

19. 代码重构技巧

19.1 函数拆分原则

重构前：

void process_data(Data *data) { // 验证输入 if (!data ||>int validate_input(const Data *data) { return data &&>#define MAX(a, b) ({ \ typeof(a) _a = (a); \ typeof(b) _b = (b); \ _a > _b ? _a : _b; \ })

调试宏：

#ifdef DEBUG #define DBG_PRINT(fmt, ...) \ fprintf(stderr, "[DEBUG] %s:%d: " fmt "\n", \ __FILE__, __LINE__, ##__VA_ARGS__) #else #define DBG_PRINT(fmt, ...) #endif

20. 跨语言交互

20.1 Python扩展开发

使用Python C API示例：

#include <Python.h> static PyObject* hello_world(PyObject *self, PyObject *args) { printf("Hello from C!\n"); Py_RETURN_NONE; } static PyMethodDef methods[] = { {"hello_world", hello_world, METH_NOARGS, "Print hello world"}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef module = { PyModuleDef_HEAD_INIT, "cext", NULL, -1, methods }; PyMODINIT_FUNC PyInit_cext(void) { return PyModule_Create(&module); }

20.2 Rust FFI集成

Rust调用C代码示例：

// src/lib.rs #[link(name = "mylib", kind = "static")] extern "C" { fn c_add(a: i32, b: i32) -> i32; } pub fn add(a: i32, b: i32) -> i32 { unsafe { c_add(a, b) } }

对应的C头文件：

// mylib.h int c_add(int a, int b);

21. 性能分析工具

21.1 gprof使用指南

编译时添加-pg选项：

gcc -pg -O2 -o program source.c

运行程序生成gmon.out：

./program

分析结果：

gprof program gmon.out > analysis.txt

21.2 perf实战技巧

常用perf命令：

perf stat ./program # 基本统计 perf record ./program # 记录性能数据 perf report # 查看报告 perf annotate # 源码级分析

22. 代码生成技术

22.1 元编程应用

X-Macro技术示例：

#define COLOR_TABLE \ X(RED, 0xFF0000) \ X(GREEN, 0x00FF00) \ X(BLUE, 0x0000FF) enum Color { #define X(name, value) name, COLOR_TABLE #undef X }; const char *color_to_string(enum Color c) { switch (c) { #define X(name, value) case name: return #name; COLOR_TABLE #undef X } return "UNKNOWN"; }

22.2 协议代码生成

使用脚本生成序列化代码：

# generate_protocol.py types = [ ('Login', [('user', 'string'), ('password', 'string')]), ('Message', [('from', 'string'), ('content', 'string')]) ] for name, fields in types: print(f"typedef struct {name}_t {{") for field, type in fields: print(f" {type} {field};") print(f"}} {name};") print()

23. 并发模式实践

23.1 线程池实现

基础线程池结构：

typedef struct { void (*task)(void *); void *arg; } Task; typedef struct { pthread_t *threads; Task *queue; int queue_size; int head, tail; int count; pthread_mutex_t lock; pthread_cond_t not_empty; pthread_cond_t not_full; int shutdown; } ThreadPool; void *worker_thread(void *arg) { ThreadPool *pool = arg; while (1) { pthread_mutex_lock(&pool->lock); while (pool->count == 0 && !pool->shutdown) { pthread_cond_wait(&pool->not_empty, &pool->lock); } if (pool->shutdown) { pthread_mutex_unlock(&pool->lock); pthread_exit(NULL); } Task task = pool->queue[pool->head]; pool->head = (pool->head + 1) % pool->queue_size; pool->count--; pthread_cond_signal(&pool->not_full); pthread_mutex_unlock(&pool->lock); task.task(task.arg); } return NULL; }

23.2 无锁队列设计

基于CAS的队列：

typedef struct { void **buffer; int capacity; volatile int head; volatile int tail; } LockFreeQueue; int lfq_enqueue(LockFreeQueue *q, void *item) { int curr_tail, next_tail; do { curr_tail = q->tail; next_tail = (curr_tail + 1) % q->capacity; if (next_tail == q->head) return 0; // 队列满 } while (!__sync_bool_compare_and_swap(&q->tail, curr_tail, next_tail)); q->buffer[curr_tail] = item; return 1; }

24. 嵌入式调试技巧

24.1 JTAG调试配置

OpenOCD基本配置：

# openocd.cfg interface ftdi ftdi_vid_pid 0x0403 0x6010 transport select jtag source [find target/stm32f4x.cfg] reset_config srst_only

GDB连接命令：

target extended-remote :3333 monitor reset halt load program.elf

24.2 串口调试输出

可靠串口实现：

void uart_putc(char c) { while (!(USART1->SR & USART_SR_TXE)); USART1->DR = c; } void uart_puts(const char *s) { while (*s) { if (*s == '\n') uart_putc('\r'); uart_putc(*s++); } } int _write(int fd, char *ptr, int len) { (void)fd; for (int i = 0; i < len; i++) { uart_putc(ptr[i]); } return len; }

25. 固件更新机制

25.1 安全引导加载程序

双区更新流程：

验证新固件签名
擦除备用区
写入新固件
设置启动标志

int update_firmware(const uint8_t *data, size_t len) { // 验证签名 if (!verify_signature(data, len)) return -1; // 擦除备用区 flash_erase(BACKUP_SECTOR); // 写入数据 for (size_t offset = 0; offset < len; offset += FLASH_PAGE_SIZE) { flash_program(BACKUP_SECTOR + offset, data + offset, MIN(FLASH_PAGE_SIZE, len - offset)); } // 更新启动标志 uint32_t flag = 0xDEADBEEF; flash_program(BOOT_FLAG_ADDR, &flag, sizeof(flag)); return 0; }

25.2 差分更新实现

bsdiff算法集成：

void apply_patch(const uint8_t *old, size_t old_size, const uint8_t *patch, size_t patch_size, uint8_t **new, size_t *new_size) { // 解析补丁头 PatchHeader *hdr = (PatchHeader *)patch; // 分配新缓冲区 *new_size = hdr->new_size; *new = malloc(*new_size); // 应用控制指令 const uint8_t *ctrl = patch + sizeof(PatchHeader); const uint8_t *diff = ctrl + hdr->ctrl_size; const uint8_t *extra = diff + hdr->diff_size; size_t new_pos = 0, old_pos = 0; while (new_pos < *new_size) { // 读取控制指令 int32_t ctrl_diff = read_ctrl(&ctrl); int32_t ctrl_extra = read_ctrl(&ctrl); int32_t ctrl_seek = read_ctrl(&ctrl); // 复制差异数据 for (int i = 0; i < ctrl_diff; i++) { (*new)[new_pos++] = old[old_pos++] + *diff++; } // 添加额外数据 memcpy(*new + new_pos, extra, ctrl_extra); new_pos += ctrl_extra; extra += ctrl_extra; // 移动旧数据位置 old_pos += ctrl_seek; } }

26. 硬件加速接口

26.1 SIMD指令优化

AVX2向量化示例：

#include <immintrin.h> void vector_add(float *a, float *b, float *c, int n) { for (int i = 0; i < n; i += 8) { __m256 va = _mm256_load_ps(a + i); __m256 vb = _mm256_load_ps(b + i); __m256 vc = _mm256_add_ps(va, vb); _mm256_store_ps(c + i, vc); } }

26.2 GPU加速计算

OpenCL内核示例：

__kernel void vector_add( __global const float *a, __global const float *b, __global float *c) { int gid = get_global_id(0); c[gid] = a[gid] + b[gid]; }

主机端代码：

cl_program program = clCreateProgramWithSource( context, 1, (const char**)&source, NULL, &err); clBuildProgram(program, 1, &device, NULL, NULL, NULL); cl_kernel kernel = clCreateKernel(program, "vector_add", &err); clSetKernelArg(kernel, 0, sizeof(cl_mem), &a_mem); clSetKernelArg(kernel, 1, sizeof(cl_mem), &b_mem); clSetKernelArg(kernel, 2, sizeof(cl_mem), &c_mem); size_t global_size = N; clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &global_size, NULL, 0, NULL, NULL);

27. 测试驱动开发

27.1 Unity测试框架

测试用例示例：

#include "unity.h" #include "stack.h" Stack *stack; void setUp(void) { stack = stack_create(10); } void tearDown(void) { stack_destroy(stack); } void test_stack_push_pop(void) { TEST_ASSERT_EQUAL_INT(0, stack_size(stack)); stack_push(stack, 42);

查看全文

http://www.jsqmd.com/news/1210801/