🔍 C++反射机制深度解析

反射是许多高级语言（如Java、C#）的内置特性，但C++并不原生支持。本文介绍如何通过设计模式实现C++的类反射机制，实现通过类名动态创建对象。

一、什么是反射

反射（Reflection）是一种在程序运行时检查、访问和修改对象状态和行为的机制。拥有反射特性的语言可以在运行时获取类的信息、调用类的方法、创建类的实例。

在Java中，反射非常简单：

Class<?> clazz = Class.forName("com.example.MyClass");
Object instance = clazz.newInstance();

但C++作为编译型语言，不提供原生的反射机制。然而，在某些场景下，我们确实需要类似的功能。

二、为什么C++需要反射

2.1 问题场景

假设有一个JSON配置文件：

{
  "car_type": "truck"  // car_type可以是：truck, bus, motorcycle, bicycle, person, tricycle
}

从这个JSON中读取car_type，然后构造对应的类。传统做法是：

void* car;
if (car_type == "truck") car = new truck();
if (car_type == "bus") car = new bus();
if (car_type == "motorcycle") car = new motorcycle();
if (car_type == "bicycle") car = new bicycle();
if (car_type == "person") car = new person();
if (car_type == "tricycle") car = new tricycle();
// ... 每增加一种类型就要修改这里

2.2 问题分析

这种写法的问题：

问题	说明
🔴 扩展性差	每增加一种类型，都要修改多处代码
🔴 维护困难	如果是框架型代码，使用者众多，修改成本高
🔴 违反开闭原则	对修改开放，对扩展不够开放

2.3 反射的解决方案

使用反射后，代码变得优雅：

truck* car1 = (truck*)ClassFactory::getInstance().getClassByName("truck");
bus* car2 = (bus*)ClassFactory::getInstance().getClassByName("bus");

这样实现了：

• ✅ 通过名称字符串来生成类的对象
• ✅ 代码优雅、扩展性强
• ✅ 框架代码与使用代码解耦
• ✅ 新增类型只需注册，无需修改核心代码

三、反射要解决的核心问题

反射要解决的核心问题是：通过类的名称字符串来生成类的对象。

💡 实际上，我们这里实现的并不是完整的反射机制，只是反射机制中的一个小功能模块：通过类名称字符串创建类的实例。完整的反射还包括：通过类名称字符串获取类中的属性和方法、修改属性和方法的访问权限等。

四、实现原理

4.1 涉及的知识点

实现C++类反射需要以下技术：

技术	作用
单例模式	保证工厂类全局唯一
工厂模式	统一管理对象的创建
在main()之前执行代码	实现自动注册的核心

4.2 核心思路

1. 注册阶段：在main()之前，通过全局对象的构造函数，将类名和创建函数注册到工厂
2. 创建阶段：运行时通过类名字符串，从工厂查找对应的创建函数，调用创建对象

4.3 实现代码

#include <iostream>
#include <string>
#include <map>
#include <functional>
using namespace std;

// 基类
class Car {
public:
  virtual void run() = 0;
  virtual ~Car() = default;
};

// 具体类
class Truck : public Car {
public:
  void run() override { cout << "Truck is running" << endl; }
};

class Bus : public Car {
public:
  void run() override { cout << "Bus is running" << endl; }
};

class Motorcycle : public Car {
public:
  void run() override { cout << "Motorcycle is running" << endl; }
};

// 工厂类（单例）
class ClassFactory {
private:
  map<string, function<Car*()>> creators;
  ClassFactory() = default;

public:
  static ClassFactory& getInstance() {
    static ClassFactory instance;
    return instance;
  }

  // 注册创建函数
  void registerClass(const string& className, function<Car*()> creator) {
    creators[className] = creator;
    cout << "注册类: " << className << endl;
  }

  // 通过类名创建对象
  Car* getClassByName(const string& className) {
    if (creators.find(className) != creators.end()) {
      return creators[className]();
    }
    return nullptr;
  }

  // 禁止拷贝
  ClassFactory(const ClassFactory&) = delete;
  ClassFactory& operator=(const ClassFactory&) = delete;
};

// 注册器类
template<typename T>
class Register {
public:
  Register(const string& className) {
    ClassFactory::getInstance().registerClass(
      className, 
      []() -> Car* { return new T(); }
    );
  }
};

// 注册宏，简化注册过程
#define REGISTER_CLASS(className) \
  Register<className> reg_##className(#className);

// 在main()之前注册
REGISTER_CLASS(Truck)
REGISTER_CLASS(Bus)
REGISTER_CLASS(Motorcycle)

int main() {
  cout << "\n=== 开始创建对象 ===" << endl;

  // 通过类名创建对象
  Car* car1 = ClassFactory::getInstance().getClassByName("Truck");
  if (car1) car1->run();

  Car* car2 = ClassFactory::getInstance().getClassByName("Bus");
  if (car2) car2->run();

  Car* car3 = ClassFactory::getInstance().getClassByName("Motorcycle");
  if (car3) car3->run();

  // 清理
  delete car1;
  delete car2;
  delete car3;

  return 0;
}

运行结果：

注册类: Truck
注册类: Bus
注册类: Motorcycle

=== 开始创建对象 ===
Truck is running
Bus is running
Motorcycle is running

4.4 在main()之前执行代码的原理

C++全局对象在main()函数执行之前就会被构造。利用这个特性，我们可以实现自动注册：

// 全局对象的构造函数会在main()之前执行
static Register<Truck> reg_Truck("Truck");

这样，每个需要支持反射的类只需要一行注册代码，一般是将该代码写在类的cpp文件中就能自动完成注册。

五、实际应用案例

5.1 ffmpeg_sample/stream_decoder

在ffmpeg_sample项目中，stream_decoder使用反射机制创建不同类型的demuxer和decoder：

// DecoderFactory / DemuxerFactory 提供工厂模式
// FFDecoder / FFDemuxer 是具体模块
// 通过在 FFDecoder.cpp 中写 DecoderRegistrar<FFDecoder> 实现自动注册

六、静态库中的注意事项

⚠️ 重要警告：当使用静态库时，反射机制可能失效！

6.1 问题原因

编译器会对未被引用的.o文件进行优化丢弃。如果FFDecoder.cpp属于未被引用的代码，它会被丢弃，导致自动注册失效。

6.2 解决方案

方法1：使用动态库

动态库的所有代码都会被加载，不存在丢弃问题。

方法2：静态库 + 显示调用注册函数

在IDecoder.cpp中定义RegisterAllDecoders()函数，用来注册所有的decoder：

// IDemuxer.cpp
void RegisterAllDemuxers() {
  static DemuxerRegistrar<FFDemuxer> ff_demuxer_registrar("FFDemuxer");
  static DemuxerRegistrar<ZRtspDemuxer> rtsp_demuxer_registrar("ZRtspDemuxer");
  // ...
}

在肯定会调用的.cpp文件中（如ZMediaProc.cpp），加入：

// ZMediaProc.cpp
class AllRegistrar {
public:
  AllRegistrar() {
    printf("***** file:%s function:%s line:%d\n", 
           __FILE__, __FUNCTION__, __LINE__);
    RegisterAllDecoders();
    RegisterAllDemuxers();
  }
} s_all_registrar;

这样也实现了自动注册，只不过主模块中IDecoder.cpp要包含所有子模块（各种decoder）的.h文件。

6.3 静态库反射对比

方案	优点	缺点
动态库	完全自动注册	依赖管理复杂
静态库+显式注册	无依赖问题	需要手动维护注册列表

八、总结

C++反射机制通过工厂模式 + 单例模式 + 全局对象构造实现：

组件	作用
单例工厂	全局管理类名与创建函数的映射
注册器类	封装注册逻辑，简化使用
全局对象	在main()之前自动执行注册

反射的价值：

• 📦 解耦框架代码与业务代码
• 🔌 支持插件化架构
• 🎯 实现配置驱动开发

💡 记住：完整的反射还包括属性访问、方法调用等，本文只涉及对象创建部分。根据实际需求选择合适的技术方案。

---