静态类型语言中如何实现返回数字或字符串的多类型返回函数？

针对你遇到的问题，下面逐一解答并给出具体实现示例：

1. 静态类型语言中的可行实现方式 #

当然有。核心逻辑是用一个统一的"容器类型"封装两种返回值可能性，因为静态类型语言要求函数返回值类型在编译期确定，无法直接根据运行时输入动态返回不同类型。只要用能容纳两种类型的结构作为返回值，就能实现需求。

2. 推荐的语言特性与设计模式 #

变体/联合类型（Variant/Union Type） #

这是最直接的方案，多数现代静态类型语言原生支持：

• C++17+：std::variant
• Rust：关联值的枚举（Enum）
• TypeScript：string | number 联合类型
• C#：可使用第三方库OneOf或自定义类似结构

标签联合（Tagged Union） #

手动实现带类型标记的联合结构，用枚举标记当前存储的类型，搭配联合体存储实际值，适合底层语言场景。

多态结果类 #

如果语言不支持变体类型，可定义一个抽象基类，为数字、字符串分别实现子类，函数返回基类指针/引用，调用方通过多态或类型判断处理不同结果。

3. 现有思路的改进建议 #

你的重载思路不可行——静态类型语言的重载是编译期根据参数类型匹配，而非运行时根据参数值匹配。以下是具体改进方案：

方案一：使用变体类型（C++示例） #

#include <variant>
#include <string>
#include <stdexcept>
#include <cstdio>

using ResultType = std::variant<int, std::string>;

ResultType tmp(const std::string& a) {
    if (a == "a") {
        return 1;
    } else if (a == "b") {
        return std::string("a");
    }
    throw std::invalid_argument("Invalid input");
}

void Result(const ResultType& res) {
    std::visit([](auto&& val) {
        using T = std::decay_t<decltype(val)>;
        if constexpr (std::is_same_v<T, int>) {
            printf("Got number: %d\n", val);
        } else if constexpr (std::is_same_v<T, std::string>) {
            printf("Got string: %s\n", val.c_str());
        }
    }, res);
}

// 调用示例
int main() {
    Result(tmp("a"));
    Result(tmp("b"));
    return 0;
}

方案二：将输入值映射为不同类型（利用重载） #

如果一定要用重载，可把输入字符串转换成不同的标签类型，让编译器能区分重载：

#include <string>
#include <stdexcept>

struct TagA {};
struct TagB {};

int tmp(TagA) { return 1; }
std::string tmp(TagB) { return "a"; }

auto map_input(const std::string& a) {
    if (a == "a") return tmp(TagA{});
    if (a == "b") return tmp(TagB{});
    throw std::invalid_argument("Invalid input");
}

方案三：多态结果类（无变体类型时使用） #

#include <iostream>
#include <string>
#include <memory>

class BaseResult {
public:
    virtual ~BaseResult() = default;
    virtual void process() = 0;
};

class NumberResult : public BaseResult {
private:
    int val;
public:
    NumberResult(int v) : val(v) {}
    void process() override {
        std::cout << "Number: " << val << std::endl;
    }
};

class StringResult : public BaseResult {
private:
    std::string val;
public:
    StringResult(const std::string& v) : val(v) {}
    void process() override {
        std::cout << "String: " << val << std::endl;
    }
};

std::unique_ptr<BaseResult> tmp(const std::string& a) {
    if (a == "a") {
        return std::make_unique<NumberResult>(1);
    } else if (a == "b") {
        return std::make_unique<StringResult>("a");
    }
    throw std::invalid_argument("Invalid input");
}

void Result(std::unique_ptr<BaseResult> res) {
    res->process();
}

// 调用示例
int main() {
    Result(tmp("a"));
    Result(tmp("b"));
    return 0;
}

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