Очень срочно , через 2 дня сдача) (композиция, наследование)

class A{};
 
class B{
   A a;//композиция
};

#include <iostream>
#include <vector>
 
// Well... U'd better use std::swap instead.
// but then you should use std::set, shouldn't you? ;)
template <class ValueType>
void swap(ValueType &a, ValueType &b) {
  ValueType c = a;
  a = b;
  b = c;
}
 
template <typename ValueType>
class Set {
 public:
  struct Node {
    Node *left;
    Node *right;
    ValueType key;
    Node() : left(NULL), right(NULL) {}
    explicit Node(const ValueType &value)
      : left(NULL), right(NULL), key(value) {}
  };
  Set() : root_(NULL), size_(0) {}
  ~Set() {
    Clear();
  }
  void Clear() {
    RecursiveFreeTree(&root_);
  }
  bool Has(const ValueType &value) {
    return *NonRecursiveFind(&root_, value);
  }
  void Insert(const ValueType &value) {
    NonRecursiveInsert(&root_, value);
  }
  void Remove(const ValueType &value) {
    Node **node = NonRecursiveFind(&root_, value);
    if (*node != NULL)
      RecursiveRemoveNode(node);
  }
  std::ostream &Print(std::ostream &stream) {
    return RecursiveOrderedPrint(&root_, stream);
  }
  template <class Container>
  Container &ToContainer(Container &container) {
    RecursiveToContainer(&root_, container);
    return container;
  }
 protected:
  template <class Container>
  Container &RecursiveToContainer(Node **node, Container &container) {
    if (*node != NULL) {
      RecursiveToContainer(&(*node)->right, container);
      container.push_back((*node)->key);
      RecursiveToContainer(&(*node)->left, container);
    }
    return container;
  }
  void RecursiveRemoveNode(Node **node) {
    Node *this_node = *node;
    if ((*node)->left == NULL) {
      *node = (*node)->right;
      delete this_node;
    } else if ((*node)->right == NULL) {
      *node = (*node)->left;
      delete this_node;
    } else {
      Node **pred = &(*node)->left;
      while ((*pred)->right != NULL)
        pred = &(*pred)->right;
      swap((*pred)->key, (*node)->key);
      RecursiveRemoveNode(pred);
    }
  }
  std::ostream &RecursiveOrderedPrint(Node **root, std::ostream &stream) {
    if (*root != NULL) {
      RecursiveOrderedPrint(&(*root)->right, stream);
      stream << (*root)->key << " ";
      RecursiveOrderedPrint(&(*root)->left, stream);
    }
    return stream;
  }
  Node **NonRecursiveFind(Node **root, const ValueType &value) {
    while (*root != NULL) {
      if (value < (*root)->key)
        root = &(*root)->left;
      else
      if ((*root)->key < value)
        root = &(*root)->right;
      else
        break;
    }
    return root;
  }
  void NonRecursiveInsert(Node **root, const ValueType &value) {
    while (*root != NULL) {
      if (value < (*root)->key)
        root = &(*root)->left;
      else
      if ((*root)->key < value)
        root = &(*root)->right;
      else
        return;
    }
    *root = new Node(value);
  }
  void RecursiveFreeTree(Node **root) {
    if (*root != NULL) {
      RecursiveFreeTree(&(*root)->left);
      RecursiveFreeTree(&(*root)->right);
      delete *root;
      *root = NULL;
      --size_;
    }
  }
  Node *root_;
  size_t size_;
 private:
  Set(const Set &other);
  Set &operator=(const Set &other);
};
 
class MoreSet: public Set<int> {
 public:
  int Multiplied() {
    std::vector<int> array;
    ToContainer(array);
    int result = 1;
    for (size_t i = 0; i < array.size(); ++i)
      result *= array[i];
    return result;
  }
};
 
int main(int argc, char *argv[]) {
  MoreSet bst;
  bst.Insert(8);
  bst.Insert(4);
  bst.Insert(6);
  bst.Insert(2);
  bst.Insert(3);
  bst.Insert(1);
 
  bst.Print(std::cout);
  std::cout << std::endl;
 
  if (bst.Has(4))
    bst.Remove(4);
 
  std::vector<int> result;
  bst.ToContainer(result);
 
  bst.Print(std::cout);
  std::cout << std::endl;
  
  std::cout << bst.Multiplied() << std::endl;
}