Implementation of Trie data structure accommodating varying number of children
Your code does several things more complex than required. In no particular order:


What purpose does Trie_node_base serve? You don’t need a base class here since you only inherit from it once.
Worse, your base class doesn’t have a virtual destructor.
To create an array of size n, you use a loop and push_back. Much easier would be to use the proper initialiser:

Trie_node_base(int n) :
    num_of_child(n) ,
    child(n)
    { }

In fact, you generally fail to use initialisers, and instead re-assign values inside the constructor.
Consider proper naming. In the above code snippet, it should really be number_of_children and children (plural!).
The num_of_child member is redundant – the same information is stored in the vector.
The tree node root doesn’t need to, and shouldn’t be, a pointer.
In general, your use of pointers and manual memory management makes the code vastly more complex and brittle (and requires the existence of the destroy method). If you need to use pointers, use smart pointers (std::unique_ptr in this case).
Better yet, omit pointers entirely. They are utterly unnecessary here. Unfortunately though, you cannot use std::vector with an incomplete class (the standard screwed up here). But you can (and should!) use boost::container::vector. Thus your tree node implementation becomes:

struct Trie_node
{
    boost::container::vector&lt;Trie_node&gt; children;
    bool is_word;

    Trie_node(int n)
        : children(n)
        , is_word(false)
    { }
};



… There’s more but these are the essential points that will help reduce code complexity.