第三节 · 摆脱单亲状态 · 多重继承与虚继承

有时我们需要存储任意类型的值，C++17 提供了 std::any 来实现类型安全的类型擦除。

---

void 的问题*

// 旧方法：不安全
void* data = new int(42);
int* p = static_cast<int*>(data);  // 必须记住类型
cout << *p << endl;
delete static_cast<int*>(data);

// 如果类型记错了，就是未定义行为
string* s = static_cast<string*>(data);  // 危险！

---

std::any

#include <any>

int main()
{
    any a = 42;
    cout << any_cast<int>(a) << endl;  // 42
    
    a = string("Hello");
    cout << any_cast<string>(a) << endl;  // Hello
    
    a = 3.14;
    cout << any_cast<double>(a) << endl;  // 3.14
    
    // 类型不匹配会抛出异常
    try
    {
        cout << any_cast<int>(a) << endl;
    }
    catch (const bad_any_cast& e)
    {
        cout << "Bad cast: " << e.what() << endl;
    }
    
    return 0;
}

---

any 的操作

int main()
{
    any a;
    
    // 检查是否有值
    if (!a.has_value())
    {
        cout << "Empty" << endl;
    }
    
    a = 42;
    
    // 获取类型信息
    cout << a.type().name() << endl;  // i (int)
    
    // 重置
    a.reset();
    
    // 原地构造
    a.emplace<string>("Hello");
    
    // 安全的获取方式
    if (auto* p = any_cast<string>(&a))
    {
        cout << *p << endl;
    }
    
    return 0;
}

---

std::variant

variant 是类型安全的联合体。

#include <variant>

int main()
{
    variant<int, double, string> v;
    
    v = 42;
    cout << get<int>(v) << endl;  // 42
    
    v = 3.14;
    cout << get<double>(v) << endl;  // 3.14
    
    v = "Hello"s;
    cout << get<string>(v) << endl;  // Hello
    
    // 按索引访问
    cout << get<0>(v) << endl;  // 错误：当前不是 int
    
    // 检查当前类型
    cout << v.index() << endl;  // 2 (string)
    
    // 检查是否持有特定类型
    if (holds_alternative<string>(v))
    {
        cout << "It's a string" << endl;
    }
    
    return 0;
}

---

访问者模式与 variant

#include <variant>

using Value = variant<int, double, string>;

// 访问者
struct Visitor
{
    void operator()(int i) const
    {
        cout << "Int: " << i << endl;
    }
    
    void operator()(double d) const
    {
        cout << "Double: " << d << endl;
    }
    
    void operator()(const string& s) const
    {
        cout << "String: " << s << endl;
    }
};

int main()
{
    Value v = 42;
    visit(Visitor{}, v);  // Int: 42
    
    v = 3.14;
    visit(Visitor{}, v);  // Double: 3.14
    
    v = "Hello"s;
    visit(Visitor{}, v);  // String: Hello
    
    // 使用 lambda（C++17）
    visit([](auto&& arg) {
        cout << arg << endl;
    }, v);
    
    return 0;
}

---

std::optional

表示可能没有值的类型。

#include <optional>

optional<int> findIndex(const vector<int>& v, int target)
{
    for (size_t i = 0; i < v.size(); ++i)
    {
        if (v[i] == target)
            return i;
    }
    return nullopt;
}

int main()
{
    vector<int> v = {1, 2, 3, 4, 5};
    
    if (auto idx = findIndex(v, 3))
    {
        cout << "Found at index: " << *idx << endl;
    }
    
    auto idx2 = findIndex(v, 10);
    cout << "Found: " << idx2.has_value() << endl;  // 0
    
    // 提供默认值
    cout << idx2.value_or(-1) << endl;  // -1
    
    return 0;
}

---

手动实现类型擦除

class Any
{
    struct Base
    {
        virtual ~Base() = default;
        virtual unique_ptr<Base> clone() const = 0;
    };
    
    template<typename T>
    struct Derived : Base
    {
        T value;
        Derived(T v) : value(move(v)) {}
        unique_ptr<Base> clone() const override
        {
            return make_unique<Derived<T>>(value);
        }
    };
    
    unique_ptr<Base> data;
    
public:
    Any() = default;
    
    template<typename T>
    Any(T value) : data(make_unique<Derived<T>>(move(value))) {}
    
    Any(const Any& other)
        : data(other.data ? other.data->clone() : nullptr) {}
    
    template<typename T>
    T& get()
    {
        auto* p = dynamic_cast<Derived<T>*>(data.get());
        if (!p) throw bad_any_cast{};
        return p->value;
    }
};

---

函数包装器 std::function

#include <functional>

int add(int a, int b) { return a + b; }

int main()
{
    // function 可以存储任何可调用对象
    function<int(int, int)> f;
    
    // 普通函数
    f = add;
    cout << f(1, 2) << endl;  // 3
    
    // Lambda
    f = [](int a, int b) { return a * b; };
    cout << f(3, 4) << endl;  // 12
    
    // 函数对象
    struct Multiply
    {
        int operator()(int a, int b) const { return a * b; }
    };
    f = Multiply{};
    cout << f(5, 6) << endl;  // 30
    
    // 成员函数
    struct Calculator
    {
        int multiply(int a, int b) { return a * b; }
    };
    Calculator calc;
    function<int(int, int)> g = bind(&Calculator::multiply, &calc, placeholders::_1, placeholders::_2);
    cout << g(7, 8) << endl;  // 56
    
    return 0;
}

---

类型擦除的应用

// 命令模式
class Command
{
    function<void()> action;
    
public:
    template<typename F>
    Command(F&& f) : action(forward<F>(f)) {}
    
    void execute() { action(); }
};

// 事件系统
class EventSystem
{
    map<string, vector<function<void(any)>>> handlers;
    
public:
    template<typename F>
    void on(const string& event, F&& handler)
    {
        handlers[event].push_back(forward<F>(handler));
    }
    
    template<typename T>
    void emit(const string& event, T&& data)
    {
        for (auto& handler : handlers[event])
        {
            handler(any(forward<T>(data)));
        }
    }
};

---

习题

• 比较 any、variant 和 void* 的优缺点。

• 实现一个简单的属性系统，支持任意类型的属性值。

• 使用 variant 实现一个简单的 JSON 值类型。