C++中能否以实时安全的方式让函数返回多态对象？

问题背景 #

我需要实现一个函数，返回系统检测到的错误信息。最初的简易实现如下（简化版）：

class Error { ... };  // 抽象基类
// 不同错误类型：
class FooError: public Error { public: FooError(int foo) {...}};
class BarError: public Error { public: BarError(int bar, float baz) {...}};

// 检查是否存在错误并返回第一个检测到的错误
std::shared_ptr<Error> get_error() {
    if (is_error_foo()) {
        return std::make_shared<FooError>(42);
    }
    if (is_error_bar()) {
        return std::make_shared<BarError>(13, 3.14);
    }

    ...
}

由于该代码用于实时关键系统，不允许使用动态内存分配（make_shared会触发堆分配），因此需要寻找无需动态内存分配的替代实现方式。

可行替代方案 #

1. 使用变体类型（std::variant，C++17及以上） #

利用std::variant存储不同错误类型的实例，所有错误对象都分配在栈上，完全避免堆内存操作。

#include <variant>

// 错误类型无需继承抽象基类，直接定义具体类型
struct FooError { int foo; };
struct BarError { int bar; float baz; };

// 定义错误变体类型
using ErrorVariant = std::variant<std::monostate, FooError, BarError>;

ErrorVariant get_error() {
    if (is_error_foo()) {
        return FooError{42};
    }
    if (is_error_bar()) {
        return BarError{13, 3.14};
    }

    // 无错误时返回空状态
    return std::monostate{};
}

// 使用时通过访问器处理不同错误类型
void handle_error(const ErrorVariant& err) {
    std::visit([](const auto& e) {
        using T = std::decay_t<decltype(e)>;
        if constexpr (std::is_same_v<T, std::monostate>) {
            // 无错误逻辑
        } else if constexpr (std::is_same_v<T, FooError>) {
            // 处理FooError，比如打印e.foo
        } else if constexpr (std::is_same_v<T, BarError>) {
            // 处理BarError，比如打印e.bar和e.baz
        }
    }, err);
}

优势：类型安全，无需继承体系，完全栈分配，符合实时系统的确定性要求。

2. 基于标签联合（Tagged Union）的C风格实现 #

如果项目使用C++17之前的标准，可以手动实现标签联合，同样在栈上存储错误数据。

#include <cstdint>

// 错误类型标签
enum ErrorTag {
    ERROR_NONE,
    ERROR_FOO,
    ERROR_BAR
};

// 标签联合存储错误数据
struct Error {
    ErrorTag tag;
    union {
        int foo;                  // 对应ERROR_FOO
        struct { int bar; float baz; } bar; // 对应ERROR_BAR
    } data;
};

Error get_error() {
    Error err{ERROR_NONE};
    if (is_error_foo()) {
        err.tag = ERROR_FOO;
        err.data.foo = 42;
        return err;
    }
    if (is_error_bar()) {
        err.tag = ERROR_BAR;
        err.data.bar.bar = 13;
        err.data.bar.baz = 3.14;
        return err;
    }
    return err;
}

// 使用时通过标签判断错误类型
void handle_error(const Error& err) {
    switch (err.tag) {
        case ERROR_FOO:
            // 处理FooError，访问err.data.foo
            break;
        case ERROR_BAR:
            // 处理BarError，访问err.data.bar.bar和err.data.bar.baz
            break;
        case ERROR_NONE:
            // 无错误逻辑
            break;
    }
}

优势：兼容性好，无标准库依赖，内存开销极小，但需要手动维护标签和联合的一致性，容易出错。

3. 预分配静态错误实例（适合错误参数固定的场景） #

如果错误的参数是固定值（比如示例中的42、13/3.14），可以提前静态分配所有可能的错误实例，函数直接返回指向这些实例的指针（无需动态分配）。

class Error { public: virtual ~Error() = default; };
class FooError: public Error { public: int foo; FooError(int f) : foo(f) {} };
class BarError: public Error { public: int bar; float baz; BarError(int b, float z) : bar(b), baz(z) {} };

// 静态预分配错误实例
static FooError static_foo_error(42);
static BarError static_bar_error(13, 3.14);

const Error* get_error() {
    if (is_error_foo()) {
        return &static_foo_error;
    }
    if (is_error_bar()) {
        return &static_bar_error;
    }
    return nullptr; // 无错误
}

// 使用时通过动态类型识别处理
void handle_error(const Error* err) {
    if (!err) return;
    if (const auto* foo_err = dynamic_cast<const FooError*>(err)) {
        // 处理FooError
    } else if (const auto* bar_err = dynamic_cast<const BarError*>(err)) {
        // 处理BarError
    }
}

注意：如果错误参数是动态生成的（比如不同的错误码），这种方式不适用；另外dynamic_cast可能引入运行时开销，部分实时系统可能禁用RTTI，此时可以在基类中添加类型枚举作为标签替代。

4. 输出参数传递错误信息 #

将错误信息通过函数的输出参数（引用）传递，完全避免返回堆分配对象。

#include <optional> // C++17及以上，或自定义可选类型

struct FooError { int foo; };
struct BarError { int bar; float baz; };

// 使用std::variant作为输出参数的类型
bool get_error(std::variant<FooError, BarError>& out_err) {
    if (is_error_foo()) {
        out_err = FooError{42};
        return true;
    }
    if (is_error_bar()) {
        out_err = BarError{13, 3.14};
        return true;
    }
    return false; // 无错误
}

// 使用示例
std::variant<FooError, BarError> err;
if (get_error(err)) {
    // 处理错误，同方案1的visit逻辑
}

优势：函数返回值仅表示是否存在错误，错误数据由调用方预分配（栈上），完全符合实时系统的内存确定性要求。

内容的提问来源于stack exchange，提问作者luator