Дерево с узлами трёх разных типов

template <typename T>
class tree_node
{
    using value_type = typename std::enable_if
        <
            std::is_same<std::string, T>::value ||
            std::is_same<int, T>::value ||
            std::is_same<float, T>::value, T
        >::type;
    value_type data;
    std::vector<??????> children;// Что за тип здесь должен быть?
public:
...

struct node_data {};
struct str_node: public node_data
{
    std::string data;
    str_node(std::string &str): data(str) {};
};
struct int_node: public node_data
{
    int data;
    int_node(int n): data(n) {};
};
struct float_node: public node_data
{
    float data;
    float_node(float f): data(f) {};
};
 
class tree_node
{
    std::shared_ptr<node_data> val;
    std::vector<std::shared_ptr<node_data>> children;
public:
....
//Поскольку для подклассового полиморфизма нужно работать с указателями решил заодно 
//использовать кучу, а затем, чтобы не писать сложный деструктор, обернул в умные 
//указатели. Ввиду того, что шаблоны использовать нельзя, приходится писать многие методы 
//в трёх экземплярах, соответственно смысла в полиморфизме мало.

    void add_child(std::string &_val)
    {
        if(children.empty())
            children.resize(3);
        children.push_back(std::shared_ptr<node_data>(new str_node(_val)));
    }
    void add_child(int _val)
    {
        if(children.empty())
            children.resize(3);
        children.push_back(std::shared_ptr<node_data>(new int_node(_val)));
    }
    void add_child(float _val)
    {
        if(children.empty())
            children.resize(3);
        children.push_back(std::shared_ptr<node_data>(new float_node(_val)));
    }

class Tree
{
public:
    virtual bool isString()const{return false;}
    virtual bool isInt()const{return false;}
    virtual bool isDouble()const{return false;}
 
    virtual const std::string&getString()const{throw std::runtime_error("Ops..");}
    virtual int getInt()const{throw std::runtime_error("Ops..");}
    virtual double getDouble()const{throw std::runtime_error("Ops..");}
 
    std::vector<std::unique_ptr<Tree>> childList;
};

class Tree
{
public:
    virtual bool isString()const{return true;}
    virtual bool isInt()const{return false;}
    virtual bool isDouble()const{return false;}
 
    virtual const std::string&getString()const{ return std::string("abc");}
    virtual int getInt()const{throw std::runtime_error("Ops..");}
    virtual double getDouble()const{throw std::runtime_error("Ops..");}
 
    std::vector<std::unique_ptr<Tree>> childList;
};

//это через union
class TreeUnion
{
public:
    enum Type{isString,isInt};
    TreeUnion(const std::string&value):type(isString),stringValue(value){}
    TreeUnion(int value):type(isInt),intValue(value){}
    ~TreeUnion()
    {
        if(type==isString)
            stringValue.std::string::~string();
    }
 
    Type type;
    union
    {
        std::string stringValue;
        int intValue;
    };
};
 
class TreeVirtual
{
public:
    virtual bool isString()const{return false;}
    virtual bool isInt()const{return false;}
    virtual bool isDouble()const{return false;}
 
    virtual const std::string&getString()const{throw std::runtime_error("Ops..");}
    virtual int getInt()const{throw std::runtime_error("Ops..");}
    virtual double getDouble()const{throw std::runtime_error("Ops..");}
 
    std::vector<std::unique_ptr<TreeVirtual>> childList;
};
 
//вот здесь хранится строка для TreeVirtual
class TreeString
{
public:
    bool isString()const{return true;}
    const std::string&getString()const{return value;}
    std::string value;
};

class Elbase{
    virtual size_t typehash() =0;
};
 
template <typename T>
class Elem :Elbase {
    using value_type = typename std::enable_if
        <
            std::is_same<std::string, T>::value ||
            std::is_same<int, T>::value ||
            std::is_same<float, T>::value, T
        >::type;
    size_t typehash(){ return typeid(T).hash_code();};
    T val;
};