手动实现 std::variant / std::visit 的功能

要手动实现 std::variant / std::visit 的功能，我们需要理解 std::variant 和 std::visit 是如何工作的。std::variant 是一种可变类型，它可以存储不同类型的对象。std::visit 是一个函数模板，用于访问 std::variant 中的对象，并以类型安全的方式进行参数化。

以下是一个简单的手动实现 std::variant 的示例代码：

```
#include <iostream>
#include <type_traits>

template<class... Types>
class my_variant {
public:
    // 构造函数
    template<class T, typename = std::enable_if_t<(std::is_same_v<T, Types> || ...)>>
    my_variant(T& value) {
        using T_no_ref = std::remove_reference_t<T>;
        constexpr size_t index = find_index<T_no_ref>();
        new (std::addressof(data_)) T_no_ref(value);
        index_ = index;
    }
    
    // 析构函数
    ~my_variant() {
        reset();
    }
    
    // 重载赋值运算符
    template<class T, typename = std::enable_if_t<(std::is_same_v<T, Types> || ...)>>
    my_variant& operator=(T& value) {
        reset();
        using T_no_ref = std::remove_reference_t<T>;
        constexpr size_t index = find_index<T_no_ref>();
        new (std::addressof(data_)) T_no_ref(value);
        index_ = index;
        return *this;
    }
    
    // 获取类型索引
    size_t index() const {
        return index_;
    }
    
    // 重置变量
    void reset() {
        if (index_ != -1) {
            switch (index_) {
            case 0:
                reinterpret_cast<Types*>(std::addressof(data_))->~Types();
                break;
            case 1:
                reinterpret_cast<Types*>(std::addressof(data_))->~Types();
                break;
            // ...
            }
            index_ = -1;
        }
    }
    
    // 获取指定类型的值
    template<class T, typename = std::enable_if_t<(std::is_same_v<T, Types> || ...)>>
    T& get() {
        using T_no_ref = std::remove_reference_t<T>;
        constexpr size_t index = find_index<T_no_ref>();
        if (index == index_) {
            return *reinterpret_cast<T*>(std::addressof(data_));
        }
        throw std::bad_variant_access();
    }

private:
    // 数据存储
    std::aligned_union_t<0, Types...> data_;
    // 类型索引
    size_t index_{ -1 };

    // 查找类型索引
    template<typename T>
    constexpr size_t find_index() {
        size_t index = 0;
        size_t found_index = static_cast<size_t>(-1);
        ((std::is_same_v<T, Types> && (found_index = index)), ...);
        return found_index;
    }
};

// 测试代码
int main() {
    my_variant<int, float, std::string> v1 = 3;
    my_variant<int, float, std::string> v2 = 2.5;
    my_variant<int, float, std::string> v3 = "hello";
 
    std::cout << v1.get<int>() << '\n';    // 输出 3
    std::cout << v2.get<float>() << '\n';  // 输出 2.5
    std::cout << v3.get<std::string>() << '\n';  // 输出 hello
 
    v1 = 5.5;  // 重新赋值为浮点数
    std::cout << v1.get<float>() << '\n';  // 输出 5.5
 
    try {
        // 获取错误类型的值
        std::cout << v1.get<std::string>() << '\n';
    }
    catch (const std::bad_variant_access& e) {
        // 抛出 bad_variant_access 异常
        std::cerr << e.what() << '\n';
    }
}
```

在上面的代码中，my_variant 使用 std::aligned_union_t 来存储任意类型的值，使用 index_ 来跟踪存储在 my_variant 中的类型。

接下来，我们来看一下如何手动实现 std::visit：

```
template <typename Visitor, typename Variant, typename... Variants>
decltype(auto) my_visit_helper(Visitor&& vis, Variant&& var, Variants&&... vars) {
    constexpr size_t num_alternatives = std::variant_size_v<std::remove_reference_t<Variant>>;
    using result_t = decltype(vis(std::get<0>(std::forward<Variant>(var))));
    using fptr_t = result_t(*)(Visitor&&, Variant&&, Variants&&...);
    static fptr_t jumptable[num_alternatives] = {
        +[] (Visitor&& vis, Variant&& var, Variants&&... vars) -> result_t {
            return vis(std::get<0>(std::forward<Variant>(var)));
        },
        +[] (Visitor&& vis, Variant&& var, Variants&&... vars) -> result_t {
            return my_visit_helper(std::forward<Visitor>(vis), std::forward<Variants>(vars)...);
        },
        // ...
    };
    return jumptable[var.index()](std::forward<Visitor>(vis), std::forward<Variant>(var), std::forward<Variants>(vars)...);
}

template <typename Visitor, typename... Variants>
decltype(auto) my_visit(Visitor&& vis, Variants&&... vars) {
    return my_visit_helper(std::forward<Visitor>(vis), std::forward<Variants>(vars)...);
}
```

my_visit_helper 是用来递归访问 std::variant 对象的辅助函数，它使用一个静态的跳转表来分派访问器。my_visit 使用 my_visit_helper 来访问给定的 std::variant 对象序列，并把每个对象传递给给定的访问器。

在上面的例子中，我们使用 std::get 来访问 std::variant 对象的值。需要注意的是，我们没有检查 std::variant 对象是否包含与访问器相匹配的值，这可能会导致未定义的行为。因此，我们在实现自己的 std::variant / std::visit 时，需要注意类型匹配和错误处理。