文章目录

在这里插入图片描述

每日一句正能量

越是难时，越要站稳脚跟，挺起脊梁；越是险时，越要提着一口气，咬牙硬撑。
“难”是压力，让人想弯腰；“险”是危机，让人想泄气。站稳、挺直，是为了不散架——身体不乱晃，心智才不崩塌。咬牙不是痛苦，是告诉自己：“我可以软，但不是现在。”

摘要

摘要：从裸机（Bare Metal）程序迁移到RTOS是嵌入式开发中的关键转折点。本文系统性地对比裸机与RTOS的执行模型差异，深入解析中断处理的Deferred Processing重构模式、临界区保护的粒度优化策略，并提供完整的迁移决策树与工程实践案例，帮助开发者平稳完成架构升级。

一、引言：何时需要迁移到RTOS？

许多嵌入式项目从简单的裸机程序开始——一个main()函数中的while(1)超级循环，配合若干中断服务程序（ISR）。随着功能复杂度增加，这种架构逐渐暴露出严重问题：

  • 响应延迟不可预测：长任务阻塞了其他功能的及时处理
  • 代码耦合严重：各功能模块纠缠在超级循环中
  • 低功耗难以实现：CPU空转等待事件
  • 扩展困难：新增功能需要修改现有代码结构

在这里插入图片描述

上图展示了裸机与RTOS执行模型的本质差异。裸机采用顺序执行的超级循环，ISR直接打断主流程；RTOS则通过抢占式调度器实现多任务并发，每个功能独立成任务，由调度器统一管理。

二、裸机 vs RTOS：执行模型深度对比

2.1 裸机超级循环模型

/* 典型裸机程序结构 */
int main(void)
{
    hardware_init();
    timer_init();
    interrupt_enable();
    
    while (1) {
        read_sensors();      /* 读取传感器 */
        process_data();      /* 数据处理（可能耗时） */
        update_display();    /* 更新显示 */
        check_buttons();     /* 检查按键 */
        check_uart();        /* 检查串口 */
        delay_ms(10);        /* 延时等待 */
    }
}

核心问题：

  • process_data()耗时较长时，UART数据可能丢失
  • delay_ms()期间CPU空转，浪费功耗
  • 各功能模块优先级相同，紧急事件无法抢占
  • ISR中直接处理数据，可能错过其他中断

2.2 RTOS多任务调度模型

/* RTOS版本：功能拆分为独立任务 */
void sensor_task(void *pvParameters)
{
    while (1) {
        read_sensors();
        xQueueSend(sensor_queue, &data, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void process_task(void *pvParameters)
{
    sensor_data_t data;
    while (1) {
        xQueueReceive(sensor_queue, &data, portMAX_DELAY);
        process_data(&data);
        xSemaphoreGive(process_sem);
    }
}

void display_task(void *pvParameters)
{
    while (1) {
        xSemaphoreTake(display_sem, portMAX_DELAY);
        update_display();
    }
}

在这里插入图片描述

上图对比了两种执行模型：裸机是顺序执行的超级循环，RTOS是抢占式多任务调度。RTOS中，高优先级任务可立即抢占低优先级任务，ISR通过通知机制唤醒相关任务，系统响应时间变得可预测。

三、中断处理重构：从"大ISR"到"Deferred Processing"

3.1 裸机中断处理的痛点

在裸机程序中，ISR往往承担了过多工作：

/* 裸机风格：ISR直接处理所有逻辑 */
void TIM2_IRQHandler(void)
{
    __disable_irq();  /* 关中断，防止重入 */
    
    /* 读取传感器数据 */
    uint16_t adc_val = ADC1->DR;
    
    /* 数据处理（滤波、计算） */
    float voltage = adc_val * 3.3f / 4096.0f;
    float temperature = (voltage - 0.5f) / 0.01f;
    
    /* 更新显示 */
    char buf[16];
    sprintf(buf, "Temp: %.1fC", temperature);
    LCD_ShowString(10, 10, buf);
    
    /* 清除中断标志 */
    TIM2->SR &= ~TIM_SR_UIF;
    
    __enable_irq();
}

问题分析：

  • ISR执行时间长达数百微秒，阻塞了其他中断
  • 在ISR中调用printf/sprintf等不可重入函数，极其危险
  • LCD操作可能涉及I2C/SPI通信，进一步延长ISR时间
  • 无法被更高优先级中断抢占（如果使用了中断优先级分组）

3.2 RTOS中断处理重构：Top Half + Bottom Half

RTOS推荐的中断处理模式是Deferred Processing（延迟处理），将ISR拆分为两部分：

在这里插入图片描述

上图对比了裸机与RTOS的中断处理模型。裸机ISR直接处理所有逻辑，耗时不可控；RTOS采用短ISR（Top Half）+ 高优先级任务（Bottom Half）模式，ISR只读取数据和通知任务，耗时处理在任务中完成。

重构后的代码：

/* RTOS风格：ISR极短，只通知任务 */
void TIM2_IRQHandler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    /* 只读取原始数据 */
    uint16_t adc_val = ADC1->DR;
    
    /* 清除中断标志 */
    TIM2->SR &= ~TIM_SR_UIF;
    
    /* 通知处理任务（从ISR安全） */
    xSemaphoreGiveFromISR(process_sem, &xHigherPriorityTaskWoken);
    
    /* 上下文切换（如果需要） */
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

/* 高优先级任务处理数据 */
void process_task(void *pvParameters)
{
    while (1) {
        /* 等待ISR通知 */
        xSemaphoreTake(process_sem, portMAX_DELAY);
        
        /* 安全地读取数据 */
        uint16_t adc_val = get_latest_adc();
        
        /* 耗时处理（在任务中，可被中断） */
        float voltage = adc_val * 3.3f / 4096.0f;
        float temperature = (voltage - 0.5f) / 0.01f;
        
        /* 发送给显示任务 */
        xQueueSend(display_queue, &temperature, portMAX_DELAY);
    }
}

3.3 ISR与任务通信机制选择

机制 适用场景 ISR安全 数据传递
xSemaphoreGiveFromISR 简单事件通知 是 无
xQueueSendFromISR 传递数据 是 有
xTaskNotifyFromISR 直接任务通知 是 32位值
vTaskSetThreadLocalStoragePointer 线程数据 否 指针

推荐实践：

  • 简单通知（如定时器到期）：使用Semaphore
  • 传递数据（如ADC采样值）：使用Queue
  • 一对一高效通知：使用Task Notification
/* 使用Queue从ISR传递数据 */
void ADC_IRQHandler(void)
{
    BaseType_t xHPW = pdFALSE;
    uint16_t adc_val = ADC1->DR;
    
    xQueueSendFromISR(adc_queue, &adc_val, &xHPW);
    portYIELD_FROM_ISR(xHPW);
}

/* 任务接收 */
void adc_process_task(void *pv)
{
    uint16_t adc_val;
    while (1) {
        xQueueReceive(adc_queue, &adc_val, portMAX_DELAY);
        /* 处理数据 */
    }
}

四、临界区重构：从"全局关中断"到"精细化保护"

4.1 裸机临界区保护方式

裸机程序中，保护临界区最直接的方法是关中断：

/* 裸机方式1：全局关中断 */
void critical_section_baremetal(void)
{
    __disable_irq();           /* 关中断 */
    shared_counter++;          /* 临界区 */
    __enable_irq();            /* 开中断 */
}

/* 裸机方式2：保存PRIMASK（支持嵌套） */
void critical_section_nested(void)
{
    uint32_t primask = __get_PRIMASK();
    __disable_irq();
    
    buffer[index] = data;      /* 临界区 */
    
    __set_PRIMASK(primask);   /* 恢复中断状态 */
}

问题：

  • 关中断影响所有中断源，包括不相关的定时器、通信中断
  • 临界区过长时，系统响应延迟不可预测
  • 不支持嵌套（方式1）或需要手动管理（方式2）

4.2 RTOS临界区保护方式

RTOS提供了多种粒度可控的临界区保护机制：

在这里插入图片描述

上图对比了裸机与RTOS的临界区保护方式。裸机只能全局关中断，影响所有中断源；RTOS提供了调度器锁定、互斥锁、关中断等多种机制，可根据场景选择最合适的保护粒度。

方式1：调度器锁定（推荐用于任务级保护）

/* FreeRTOS: 挂起调度器，不关闭中断 */
void critical_section_scheduler(void)
{
    vTaskSuspendAll();         /* 挂起调度器 */
    
    /* 临界区：此时不会发生任务切换 */
    shared_counter++;
    memcpy(buffer, data, len);
    
    xTaskResumeAll();          /* 恢复调度器 */
}

方式2：互斥锁（推荐用于共享资源）

/* 使用Mutex保护共享资源 */
SemaphoreHandle_t data_mutex;

void init(void)
{
    data_mutex = xSemaphoreCreateMutex();
}

void critical_section_mutex(void)
{
    xSemaphoreTake(data_mutex, portMAX_DELAY);
    
    /* 临界区 */
    shared_buffer.head = (shared_buffer.head + 1) % BUFFER_SIZE;
    shared_buffer.data[shared_buffer.head] = new_data;
    
    xSemaphoreGive(data_mutex);
}

方式3：关中断（仅用于ISR相关临界区）

/* 仅在需要保护ISR访问的数据时使用 */
void critical_section_interrupt(void)
{
    uint32_t mask = taskENTER_CRITICAL();
    
    /* 临界区：中断被关闭 */
    timer_count++;
    
    taskEXIT_CRITICAL(mask);
}

4.3 临界区保护方法对比

方法 适用范围 影响范围 延迟 推荐度
裸机关中断 简单保护 所有中断 不可预测 ★★
裸机保存PRIMASK 嵌套临界区 所有中断 不可预测 ★★★
RTOS调度器锁定 任务级保护 任务调度 可控 ★★★★
RTOS互斥锁 共享资源 仅等待锁的任务 可控 ★★★★★
RTOS关中断 ISR相关临界区 同优先级中断 最小 ★★★★

五、迁移决策树与实施步骤

5.1 何时应该迁移？

在这里插入图片描述

上图提供了迁移决策树和详细对照表。如果系统有多个独立功能、实时性要求、模块化需求、复杂状态机或低功耗需求，强烈建议迁移到RTOS。

5.2 迁移实施六步法

Step 1：识别独立功能模块

分析现有代码，将超级循环中的功能拆分为独立模块：

/* 裸机：所有功能在main循环中 */
while (1) {
    read_sensor();    /* -> sensor_task */
    process_data();   /* -> process_task */
    update_lcd();     /* -> display_task */
    check_uart();     /* -> comm_task */
    delay_ms(10);
}

Step 2：将ISR拆分为Top/Bottom

/* 重构前：ISR处理所有逻辑 */
void ISR_old(void) {
    read_data();
    process_data();
    clear_flag();
}

/* 重构后：ISR只通知任务 */
void ISR_new(void) {
    BaseType_t xHPW = pdFALSE;
    xSemaphoreGiveFromISR(task_sem, &xHPW);
    portYIELD_FROM_ISR(xHPW);
}

Step 3：用任务替代超级循环

/* 为每个功能创建独立任务 */
xTaskCreate(sensor_task, "Sensor", 512, NULL, 3, NULL);
xTaskCreate(process_task, "Process", 512, NULL, 2, NULL);
xTaskCreate(display_task, "Display", 256, NULL, 1, NULL);
xTaskCreate(comm_task, "Comm", 512, NULL, 2, NULL);

Step 4：用同步原语替代关中断

/* 替换前 */
__disable_irq();
shared_data = value;
__enable_irq();

/* 替换后 */
xSemaphoreTake(data_mutex, portMAX_DELAY);
shared_data = value;
xSemaphoreGive(data_mutex);

Step 5：配置任务优先级和栈大小

/* 优先级设计原则 */
#define PRIO_SENSOR     4   /* 最高：数据采集 */
#define PRIO_PROCESS    3   /* 高：数据处理 */
#define PRIO_COMM       2   /* 中：通信 */
#define PRIO_DISPLAY    1   /* 低：显示 */
#define PRIO_IDLE       0   /* 最低：空闲 */

/* 栈大小估算 */
#define STACK_SENSOR    512  /* 简单IO操作 */
#define STACK_PROCESS   1024 /* 浮点运算，局部数组 */
#define STACK_COMM      768  /* 协议解析 */

Step 6：测试和优化时序

/* 使用时序分析工具 */
void timing_analysis(void)
{
    TickType_t start = xTaskGetTickCount();
    
    /* 执行被测代码 */
    process_data();
    
    TickType_t elapsed = xTaskGetTickCount() - start;
    printf("Process time: %lu ms\r\n", elapsed);
}

六、完整迁移工程示例

6.1 项目背景

温湿度监控系统：STM32F4 + DHT22传感器 + LCD显示 + UART通信

在这里插入图片描述

上图展示了完整的迁移工程示例。裸机版本将所有功能集中在while(1)循环中；RTOS版本将功能拆分为sensor、process、display、comm四个独立任务，通过Queue和Semaphore协作。

6.2 裸机版本代码

/* baremetal_main.c */
#include "stm32f4xx.h"
#include "dht22.h"
#include "lcd.h"
#include "uart.h"

volatile uint32_t timer_flag = 0;
volatile float g_temperature = 0;
volatile float g_humidity = 0;

void TIM2_IRQHandler(void)
{
    if (TIM2->SR & TIM_SR_UIF) {
        __disable_irq();
        timer_flag = 1;
        TIM2->SR &= ~TIM_SR_UIF;
        __enable_irq();
    }
}

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    DHT22_Init();
    LCD_Init();
    UART_Init();
    TIM2_Init(1000);  /* 1秒定时 */
    
    while (1) {
        if (timer_flag) {
            timer_flag = 0;
            
            /* 读取传感器（约25ms，阻塞） */
            DHT22_Read(&g_temperature, &g_humidity);
            
            /* 数据处理 */
            char buf[32];
            sprintf(buf, "T:%.1f H:%.1f", g_temperature, g_humidity);
            
            /* 更新显示（约10ms，阻塞） */
            LCD_ShowString(0, 0, buf);
            
            /* 发送数据（约5ms，阻塞） */
            UART_Send(buf, strlen(buf));
        }
        
        /* 按键检测（轮询，浪费CPU） */
        if (KEY_Scan()) {
            LCD_Clear();
        }
    }
}

6.3 RTOS重构版本

/* rtos_main.c */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "dht22.h"
#include "lcd.h"
#include "uart.h"

/* 同步原语 */
QueueHandle_t sensor_queue;
SemaphoreHandle_t lcd_sem;
SemaphoreHandle_t timer_sem;

/* 数据结构 */
typedef struct {
    float temperature;
    float humidity;
    uint32_t timestamp;
} sensor_data_t;

/* ISR：极短，只通知 */
void TIM2_IRQHandler(void)
{
    BaseType_t xHPW = pdFALSE;
    if (TIM2->SR & TIM_SR_UIF) {
        TIM2->SR &= ~TIM_SR_UIF;
        xSemaphoreGiveFromISR(timer_sem, &xHPW);
        portYIELD_FROM_ISR(xHPW);
    }
}

/* 传感器任务：优先级4 */
void sensor_task(void *pvParameters)
{
    sensor_data_t data;
    
    while (1) {
        /* 等待定时器通知 */
        xSemaphoreTake(timer_sem, portMAX_DELAY);
        
        /* 读取传感器 */
        DHT22_Read(&data.temperature, &data.humidity);
        data.timestamp = xTaskGetTickCount();
        
        /* 发送给处理任务 */
        xQueueSend(sensor_queue, &data, portMAX_DELAY);
    }
}

/* 处理任务：优先级3 */
void process_task(void *pvParameters)
{
    sensor_data_t data;
    static float temp_avg = 0;
    static uint32_t count = 0;
    
    while (1) {
        xQueueReceive(sensor_queue, &data, portMAX_DELAY);
        
        /* 滤波计算 */
        temp_avg = (temp_avg * count + data.temperature) / (count + 1);
        count++;
        
        /* 通知显示任务 */
        xSemaphoreGive(lcd_sem);
        
        /* 发送给通信任务 */
        xQueueSend(comm_queue, &data, portMAX_DELAY);
    }
}

/* 显示任务：优先级1 */
void display_task(void *pvParameters)
{
    sensor_data_t data;
    char buf[32];
    
    while (1) {
        xSemaphoreTake(lcd_sem, portMAX_DELAY);
        
        /* 获取最新数据（从共享变量或队列） */
        xQueuePeek(sensor_queue, &data, 0);
        
        snprintf(buf, sizeof(buf), "T:%.1f H:%.1f", 
                 data.temperature, data.humidity);
        LCD_ShowString(0, 0, buf);
    }
}

/* 通信任务：优先级2 */
void comm_task(void *pvParameters)
{
    sensor_data_t data;
    char buf[64];
    
    while (1) {
        xQueueReceive(comm_queue, &data, portMAX_DELAY);
        
        snprintf(buf, sizeof(buf), "{\"t\":%.1f,\"h\":%.1f,\"ts\":%lu}\r\n",
                 data.temperature, data.humidity, data.timestamp);
        UART_Send(buf, strlen(buf));
    }
}

/* 按键任务：优先级2 */
void button_task(void *pvParameters)
{
    while (1) {
        /* 阻塞等待按键中断通知 */
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        
        LCD_Clear();
        LOG_Info("LCD cleared by button");
    }
}

/* 按键ISR */
void EXTI0_IRQHandler(void)
{
    BaseType_t xHPW = pdFALSE;
    if (EXTI->PR & EXTI_PR_PR0) {
        EXTI->PR = EXTI_PR_PR0;
        vTaskNotifyGiveFromISR(button_task_handle, &xHPW);
        portYIELD_FROM_ISR(xHPW);
    }
}

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    
    /* 创建同步原语 */
    sensor_queue = xQueueCreate(5, sizeof(sensor_data_t));
    comm_queue = xQueueCreate(5, sizeof(sensor_data_t));
    lcd_sem = xSemaphoreCreateBinary();
    timer_sem = xSemaphoreCreateBinary();
    
    /* 创建任务 */
    xTaskCreate(sensor_task, "Sensor", 512, NULL, 4, NULL);
    xTaskCreate(process_task, "Process", 1024, NULL, 3, NULL);
    xTaskCreate(display_task, "Display", 512, NULL, 1, NULL);
    xTaskCreate(comm_task, "Comm", 768, NULL, 2, NULL);
    xTaskCreate(button_task, "Button", 256, NULL, 2, &button_task_handle);
    
    /* 初始化硬件 */
    DHT22_Init();
    LCD_Init();
    UART_Init();
    TIM2_Init(1000);
    Button_Init();
    
    vTaskStartScheduler();
    
    while (1);  /* 不应该到达这里 */
}

6.4 重构后的优势

指标 裸机版本 RTOS版本 提升
传感器读取周期 固定1秒 精确1秒（任务延迟） 精确可控
UART响应延迟 最长1秒（等待主循环） 立即（独立任务） 实时性
按键响应 轮询检测 中断+任务通知 即时响应
CPU空闲时间 0%（空转delay） >80%（可进入低功耗） 功耗
代码模块化 差（耦合在main） 优（独立任务） 可维护性
新增功能难度 需修改main循环 新增独立任务 扩展性

七、兼容性设计：平滑迁移策略

7.1 渐进式迁移

不需要一次性重写所有代码，可以采用渐进式策略：

Phase 1：引入RTOS内核，保持裸机风格

/* 先引入RTOS，但保持超级循环结构 */
void legacy_task(void *pvParameters)
{
    while (1) {
        /* 原有裸机代码，稍作修改 */
        read_sensors();
        process_data();
        update_display();
        
        vTaskDelay(pdMS_TO_TICKS(10));  /* 替换delay_ms */
    }
}

int main(void)
{
    xTaskCreate(legacy_task, "Legacy", 1024, NULL, 1, NULL);
    vTaskStartScheduler();
}

Phase 2：逐步拆分功能模块

/* 将独立功能逐个拆分为任务 */
void sensor_task(void *pvParameters) { /* ... */ }
void display_task(void *pvParameters) { /* ... */ }

/* 在主任务中协调 */
void legacy_task(void *pvParameters)
{
    while (1) {
        /* 只保留无法立即拆分的逻辑 */
        process_data();
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

Phase 3：完全RTOS化

/* 最终：所有功能都是独立任务 */
void sensor_task(void *pv) { /* ... */ }
void process_task(void *pv) { /* ... */ }
void display_task(void *pv) { /* ... */ }
void comm_task(void *pv) { /* ... */ }

7.2 兼容层设计

为便于迁移，可以设计兼容层：

/* compatibility.h */
#ifdef USE_RTOS
    #include "FreeRTOS.h"
    #include "task.h"
    #define DELAY_MS(ms)    vTaskDelay(pdMS_TO_TICKS(ms))
    #define CRITICAL_ENTER()  taskENTER_CRITICAL()
    #define CRITICAL_EXIT()   taskEXIT_CRITICAL()
#else
    #define DELAY_MS(ms)    HAL_Delay(ms)
    #define CRITICAL_ENTER()  __disable_irq()
    #define CRITICAL_EXIT()   __enable_irq()
#endif

八、常见问题与解决方案

8.1 中断延迟增加

问题：引入RTOS后，中断入口需要保存更多寄存器，延迟增加。

解决：

  • 使用零中断延迟的RTOS端口（如FreeRTOS的configKERNEL_INTERRUPT_PRIORITY）
  • 将关键中断设置为高于configMAX_SYSCALL_INTERRUPT_PRIORITY
  • 使用硬件FPU减少浮点上下文保存时间

8.2 栈溢出

问题：任务栈大小估算不足。

解决：

  • 启用configCHECK_FOR_STACK_OVERFLOW
  • 使用uxTaskGetStackHighWaterMark()监控
  • 初始栈大小设为估算值的1.5倍

8.3 优先级翻转

问题：低优先级任务持有锁，高优先级任务阻塞。

解决：

  • 使用Mutex替代Binary Semaphore（Mutex支持优先级继承）
  • 设计合理的任务优先级
  • 减小临界区粒度

8.4 内存碎片

问题：频繁动态分配导致内存碎片。

解决：

  • 使用静态内存分配（xTaskCreateStatic、xQueueCreateStatic）
  • 预分配对象池
  • 避免在运行时频繁创建/删除任务

九、最佳实践总结

9.1 设计模式推荐

模式 适用场景 实现方式
Deferred Interrupt 所有中断处理 ISR通知 + 任务处理
Producer-Consumer 数据流处理 Queue连接生产者和消费者
Observer 事件分发 Event Group或Task Notification
State Machine 复杂协议 任务内状态机 + 事件驱动
Resource Pool 共享硬件 Mutex保护 + 资源计数

9.2 迁移检查清单

  • 识别所有ISR，拆分为Top/Bottom
  • 将超级循环功能拆分为独立任务
  • 用Queue/Semaphore替代全局变量标志
  • 用Mutex替代__disable_irq()
  • 配置合理的任务优先级
  • 估算并分配足够的栈空间
  • 测试中断延迟和任务响应时间
  • 验证低功耗模式兼容性

十、总结

从裸机到RTOS的迁移是嵌入式软件架构的质变。核心要点：

  1. 中断处理：从"大ISR"重构为"短ISR + 高优先级任务"的Deferred Processing模式
  2. 临界区保护：从"全局关中断"重构为"调度器锁定/互斥锁/精细关中断"的多级保护
  3. 任务设计：从"顺序执行"重构为"事件驱动、优先级调度"的并发模型
  4. 渐进迁移：不必一次性重写，可以分阶段引入RTOS特性

掌握这些重构模式后，开发者可以在保持系统稳定性的前提下，逐步享受RTOS带来的实时性、模块化和低功耗优势。

转载自：https://blog.csdn.net/u014727709/article/details/162496130
欢迎 👍点赞✍评论⭐收藏，欢迎指正

# 重构 # 设计模式 # java
Logo
亚马逊云科技技术品牌专区

更多推荐

2026年量化工具选择，要跟着能力基础走

读者应理解，选择工具前要先判断自己的能力基础和当前任务。工具应该帮助自己补上当前最关键的缺口，而不是替代学习顺序本身。

avatar 亚马逊云科技技术品牌专区

加州理工 CS367 C 语言系统编程笔记（一）

C语言是一种强大且广泛使用的编程语言，尤其在系统编程领域。本节课我们将学习C语言的基础语法，包括如何编写“Hello, World!”程序、声明变量以及使用基本数据类型。我们将通过实际的代码示例来加深理解。本节课中我们一起学习了C语言的基础语法，包括如何编写和运行一个简单的C程序、声明变量以及使用基本数据类型。我们还介绍了如何使用Shell环境来编译和运行程序。通过对比Java，你可以看到C语言在

avatar 亚马逊云科技技术品牌专区

近期零基础学量化，先按基础差异拆学习顺序

读者应明白，拆解学习顺序时要先看自己的基础缺口，再决定哪一段需要放慢。不同流程阶段都有不同检查任务，学习路线要能反映这些差异。

avatar 亚马逊云科技技术品牌专区