C++中是否存在类似Java/C#的object通用数据类型？

嘿，我来帮你理清这个问题～首先得明确：你写的template <class T> T t[] = {1, "2"};是完全行不通的。因为模板参数T必须是单一确定的类型——这里1是int，"2"是const char*，编译器根本找不到一个能同时兼容这两个类型的T，直接会报编译错误。

C++是静态强类型语言，没有像Java/C#那样内置的object（统一根类型），但我们有几种类型安全的方式来实现“存储不同类型数据”的需求，下面给你逐一讲解：

方案1：用C++17的std::variant（最推荐） #

std::variant是标准库提供的类型安全的联合类型，它允许你存储指定的几种类型中的任意一种，而且在编译期就会检查类型合法性。

比如我们要存int和std::string，可以这样写：

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

// 定义一个能存int和string的variant别名，方便复用
using MyData = std::variant<int, std::string>;

int main() {
    // 二维容器：用vector的vector来模拟二维数组
    std::vector<std::vector<MyData>> my2DArray = {
        {100, std::string("foo")},
        {200, std::string("bar")}
    };

    // 访问元素的两种方式：
    // 1. 明确指定类型用std::get（类型不匹配会抛异常）
    int num = std::get<int>(my2DArray[0][0]);
    std::string str = std::get<std::string>(my2DArray[0][1]);
    std::cout << num << " | " << str << std::endl;

    // 2. 用std::visit自动匹配类型（更灵活）
    std::visit([](auto&& value) {
        using ValueType = std::decay_t<decltype(value)>;
        if constexpr (std::is_same_v<ValueType, int>) {
            std::cout << "Found integer: " << value << "\n";
        } else if constexpr (std::is_same_v<ValueType, std::string>) {
            std::cout << "Found string: " << value << "\n";
        }
    }, my2DArray[1][1]);

    return 0;
}

方案2：用C++17的std::any #

std::any可以存储任意类型的数据，但代价是类型安全需要自己保证——取出时如果类型不匹配，会抛出std::bad_any_cast异常。适合你不确定要存哪些类型的场景：

#include <any>
#include <string>
#include <vector>
#include <iostream>

int main() {
    std::vector<std::vector<std::any>> my2DArray = {
        {3.14, std::string("pi")},
        {true, 42}
    };

    try {
        double pi = std::any_cast<double>(my2DArray[0][0]);
        std::cout << "Pi value: " << pi << "\n";
        bool flag = std::any_cast<bool>(my2DArray[1][0]);
        std::cout << "Flag: " << std::boolalpha << flag << "\n";
    } catch (const std::bad_any_cast& e) {
        std::cerr << "Type cast failed: " << e.what() << "\n";
    }

    return 0;
}

方案3：多态基类（兼容C++17之前的旧标准） #

如果你的编译器不支持C++17，可以用传统的面向对象多态来实现：定义一个抽象基类，然后为每个要存储的类型写派生类，用智能指针管理对象：

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

// 抽象基类，定义统一接口
class BaseData {
public:
    virtual ~BaseData() = default; // 虚析构是多态的必要条件
    virtual void print() const = 0; // 纯虚函数，强制派生类实现
};

// 存储int的派生类
class IntData : public BaseData {
private:
    int value;
public:
    IntData(int v) : value(v) {}
    void print() const override {
        std::cout << "Integer: " << value << "\n";
    }
    int getValue() const { return value; }
};

// 存储string的派生类
class StringData : public BaseData {
private:
    std::string value;
public:
    StringData(const std::string& v) : value(v) {}
    void print() const override {
        std::cout << "String: " << value << "\n";
    }
    const std::string& getValue() const { return value; }
};

int main() {
    // 二维容器：用unique_ptr管理基类对象
    std::vector<std::vector<std::unique_ptr<BaseData>>> my2DArray;
    my2DArray.push_back({
        std::make_unique<IntData>(123),
        std::make_unique<StringData>("hello")
    });

    // 遍历打印所有元素
    for (const auto& row : my2DArray) {
        for (const auto& elem : row) {
            elem->print();
        }
    }

    // 获取具体类型的值需要dynamic_cast
    if (auto* intPtr = dynamic_cast<IntData*>(my2DArray[0][0].get())) {
        std::cout << "Extracted int: " << intPtr->getValue() << "\n";
    }

    return 0;
}

避坑提醒 #

千万别用void*来存储不同类型——虽然它能存任意指针，但完全没有类型安全检查，很容易出现内存泄漏、野指针、类型转换错误等问题，调试起来会非常头疼。

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