在C++中模拟Python集合：代码问题与优化探讨

原代码的问题分析 #

你最初的代码编译失败的核心原因是C++不允许仅通过返回值来重载函数。基类Handle里声明了三个同名的val()函数，只是返回值不同，这在C++里是不合法的——编译器无法根据返回值来区分调用哪个版本，所以会直接报错。

修复方案：基于多态的统一行为接口 #

你后来修改的代码思路完全正确：把返回不同类型值的逻辑，改成一个统一的行为接口（比如print），让每个子类去实现自己的打印方式，这样就绕开了返回值重载的问题。这里给修改后的代码做几个小优化，更贴合现代C++的编码习惯：

// experimenting with vectors of heterogeneous elements (like sets in python)
#include <iostream>
#include <memory>
#include <string>
#include <vector>

// Handle can wrap an int, a double, or a string.
class Handle {
public:
    Handle() = default;
    virtual ~Handle() = default; // 必须加虚析构，避免多态场景下的内存泄漏
    virtual void print(std::ostream&) const = 0; // 改为const成员函数，符合const正确性
};

class Int : public Handle {
public:
    Int(int n) : value(n) {};
    void print(std::ostream& s) const override { 
        s << value << '\n'; // 用'\n'替代endl，减少不必要的缓冲区刷新，提升效率
    };
private:
    int value;
};

class Double : public Handle {
public:
    Double(double n) : value(n) {};
    void print(std::ostream& s) const override { 
        s << value << '\n'; 
    };
private:
    double value;
};

class String : public Handle {
public:
    String(const std::string& n) : value(n) {};
    void print(std::ostream& s) const override { 
        s << value << '\n'; 
    };
private:
    std::string value;
};

int main() {
    std::vector<std::shared_ptr<Handle>> v(12);
    for (size_t i = 0; i < v.size(); i += 3) {
        v[i] = std::make_shared<Int>(i); // 用make_shared替代直接new，更安全高效
        v[i + 1] = std::make_shared<Double>(i + 1.);
        v[i + 2] = std::make_shared<String>(std::to_string(i + 2));
    }
    for (const auto& ptr : v) {
        ptr->print(std::cout);
    }
}

补充的细节说明：

• 虚析构函数：基类指针指向子类对象时，虚析构能确保子类的析构函数被正确调用，避免内存泄漏。
• const成员函数：打印操作不会修改对象状态，标记为const后可以在const对象上调用，代码更严谨。
• std::make_shared：减少内存分配次数，同时避免因异常导致的内存泄漏，是现代C++推荐的智能指针创建方式。
• '\n'替代std::endl：endl会强制刷新输出缓冲区，频繁使用会降低程序效率，除非你确实需要立即输出内容。

更优的惯用实现：使用std::variant（C++17及以上） #

如果你的项目支持C++17或更高版本，**std::variant**是实现异构容器更简洁、高效的方案，不需要手动编写继承体系，代码量大幅减少：

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

// 定义variant类型，支持int、double、string三种元素
using PythonLikeElement = std::variant<int, double, std::string>;

// 定义访问器，用于处理不同类型的元素打印
struct PrintVisitor {
    void operator()(int val) const {
        std::cout << val << '\n';
    }
    void operator()(double val) const {
        std::cout << val << '\n';
    }
    void operator()(const std::string& val) const {
        std::cout << val << '\n';
    }
};

int main() {
    std::vector<PythonLikeElement> v;
    for (size_t i = 0; i < 4; ++i) {
        v.push_back(i);
        v.push_back(i + 1.);
        v.push_back(std::to_string(i + 2));
    }

    for (const auto& elem : v) {
        std::visit(PrintVisitor{}, elem);
    }
}

这种方案的优势：

1. 无需手动管理多态：std::variant是标准库提供的类型安全联合类型，编译器会自动处理类型检查，避免继承体系的繁琐。
2. 性能更优：variant对象直接存储在容器中（而非指针），没有额外的内存分配开销，访问速度更快。
3. 类型安全：如果尝试访问错误的类型，编译器或运行时会给出明确提示（比如std::get类型不匹配时会抛出std::bad_variant_access异常）。

灵活度更高的选择：std::any（C++17及以上） #

如果你需要支持任意可拷贝构造的类型（而非预定义的几种），可以用std::any，但使用时需要手动指定类型取出值：

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

int main() {
    std::vector<std::any> v;
    v.push_back(1);
    v.push_back(2.5);
    v.push_back(std::string("hello"));

    for (const auto& elem : v) {
        if (elem.type() == typeid(int)) {
            std::cout << std::any_cast<int>(elem) << '\n';
        } else if (elem.type() == typeid(double)) {
            std::cout << std::any_cast<double>(elem) << '\n';
        } else if (elem.type() == typeid(std::string)) {
            std::cout << std::any_cast<std::string>(elem) << '\n';
        }
    }
}

不过std::any的灵活性是以性能和类型安全为代价的：它需要额外存储类型信息，取出值时必须准确指定类型，否则会抛出异常。因此如果你的异构类型是固定的几种，std::variant是更优的选择。

内容的提问来源于stack exchange，提问作者J. D.