扫描关注 一起学嵌入式 ，一起学习，一起成长

在嵌入式系统开发中，C语言因其接近硬件、执行效率高、资源占用少等优势长期占据主导地位。

不过，随着嵌入式系统变得越来越复杂，C++的面向对象特性、模板、RAII等高级功能为开发大型复杂嵌入式系统提供了更好的抽象能力和代码组织方式。

在现代嵌入式开发中，C与C++混合编程已成为常见实践。

C与C++的主要差异

编译与链接差异

• 名称修饰（Name Mangling） ：C++支持函数重载，因此编译器会对函数名进行修饰以区分不同版本，而C语言没有这一机制

• 类型安全 ：C++有更严格的类型检查系统

• 异常处理 ：C++支持异常机制，而C语言没有

语法和特性差异

// C语言代码示例
typedefstruct {
int x;
int y;
} Point;

voidpoint_init(Point* p, int x, int y){
p->x = x;
p->y = y;
}

// C++代码示例
classPoint{
private:
int x, y;
public:
Point(int x, int y) : x(x), y(y) {}
intgetXconst{ return x; }
intgetYconst{ return y; }
};

C调用C++函数的实现方法

使用extern “C”包装C++函数

// C++头文件: math_utils.h
#ifdef __cplusplus
extern"C"{
#endif

// 这些函数使用C链接约定，可以被C代码调用
intadd(int a, int b);
doublecalculate_circle_area(double radius);

#ifdef __cplusplus
}
#endif

// C++实现文件: math_utils.cpp
#include"math_utils.h"
#include

classMathCalculator{
public:
staticintaddNumbers(int a, int b){
return a + b;
}

staticdoublecircleArea(double radius){
return M_PI * radius * radius;
}
};

// C链接的函数实现
intadd(int a, int b){
return MathCalculator::addNumbers(a, b);
}

doublecalculate_circle_area(double radius){
return MathCalculator::circleArea(radius);
}

C代码调用示例

// C主程序: main.c
#include
#include"math_utils.h"

intmain{
int result = add(5,3);
printf("5 + 3 = %d
", result);

double area = calculate_circle_area(2.5);
printf("Circle area with radius 2.5: %f
", area);

return0;
}

C++调用C函数的实现方法

在C++中包含C头文件

// C头文件: hardware_io.h
#ifndef HARDWARE_IO_H
#define HARDWARE_IO_H

#ifdef __cplusplus
extern"C"{
#endif

voidport_init(void);
voidwrite_port(uint8_t value);
uint8_tread_port(void);
voiddelay_ms(uint32_t milliseconds);

#ifdef __cplusplus
}
#endif

#endif// HARDWARE_IO_H

// C实现文件: hardware_io.c
#include"hardware_io.h"
#include

// 假设的硬件寄存器地址
volatileuint8_t* PORT_REGISTER = (volatileuint8_t*)0x1000;
volatileuint8_t* DATA_REGISTER = (volatileuint8_t*)0x1001;

voidport_init(void){
*PORT_REGISTER =0xFF; // 设置为输出模式
}

voidwrite_port(uint8_t value){
*DATA_REGISTER = value;
}

uint8_tread_port(void){
return *DATA_REGISTER;
}

voiddelay_ms(uint32_t milliseconds){
// 简化的延时实现
for (volatileuint32_t i = ; i0 1000; i++);
}

C++代码调用C函数

// C++类封装硬件操作: io_controller.cpp
#include"hardware_io.h"

classIOController{
private:
bool initialized;

public:
IOController : initialized(false) {}

voidinitialize{
port_init;
initialized =true;
}

voidwriteData(uint8_t data){
if (!initialized) return;
write_port(data);
}

uint8_treadData{
if (!initialized) return0;
return read_port;
}

voiddelay(uint32_t ms){
delay_ms(ms);
}
};

// 使用示例
classLEDController{
private:
IOController& io;

public:
LEDController(IOController& ioCtrl) : io(ioCtrl) {}

voidblinkLED(uint8_t times){
io.initialize;
for (uint8_t i =0; i
io.writeData(0xFF); // 所有LED亮
io.delay(500);
io.writeData(0x00); // 所有LED灭
io.delay(500);
}
}
};

混合编程中的内存管理

统一的内存分配策略

// memory_manager.h
#ifdef __cplusplus
extern"C"{
#endif

void* allocate_memory(size_t size);
voidfree_memory(void* ptr);
void* reallocate_memory(void* ptr, size_t new_size);

#ifdef __cplusplus
}
#endif

// memory_manager.cpp
#include"memory_manager.h"
#include

// 使用C++ RAII管理内存
classMemoryPool{
private:
staticconstsize_t POOL_SIZE =4096;
uint8_t pool[POOL_SIZE];
size_t used;

public:
MemoryPool : used(0) {}

void* allocate(size_t size){
if (used + size > POOL_SIZE) {
returnmalloc(size); // 回退到系统malloc
}
void* ptr = &pool[used];
used += size;
return ptr;
}

voidreset{
used =0;
}
};

static MemoryPool memoryPool;

void* allocate_memory(size_t size){
return memoryPool.allocate(size);
}

voidfree_memory(void* ptr){
// 只有在指针不在内存池中时才真正释放
if (ptr static_castvoid*>(memoryPool.pool) ||
ptr >= static_castvoid*>(memoryPool.pool + memoryPool.POOL_SIZE)) {
free(ptr);
}
}

void* reallocate_memory(void* ptr, size_t new_size){
// 简化实现 - 实际项目中需要更复杂的逻辑
void* new_ptr = allocate_memory(new_size);
if (ptr && new_ptr) {
// 需要知道旧块的大小，这里简化处理
// memcpy(new_ptr, ptr, min(old_size, new_size));
}
free_memory(ptr);
return new_ptr;
}

数据结构和类型转换

兼容的数据结构设计

// common_types.h
#ifndef COMMON_TYPES_H
#define COMMON_TYPES_H

#include

#ifdef __cplusplus
extern"C"{
#endif

// C风格的结构体，保证C和C++兼容
typedefstruct {
uint32_t id;
int32_t x;
int32_t y;
uint8_t status;
} sensor_data_t;

typedefstruct {
uint16_t command;
uint8_t data[32];
uint8_t length;
} command_packet_t;

// C接口函数
voidprocess_sensor_data(constsensor_data_t* data);
uint8_tsend_command(constcommand_packet_t* packet);

#ifdef __cplusplus
}
#endif

#endif// COMMON_TYPES_H

C++封装类

// sensor_wrapper.cpp
#include"common_types.h"
#include

classSensorData{
private:
sensor_data_t raw_data;

public:
SensorData(uint32_t id, int32_t x, int32_t y) {
raw_data.id = id;
raw_data.x = x;
raw_data.y = y;
raw_data.status =0;
}

// 转换为C兼容类型
constsensor_data_t* getRawDataconst{
return &raw_data;
}

voidprocess{
process_sensor_data(&raw_data);
}

uint32_tgetIdconst{ return raw_data.id; }
int32_tgetXconst{ return raw_data.x; }
int32_tgetYconst{ return raw_data.y; }
};

classCommandHandler{
private:
std::vectorcommand_packet_t> command_history;

public:
boolsendCommand(uint16_t cmd, constuint8_t* data, uint8_t length){
if (length >32) returnfalse;

command_packet_t packet;
packet.command = cmd;
packet.length = length;
for (uint8_t i =0; i
packet.data[i] = data[i];
}

bool success = (send_command(&packet) ==1);
if (success) {
command_history.push_back(packet);
}

return success;
}
};

构建系统和编译配置

Makefile示例

# 编译器定义
CC = gcc
CXX = g++
AR = ar

# 编译选项
CFLAGS = -Wall -Wextra -Os -std=c99
CXXFLAGS = -Wall -Wextra -Os -std=c++11 -fno-exceptions -fno-rtti
LDFLAGS = -lm

# 包含路径
INCLUDES = -I./include -I./c_lib

# 源文件
C_SOURCES =$(wildcard c_lib/*.c)
CPP_SOURCES =$(wildcard cpp_src/*.cpp)

# 目标文件
C_OBJECTS = $(C_SOURCES:.c=.o)
CPP_OBJECTS = $(CPP_SOURCES:.cpp=.o)

# 最终目标
TARGET = embedded_app

# 构建规则
all: $(TARGET)

$(TARGET):$(C_OBJECTS)$(CPP_OBJECTS)
$(CXX)-o$@$^$(LDFLAGS)

%.o: %.c
$(CC)$(CFLAGS)$(INCLUDES)-c$ -o $@

%.o: %.cpp
$(CXX)$(CXXFLAGS)$(INCLUDES) -c $ -o $@

clean:
 rm -f $(C_OBJECTS)$(CPP_OBJECTS)$(TARGET)

.PHONY: all clean

CMake配置示例

cmake_minimum_required(VERSION 3.10)
project(EmbeddedMixedProgramming C CXX)

# 设置C标准
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)

# 设置C++标准
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 嵌入式特定选项
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Os")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Os -fno-exceptions -fno-rtti")

# 包含目录
include_directories(include c_lib)

# 源文件
file(GLOB C_SOURCES "c_lib/*.c")
file(GLOB CPP_SOURCES "cpp_src/*.cpp")

# 创建可执行文件
add_executable(${PROJECT_NAME} ${C_SOURCES} ${CPP_SOURCES})

# 链接库
target_link_libraries(${PROJECT_NAME} m)

注意事项

头文件设计原则

// 良好的头文件示例: mixed_interface.h
#ifndef MIXED_INTERFACE_H
#define MIXED_INTERFACE_H

#include

// 条件编译确保C++和C兼容
#ifdef __cplusplus
// C++特定声明
classCppClass{
public:
CppClass;
voiddoSomething;
};

extern"C"{
#endif

// C兼容的声明
typedefstruct {
uint32_t value;
uint8_t flags;
} common_struct_t;

intc_compatible_function(common_struct_t* data);
voidanother_c_function(void);

#ifdef __cplusplus
} // extern "C"
#endif

#endif// MIXED_INTERFACE_H

错误处理策略

// error_handling.h
#ifdef __cplusplus
extern"C"{
#endif

typedefenum {
ERROR_NONE =0,
ERROR_INVALID_PARAM,
ERROR_MEMORY_ALLOC,
ERROR_HARDWARE,
ERROR_TIMEOUT
} error_code_t;

error_code_tget_last_error(void);
constchar* error_to_string(error_code_t error);

#ifdef __cplusplus
}
#endif

// C++异常安全包装
classScopedGuard{
private:
std::functionvoid> cleanup;

public:
ScopedGuard(std::functionvoid> clean) : cleanup(clean) {}
~ScopedGuard {
if (cleanup) cleanup;
}
};

实际应用

嵌入式通信协议栈

// protocol_stack.h - C接口
#ifdef __cplusplus
extern"C"{
#endif

typedefvoid(*message_callback_t)(constuint8_t* data, uint32_t length);

voidprotocol_stack_init(void);
uint32_tsend_message(constuint8_t* data, uint32_t length);
voidregister_message_callback(message_callback_t callback);

#ifdef __cplusplus
}
#endif

// protocol_stack.cpp - C++实现
#include"protocol_stack.h"
#include
#include

classProtocolHandler{
private:
std::queuestd::vectoruint8_t>> message_queue;
std::functionvoid(constuint8_t*, uint32_t)> callback;

public:
voidinit{
// 初始化协议栈
}

uint32_tsend(conststd::vectoruint8_t>& data){
message_queue.push(data);
return data.size;
}

voidsetCallback(std::functionvoid(constuint8_t*, uint32_t)> cb){
callback = cb;
}

voidprocessMessages{
while (!message_queue.empty) {
auto& msg = message_queue.front;
if (callback) {
callback(msg.data, msg.size);
}
message_queue.pop;
}
}
};

static ProtocolHandler protocolHandler;

// C接口实现
voidprotocol_stack_init(void){
protocolHandler.init;
}

uint32_tsend_message(constuint8_t* data, uint32_t length){
std::vectoruint8_t> msg(data, data + length);
return protocolHandler.send(msg);
}

voidregister_message_callback(message_callback_t callback){
protocolHandler.setCallback(callback);
}

最后

C和C++混合编程在嵌入式系统中提供了两全其美的解决方案：既可以利用C语言的高效和硬件接近性，又可以享受C++的抽象能力和代码组织优势。

成功实现混合编程需要注意：

1. 正确使用extern “C” ：确保名称修饰的一致性

2. 设计兼容的接口 ：使用C风格的数据结构和函数原型

3. 统一内存管理 ：避免内存分配/释放的不匹配

4. 合理的构建系统配置 ：确保正确的编译和链接顺序

5. 错误处理一致性 ：在C和C++之间建立统一的错误处理机制

关注【 一起学嵌入式 】，一起变得更优秀 。

觉得文章不错，点击“ 分享 ”、“ 赞 ”、“ 推荐 ” 呗！