#include <variant>
#include <string>
#include <iostream>

// 定义一个可以存储int、double或std::string的variant
using MyVariant = std::variant<int, double, std::string>;

// 简单的variant使用示例
void basicExample() {
    MyVariant v1 = 42;                    // 存储int
    MyVariant v2 = 3.14;                  // 存储double
    MyVariant v3 = "hello";               // 存储std::string (通过char数组构造)

    std::cout << std::get<int>(v1) << std::endl;     // 输出: 42
    std::cout << std::get<double>(v2) << std::endl;  // 输出: 3.14
    std::cout << std::get<std::string>(v3) << std::endl;  // 输出: hello
}

#include <variant>
#include <iostream>

void typeSafetyDemo() {
    std::variant<int, double, std::string> v = 100;

    // 正确的访问方式
    std::cout << "Value: " << std::get<int>(v) << std::endl;

    // 尝试获取错误的类型会抛出异常
    try {
        std::cout << std::get<double>(v) << std::endl;
    } catch (const std::bad_variant_access& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }
}

// 使用variant替代void*和类型标签
struct Message {
    std::variant<int, std::string, double> payload;
    int typeTag;  // 不再需要手动维护类型标签
};

// 使用variant后的改进版本
using MessageV2 = std::variant<int, std::string, double>;
// 类型信息由variant自动维护，无需额外的typeTag

enum class State { Idle, Processing, Completed, Error };

// 使用variant表示每种状态的数据
struct ProcessingData {
    int progress;
};

struct ErrorData {
    std::string message;
};

using StateData = std::monostate;  // Idle状态不需要额外数据
using StateData = std::variant<
    std::monostate,           // Idle
    ProcessingData,           // Processing
    std::monostate,           // Completed (不需要额外数据)
    ErrorData                 // Error
>;

#include <variant>
#include <string>
#include <iostream>

void basicOperations() {
    // 创建variant，使用第一个类型的默认值初始化
    std::variant<int, double, std::string> v1;  // 值为0

    // 使用其他类型的值初始化
    std::variant<int, double, std::string> v2 = 42;
    std::variant<int, double, std::string> v3 = 3.14;
    std::variant<int, double, std::string> v4 = std::string("hello");

    // 使用emplace避免不必要的拷贝
    std::variant<int, double, std::string> v5;
    v5.emplace<std::string>("world");  // 直接构造，避免临时对象

    // 使用std::in_place_type指定类型
    std::variant<int, double, std::string> v6{std::in_place_type<double>, 2.718};

    // 使用std::in_place_index指定索引
    std::variant<int, double, std::string> v7{std::in_place_index<2>, "variant"};
}

void assignmentDemo() {
    std::variant<int, std::string> v = 10;

    // 赋值相同类型
    v = 20;  // 调用int的赋值运算符

    // 赋值不同类型
    v = std::string("hello");  // 析构int，构造string

    // 使用emplace进行原地构造
    v.emplace<int>(100);  // 析构string，构造int
}

#include <variant>
#include <iostream>
#include <string>

void getDemo() {
    std::variant<int, double, std::string> v = "test";

    // 使用类型访问
    std::cout << std::get<std::string>(v) << std::endl;

    // 使用索引访问
    std::cout << std::get<2>(v) << std::endl;

    // 如果类型不匹配，会抛出异常
    try {
        std::cout << std::get<int>(v) << std::endl;
    } catch (const std::bad_variant_access& e) {
        std::cerr << "Type mismatch: " << e.what() << std::endl;
    }
}

void getIfDemo() {
    std::variant<int, double, std::string> v = 42;

    // 安全的类型检查和访问
    if (auto* intPtr = std::get_if<int>(&v)) {
        std::cout << "Got int: " << *intPtr << std::endl;
    } else if (auto* doublePtr = std::get_if<double>(&v)) {
        std::cout << "Got double: " << *doublePtr << std::endl;
    } else if (auto* stringPtr = std::get_if<std::string>(&v)) {
        std::cout << "Got string: " << *stringPtr << std::endl;
    }
}

#include <variant>
#include <iostream>
#include <string>
#include <functional>

void visitDemo() {
    std::variant<int, double, std::string> v = "hello";

    // 使用lambda作为visitor
    std::visit([](auto&& arg) {
        std::cout << "Value: " << arg << std::endl;
    }, v);

    // 多个variant一起访问
    std::variant<int, double> v1 = 10;
    std::variant<int, double> v2 = 20;

    std::visit([](auto a, auto b) {
        std::cout << "Sum: " << a + b << std::endl;
    }, v1, v2);
}

#include <variant>
#include <iostream>
#include <type_traits>

void typeBasedVisitor() {
    std::variant<int, double, std::string> v;

    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;

        if constexpr (std::is_same_v<T, int>) {
            std::cout << "Processing int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, double>) {
            std::cout << "Processing double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "Processing string: " << arg << std::endl;
        }
    }, v);
}

auto result = std::visit([](auto&& arg) -> double {
    return static_cast<double>(arg);
}, v);

#include <variant>
#include <iostream>

void stateQueries() {
    std::variant<int, double, std::string> v = 42;

    // 检查variant当前持有的是哪种类型
    std::cout << "Index: " << v.index() << std::endl;  // 输出: 0 (int的索引)

    // 检查variant是否持有特定类型的值
    std::cout << "holds_alternative<int>: " << std::holds_alternative<int>(v) << std::endl;  // true
    std::cout << "holds_alternative<double>: " << std::holds_alternative<double>(v) << std::endl;  // false

    // valueless_by_exception: variant是否处于有效状态
    // 如果variant中的操作抛出异常，variant可能处于valueless状态
}

#include <variant>
#include <iostream>
#include <stdexcept>

struct ThrowingType {
    int value;
    ThrowingType(int v) : value(v) {}
    ThrowingType(const ThrowingType&) { throw std::runtime_error("copy error"); }
    ThrowingType(ThrowingType&&) noexcept { throw std::runtime_error("move error"); }
};

void exceptionHandling() {
    std::variant<int, ThrowingType> v = 10;

    try {
        v = ThrowingType(20);  // 如果拷贝构造抛出异常
    } catch (const std::exception& e) {
        if (v.valueless_by_exception) {
            std::cout << "Variant is now valueless" << std::endl;
        }
        // variant的状态取决于异常发生的时机
    }
}

#include <variant>
#include <iostream>

void monostateDemo() {
    // 使用std::monostate作为第一个类型来提供"空"状态
    using OptionalInt = std::variant<std::monostate, int, double>;

    OptionalInt v1;  // 默认构造为空状态
    OptionalInt v2 = std::monostate{};  // 显式设置为空状态

    // 检查是否是空状态
    if (std::holds_alternative<std::monostate>(v1)) {
        std::cout << "v1 is empty" << std::endl;
    }

    // 在visit中处理空状态
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, std::monostate>) {
            std::cout << "Empty value" << std::endl;
        } else {
            std::cout << "Value: " << arg << std::endl;
        }
    }, v1);
}

template<typename T>
using Optional = std::variant<std::monostate, T>;

Optional<std::string> findName(int id) {
    if (id > 0 && id <= 100) {
        return std::string("Name") + std::to_string(id);
    }
    return std::monostate{};  // 返回空状态
}

void useOptional() {
    auto result = findName(50);
    std::visit([](auto&& arg) {
        if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::monostate>) {
            std::cout << "Not found" << std::endl;
        } else {
            std::cout << "Found: " << arg << std::endl;
        }
    }, result);
}

#include <variant>
#include <string>
#include <vector>
#include <unordered_map>

// JSON值的简单表示
using JsonValue = std::variant<
    std::nullptr_t,           // null
    bool,                     // true/false
    double,                   // number
    std::string,              // string
    std::vector<JsonValue>,   // array
    std::unordered_map<std::string, JsonValue>  // object
>;

// 构建JSON对象
JsonValue buildJson() {
    std::unordered_map<std::string, JsonValue> object;
    object["name"] = std::string("Alice");
    object["age"] = 30;
    object["active"] = true;

    std::vector<JsonValue> skills = {
        std::string("C++"),
        std::string("Python")
    };
    object["skills"] = skills;

    return object;
}

#include <variant>
#include <string>
#include <iostream>

// 定义不同类型的命令
struct CreateUser {
    std::string name;
    std::string email;
};

struct DeleteUser {
    int userId;
};

struct UpdateUser {
    int userId;
    std::string field;
    std::string newValue;
};

// 使用variant统一表示所有命令
using Command = std::variant<CreateUser, DeleteUser, UpdateUser>;

// 命令处理函数
void executeCommand(const Command& cmd) {
    std::visit([](auto&& c) {
        using T = std::decay_t<decltype(c)>;
        if constexpr (std::is_same_v<T, CreateUser>) {
            std::cout << "Creating user: " << c.name << std::endl;
        } else if constexpr (std::is_same_v<T, DeleteUser>) {
            std::cout << "Deleting user: " << c.userId << std::endl;
        } else if constexpr (std::is_same_v<T, UpdateUser>) {
            std::cout << "Updating user " << c.userId
                      << ": " << c.field << " = " << c.newValue << std::endl;
        }
    }, cmd);
}

#include <variant>
#include <string>
#include <iostream>

// 定义状态数据
struct IdleState {
    // 空闲状态不需要额外数据
};

struct ConnectingState {
    std::string server;
    int port;
};

struct ConnectedState {
    int connectionId;
    double uptime;
};

struct ErrorState {
    std::string message;
    int errorCode;
};

// 使用variant表示所有可能的状态
using NetworkState = std::variant<
    IdleState,
    ConnectingState,
    ConnectedState,
    ErrorState
>;

// 状态机类
class NetworkConnection {
    NetworkState state_;

public:
    void connect(const std::string& server, int port) {
        state_ = ConnectingState{server, port};
    }

    void disconnect() {
        state_ = IdleState{};
    }

    void process() {
        std::visit([](auto&& s) {
            using T = std::decay_t<decltype(s)>;
            if constexpr (std::is_same_v<T, IdleState>) {
                std::cout << "Waiting for connection..." << std::endl;
            } else if constexpr (std::is_same_v<T, ConnectingState>) {
                std::cout << "Connecting to " << s.server << ":" << s.port << std::endl;
            } else if constexpr (std::is_same_v<T, ConnectedState>) {
                std::cout << "Connected (ID: " << s.connectionId << ")" << std::endl;
            } else if constexpr (std::is_same_v<T, ErrorState>) {
                std::cout << "Error: " << s.message << " (code: " << s.errorCode << ")" << std::endl;
            }
        }, state_);
    }
};

#include <variant>
#include <string>
#include <chrono>

// 事件类型定义
struct MouseClick {
    int x, y;
    int button;
};

struct KeyPress {
    char key;
    bool shift;
};

struct WindowResize {
    int width, height;
};

struct TimerElapsed {
    std::chrono::steady_clock::time_point timestamp;
};

// 统一的事件类型
using Event = std::variant<MouseClick, KeyPress, WindowResize, TimerElapsed>;

// 事件处理器
class EventHandler {
public:
    void handleEvent(const Event& event) {
        std::visit([this](auto&& e) {
            processEvent(e);
        }, event);
    }

private:
    void processEvent(const MouseClick& click) {
        std::cout << "Mouse click at (" << click.x << ", " << click.y
                  << ") button: " << click.button << std::endl;
    }

    void processEvent(const KeyPress& key) {
        std::cout << "Key pressed: '" << key.key << "' (shift: " << key.shift << ")" << std::endl;
    }

    void processEvent(const WindowResize& resize) {
        std::cout << "Window resized to " << resize.width << "x" << resize.height << std::endl;
    }

    void processEvent(const TimerElapsed& timer) {
        std::cout << "Timer elapsed at timestamp" << std::endl;
    }
};

#include <variant>
#include <string>
#include <iostream>

// 计算结果可能是数值或错误信息
using CalcResult = std::variant<double, std::string>;

CalcResult divide(double a, double b) {
    if (b == 0) {
        return std::string("Error: Division by zero");
    }
    return a / b;
}

void printResult(const CalcResult& result) {
    std::visit([](auto&& arg) {
        if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::string>) {
            std::cerr << arg << std::endl;
        } else {
            std::cout << "Result: " << arg << std::endl;
        }
    }, result);
}

#include <variant>
#include <tuple>
#include <iostream>

void commonFeatures() {
    // 两者都支持异构类型
    std::tuple<int, double, std::string> t{1, 2.0, "three"};
    std::variant<int, double, std::string> v{1};

    // 两者都支持std::visit
    std::visit([](auto&& arg) {
        std::cout << "Visit result: " << arg << std::endl;
    }, v);

    std::visit([](auto&&... args) {
        ((std::cout << args << " "), ...);
        std::cout << std::endl;
    }, t);
}

#include <variant>
#include <tuple>
#include <iostream>

void storageDifference() {
    // tuple同时持有int、double、string三个值
    std::tuple<int, double, std::string> t{1, 2.0, "hello"};
    std::cout << "Tuple size (incomplete): " << sizeof(t) << " bytes" << std::endl;
    // 输出: Tuple包含int、double、string三个对象

    // variant只持有一种类型的值
    std::variant<int, double, std::string> v{1};
    std::cout << "Variant size: " << sizeof(v) << " bytes" << std::endl;
    // 输出: Variant只包含一个值加上类型索引
}

void accessDifference() {
    std::tuple<int, std::string> t{42, "hello"};
    std::variant<int, std::string> v{42};

    // tuple: 按位置访问
    std::cout << std::get<0>(t) << std::endl;  // 总是42
    std::cout << std::get<1>(t) << std::endl;  // 总是"hello"

    // variant: 按类型访问（必须与当前存储的类型匹配）
    std::cout << std::get<int>(v) << std::endl;  // 如果当前是int，正确
    // std::get<std::string>(v) 如果当前是int，会抛出异常
}

#include <tuple>
#include <variant>
#include <iostream>

struct LargeStruct {
    char data[1000];
};

void sizeComparison() {
    std::tuple<int, LargeStruct> t;
    std::variant<int, LargeStruct> v;

    std::cout << "Tuple size: " << sizeof(t) << " bytes" << std::endl;  // ~1004 bytes
    std::cout << "Variant size: " << sizeof(v) << " bytes" << std::endl;  // ~1008 bytes (加上了索引)
}

void defaultConstruction() {
    std::tuple<int, std::string> t;  // int=0, string=""

    std::variant<int, std::string> v;  // int=0
    // 如果第一个类型是std::string，variant默认构造string
}

// 使用tuple的场景：函数返回多个值
std::tuple<int, double, std::string> getStats() {
    return {100, 98.5, "Alice"};
}

// 使用variant的场景：函数返回可能失败，结果类型不固定
std::variant<int, std::string, double> processInput(const std::string& input) {
    if (input.empty()) {
        return std::string("Error: empty input");
    }
    if (input == "yes") {
        return 1;
    }
    return 3.14;
}

// 不好的设计：variant类型过多且不相关
using BadDesign = std::variant<
    int, double, std::string, std::vector<int>,
    std::map<std::string, int>, CustomClass,
    std::function<void()>, std::thread
>;

// 更好的设计：识别真正需要处理的类型集合
// 如果不同类型的处理逻辑完全不同，可能需要不同的设计
using Value = std::variant<int, double, std::string>;  // 数值或字符串
using Action = std::variant<std::function<void()>, std::thread>;  // 可执行对象

// 不必要的使用variant
VariantProcesser v = 42;
std::visit([](auto&& x) { process(x); }, v);  // process对所有类型做同样的事

// 更简单的方案：模板函数
template<typename T>
void process(T&& value) { /* 对所有类型做同样的事 */ }

#include <variant>
#include <iostream>
#include <stdexcept>

struct MayThrow {
    int value;
    MayThrow(int v) : value(v) {}
    MayThrow(const MayThrow& other) : value(other.value) {
        if (value < 0) throw std::runtime_error("Negative value");
    }
};

void safeVariantUsage() {
    std::variant<int, MayThrow> v = 10;

    try {
        v = MayThrow(20);  // 可能抛出异常
    } catch (...) {
        // 必须检查variant是否处于有效状态
        if (v.valueless_by_exception) {
            std::cerr << "Variant is valueless due to exception" << std::endl;
            return;
        }
    }
    // 继续处理...
}

// 性能敏感的代码中，频繁类型变化可能不是最佳选择
void performanceConcern() {
    std::variant<int, std::string, double> v;

    // 循环中频繁改变类型
    for (int i = 0; i < 1000000; ++i) {
        if (i % 3 == 0) {
            v = i;
        } else if (i % 3 == 1) {
            v = std::to_string(i);
        } else {
            v = static_cast<double>(i) / 1000.0;
        }
    }
}

void completeHandling() {
    std::variant<int, double, std::string> v;

    // 不完整的处理会导致编译错误（好的情况）
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>) {
            // 处理int
        }
        // 如果缺少double和string的处理，编译器会警告或报错
    }, v);

    // 使用get_if时，需要显式处理所有情况
    if (std::get_if<int>(&v)) {
        // 处理int
    } else if (std::get_if<double>(&v)) {
        // 处理double
    } else if (std::get_if<std::string>(&v)) {
        // 处理string
    }
    // 如果忘记某个分支，silent bug
}

void implicitConversion() {
    std::variant<int, double> v = 42;

    // 访问时可能发生隐式转换
    double d = std::get<double>(v);  // int被提升为double？不，这里会抛出异常

    // 正确的做法是明确知道当前类型
    if (auto* pInt = std::get_if<int>(&v)) {
        double d = static_cast<double>(*pInt);  // 显式转换
    }
}

#include <variant>
#include <type_traits>

void typeTraitsDemo() {
    using MyVariant = std::variant<int, double, std::string>;

    // 获取variant的大小（类型列表中的类型数量）
    std::cout << "variant_size: " << std::variant_size<MyVariant>::value << std::endl;  // 3

    // 获取指定位置的类型
    using FirstType = std::variant_alternative<0, MyVariant>::type;  // int
    using SecondType = std::variant_alternative<1, MyVariant>::type;  // double

    // 获取variant中最大类型的对齐要求
    std::cout << "aligned_storage: " << alignof(MyVariant) << std::endl;
}

#include <variant>
#include <iostream>

void helperFunctions() {
    using MyVariant = std::variant<int, double, std::string>;

    MyVariant v = 42;

    // 获取当前值的索引
    std::cout << "index: " << v.index() << std::endl;

    // 检查variant是否持有特定类型的值
    std::cout << "holds_alternative<int>: " << std::holds_alternative<int>(v) << std::endl;

    // 获取特定类型的值（可能抛出异常）
    int value = std::get<int>(v);

    // 安全地获取特定类型的值（返回空指针表示不匹配）
    auto* ptr = std::get_if<int>(&v);
}

#include <variant>
#include <iostream>
#include <string>

void visitAdvanced() {
    std::variant<int, double> v1 = 10;
    std::variant<int, double> v2 = 20;

    // 使用多个variant调用visit
    std::visit([](auto a, auto b) {
        std::cout << "a + b = " << (a + b) << std::endl;
    }, v1, v2);

    // visitor可以有状态
    int sum = 0;
    std::visit([&sum](auto value) {
        sum += value;
    }, v1);
    std::cout << "Sum: " << sum << std::endl;

    // visitor可以返回结果
    auto result = std::visit([](auto a, auto b) -> double {
        return a + b;
    }, v1, v2);
    std::cout << "Result: " << result << std::endl;
}

#include <variant>
#include <iostream>

void monostateUsage() {
    // Optional类型的设计模式
    using OptionalInt = std::variant<std::monostate, int>;

    OptionalInt empty;
    OptionalInt hasValue = 42;

    // 检查空状态
    if (std::holds_alternative<std::monostate>(empty)) {
        std::cout << "empty has no value" << std::endl;
    }

    // 在visit中处理空状态
    std::visit([](auto&& arg) {
        if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::monostate>) {
            std::cout << "Empty" << std::endl;
        } else {
            std::cout << "Value: " << arg << std::endl;
        }
    }, empty);
}

#include <variant>
#include <iostream>
#include <stdexcept>

void exceptionHandling() {
    std::variant<int, double> v = 10;

    try {
        // 尝试获取错误的类型
        std::cout << std::get<double>(v) << std::endl;
    } catch (const std::bad_variant_access& e) {
        std::cout << "Variant access error: " << e.what() << std::endl;
    }
}

#include <variant>
#include <vector>
#include <algorithm>

void combineWithContainers() {
    // variant的vector
    std::vector<std::variant<int, std::string, double>> values;
    values.push_back(1);
    values.push_back("hello");
    values.push_back(3.14);

    // 处理vector中的每个variant
    std::for_each(values.begin(), values.end(), [](const auto& v) {
        std::visit([](auto&& arg) {
            std::cout << arg << " ";
        }, v);
    });
    std::cout << std::endl;
}

// 与std::function组合
#include <functional>

using Operation = std::variant<
    std::function<int(int, int)>,    // 算术函数
    std::function<std::string(const std::string&)>  // 字符串函数
>;

void functionVariant() {
    Operation op = [](int a, int b) { return a + b; };

    std::visit([](auto&& func) {
        if constexpr (std::is_invocable_v<decltype(func), int, int>) {
            std::cout << "Result: " << func(10, 20) << std::endl;
        }
    }, op);
}

#include <variant>
#include <iostream>
#include <string>

// 前向声明
class TCPConnection;

// 状态类型定义
struct TCPState {
    virtual ~TCPState() = default;
    virtual void process(TCPConnection& conn) = 0;
};

struct ClosedState : TCPState {
    void process(TCPConnection& conn) override;
};

struct EstablishedState : TCPState {
    void process(TCPConnection& conn) override;
};

struct ListenState : TCPState {
    void process(TCPConnection& conn) override;
};

// 使用variant的状态模式（更轻量级的实现）
struct Closed {
    void enter(TCPConnection& conn) { std::cout << "Entering Closed state" << std::endl; }
    void exit(TCPConnection& conn) { std::cout << "Exiting Closed state" << std::endl; }
};

struct Established {
    void enter(TCPConnection& conn) { std::cout << "Connection established" << std::endl; }
    void exit(TCPConnection& conn) { std::cout << "Closing connection" << std::endl; }
};

struct Listening {
    int backlog = 10;
    void enter(TCPConnection& conn) { std::cout << "Listening on port" << std::endl; }
    void exit(TCPConnection& conn) { std::cout << "Stopped listening" << std::endl; }
};

// 使用variant的TCPConnection
class TCPConnection {
public:
    using State = std::variant<Closed, Established, Listening>;
    State currentState;

    void transitionTo(State newState) {
        std::visit([this](auto&& s) {
            s.exit(*this);
        }, currentState);

        currentState = std::move(newState);

        std::visit([this](auto&& s) {
            s.enter(*this);
        }, currentState);
    }

    void processData(const std::string& data) {
        std::visit([&data](auto&& s) {
            using T = std::decay_t<decltype(s)>;
            if constexpr (std::is_same_v<T, Established>) {
                std::cout << "Processing data: " << data << std::endl;
            } else {
                std::cout << "Cannot process data in this state" << std::endl;
            }
        }, currentState);
    }
};

#include <variant>
#include <iostream>
#include <string>

// 抽象语法树节点类型
struct NumberNode {
    int value;
};

struct BinaryOpNode {
    char op;
    void* left;
    void* right;
};

struct StringNode {
    std::string value;
};

// 使用variant表示所有节点类型
using ASTNode = std::variant<NumberNode, BinaryOpNode, StringNode>;

// 访问者定义
struct PrintVisitor {
    void operator()(const NumberNode& n) {
        std::cout << n.value;
    }

    void operator()(const BinaryOpNode& op) {
        std::cout << "(";
        std::visit(*this, *static_cast<ASTNode*>(op.left));
        std::cout << " " << op.op << " ";
        std::visit(*this, *static_cast<ASTNode*>(op.right));
        std::cout << ")";
    }

    void operator()(const StringNode& s) {
        std::cout << "\"" << s.value << "\"";
    }
};

// 使用variant的表达式求值器
struct EvalVisitor {
    int operator()(const NumberNode& n) {
        return n.value;
    }

    int operator()(const BinaryOpNode& op) {
        int left = std::visit(*this, *static_cast<ASTNode*>(op.left));
        int right = std::visit(*this, *static_cast<ASTNode*>(op.right));

        switch (op.op) {
            case '+': return left + right;
            case '-': return left - right;
            case '*': return left * right;
            case '/': return left / right;
            default: return 0;
        }
    }

    int operator()(const StringNode&) {
        return 0;  // 字符串不参与数值运算
    }
};