Хранение объектов разных типов в контейнере

#include <iostream>
#include <string>
#include <vector>
#include <memory>
 
class NodeVisitor {
public:
    virtual void visit(int) = 0;
    virtual void visit(double) = 0;
    virtual void visit(std::string const &) = 0;
};
 
class Node {
public:
    virtual void operate_with(NodeVisitor &) = 0;   
};
 
class Int : public Node {
public:
    explicit Int(int val) : value(val) {}
 
    void operate_with(NodeVisitor & v) override {
        v.visit(value);
    }
private:
    int value;
};
 
class Double : public Node {
public:
    explicit Double(double val) : value(val) {}
 
    void operate_with(NodeVisitor & v) override {
        v.visit(value);
    }
private:
    double value;
};
 
class String : public Node {
public:
    explicit String(std::string const & val) : value(val) {}
 
    void operate_with(NodeVisitor & v) override {
        v.visit(value);
    }
private:
    std::string value;
};
 
int main()
{
    std::vector<std::unique_ptr<Node>> all;
    
    all.push_back(std::make_unique<Int>(42));
    all.push_back(std::make_unique<Double>(3.14));
    all.push_back(std::make_unique<String>("Hello World!"));
    
    struct PrintValue : NodeVisitor {
        void visit(int v) {
            std::cout << "Int value: " << v << std::endl;
        }
        void visit(double v) {
            std::cout << "Double value: " << v << std::endl;
        }
        void visit(std::string const & v) {
            std::cout << "String value: " << v << std::endl;
        }        
    };
    
    PrintValue printer;
    for(auto & n : all) {
        n->operate_with(printer);
    }
}

#include <iostream>
#include <string>
#include <vector>
#include <variant>
 
template <typename ...Values>
class variant_vector {
public:
    using common_value_type = std::variant<Values...>;
    
    variant_vector() = default;
    
    template <typename T>
    void push_back(T const & v) {
        m_container.push_back(v);
    }
    
    auto begin() { return m_container.begin(); }
    auto end() { return m_container.end(); }
    auto begin() const { return m_container.begin(); }
    auto end() const { return m_container.end(); }    
    
private:
    std::vector<common_value_type> m_container;
};
 
int main()
{
    variant_vector<int, double, std::string> all;
    
    all.push_back(42);
    all.push_back(3.14);
    all.push_back("Hello World!");
    
    struct PrintValue {
        void operator()(int v) {
            std::cout << "Int value: " << v << std::endl;
        }
        void operator()(double v) {
            std::cout << "Double value: " << v << std::endl;
        }
        void operator()(std::string const & v) {
            std::cout << "String value: " << v << std::endl;
        }        
    };
    
    PrintValue printer;
    for(auto & n : all) {
        std::visit(printer, n);
    }
}