Посоветуйте статьи или книги где есть примеры собственных контейнеров

BinaryTree

NodeBinaryTree

BinaryTree

NodeBinaryTree

class BinarySearchTree: BinaryTree

 class NodeBinarySearchTree: NodeBinaryTree

template <typename T>       // Элемент двоичного дерева поиска
struct NodeBinaryTree
{
public:
    CTreeElement *Left;
    CTreeElement *Right;
    T Data;
}
 
template <typename T>   // Элемент сбалансированного двоичного дерева поиска
struct NodeSearchBinaryTree :  NodeBinaryTree<T>    
{
public:
    int Height;
}
 
 
 
 
 
 
 
template <typename T>
struct SDictionaryItem
{
public:
    T Word;
    int Count;
};
 
 
template <typename T>
class BinaryTree
{
public:
    NodeBinaryTree<SDictionaryItem<T>> *Root;  // Корень
    typedef CIterator<NodeBinaryTree<SDictionaryItem<T>>> Iterator;
public:
    CTree() : Root(nullptr) {};
    virtual ~CTree();
    void Clear();
    NodeBinaryTree<SDictionaryItem<T>>* GetRoot();
    bool InsertElement(const T &Word);
    bool Empty();
    bool DeleteElement(const T &Word);
    Iterator Begin() const;
    Iterator End() const;
    Iterator Find(T Word) const;
    list<NodeBinaryTree<SDictionaryItem<T>>> GetSortMas() ;
};
 
 
template <typename T>
class BinarySearchTree: BinaryTree<T>
{
      /* Тут мне надо чтобы методы GetRoot и GetSortMas работали и возвращали не    
 NodeBinaryTree<SDictionaryItem<T>>*, а  NodeSearchBinaryTree<SDictionaryItem<T>>*  , 
  то есть чтобы сам их код был такой же, но единственное чем они бы отличались это
тем что работают каждая с соответствующим элементом соответствующего контейнера*/
 
// Тут какие то новые методы производного класса....
}

#include <iostream>
 
template <class node, class T>
class iterator
{
public:
 
    iterator(node* n)
    : node_ptr(n)
    {
    }
 
    T* operator * ()
    {
        return node_ptr->get();
    }
 
    T* operator -> ()
    {
        return node_ptr->get();
    }
 
    void operator ++ ()
    {
        node_ptr = node_ptr->next();
    }
 
    iterator operator ++ (int)
    {
        iterator iter(*this);
        ++(*this);
        return iter;
    }
 
    bool operator == (iterator const& i)
    {
        return node_ptr == i.node_ptr;
    }
 
    bool operator != (iterator const& i)
    {
        return !(*this == i);
    }
 
private:
 
    node* node_ptr;
};
 
template <class T>
class list_node
{
public:
 
    list_node(T const& t)
    : object(t)
    , next_node(0)
    {
        
    }
 
    ~list_node()
    {
        delete next_node;
    }
 
    void push_back(T const& t)
    {
        if(next_node)
        {
            next_node->push_back(t);
        }
        else
        {
            next_node = new list_node(t);
        }
    }
 
    list_node* next()
    {
        return next_node;
    }
 
    T* get()
    {
        return &object;
    }
 
private:
 
    T object;
    list_node* next_node;
};
 
template <class T>
class list
{
public:
 
    typedef list_node<T> node;
 
    typedef iterator<node, T> iterator;
 
    list()
    : root(0)
    {
    }
 
    ~list()
    {
        delete root;
    }
 
    void push_back(T const& t)
    {
        if(root)
        {
            root->push_back(t);
        }
        else
        {
            root = new node(t);
        }
    }
 
    iterator begin()
    {
        return iterator(root);
    }
 
    iterator end()
    {
        return iterator(0);
    }
 
private:
 
    node* root;
};
 
int main()
{
    typedef list<std::string> string_container;
    string_container orders;
 
    orders.push_back("First");
    orders.push_back("Second");
    orders.push_back("Third");
    orders.push_back("Fourth");
 
    for(string_container::iterator it = orders.begin(); it != orders.end(); ++it)
    {
        std::cout << it->c_str() << std::endl;
    }
 
    return 0;
}