Контейнерный класс, с чем есть?

template <class T>
class Container {
 public:
  // добавление одного элемента
  bool add(const T &value) = 0;
  // добавление многих элементов
  bool add(ConstIterator first, ConstIterator last) = 0;
  // удаление одного элемента
  bool remove(ConstIterator position) = 0;
  // удаление многих элементов
  bool remove(ConstIterator first, ConstIterator last) = 0;
  // обход элементов
  // первый элемент
  ConstIterator begin() const = 0;
  // элемент, следующий за последним
  ConstIterator end() = 0;
  // проверка на содержание элемента
  bool contains(const T &value) const = 0;
  // проверка на пустоту контейнера
  bool isEmpty() const = 0;
  // получение количества элементов в контейнере
  int getSize() const = 0;
};

#include <ctime>
#include <cstdlib>
#include <iostream>
#include <string>
 
template <class T>
class ArrayList {
 public:
  typedef T* Iterator;
  typedef const T* ConstIterator;
  ArrayList(size_t capacity) : capacity(capacity), size(0),
    data(new T[capacity]) {}
  ArrayList(const ArrayList &other) : capacity(other.getCapacity()),
    size(0), data(new T[capacity]) {
    insert(begin(), other.begin(), other.end());
  }
  ArrayList &operator=(const ArrayList &other) {
    if (this != &other) {
      clear();
      insert(begin(), other.begin(), other.end());
    }
    return *this;
  }
  virtual ~ArrayList() {
    delete [] data;
  }
  Iterator begin() { return data; }
  ConstIterator begin() const { return data; }
  Iterator end() { return data + size; }
  ConstIterator end() const { return data + size; }
 
  Iterator insert(Iterator position, const T &value) {
    size_t distance = position - begin();
    // тут прекрасное место для кода, увеличивающего вместимость
    // хранилища при необходимости
    for (Iterator i = end(); i != begin() + distance; --i) {
      *i = *(i - 1);
    }
    *(begin() + distance) = value;
    ++size;
    return begin() + distance; 
  }
  Iterator insert(Iterator position, ConstIterator first, ConstIterator last) {
    while (first != last) {
      position = insert(position++, *first++);
      ++position;
    }
    return position;
  }
  Iterator erase(Iterator position) {
    for (Iterator i = position; i != end(); ++i) {
      *i = *(i + 1);
    }
    --size;
    return position;
  }
  Iterator erase(Iterator first, Iterator last) {
    while (first != last) {
      erase(first);
      --last;
    }
    return first;
  }
  // эта функция должна быть "внешней" относительно класса,
  // но я просто оставлю её тут
  Iterator find(const T &value) {
    for (Iterator i = begin(); i != end(); ++i) {
      if (*i == value) {
        return i;
      }
    }
    return end();
  }
  void clear() {
    size = 0;
  }
  Iterator pushBack(const T &value) {
    return insert(end(), value);
  }
  Iterator pushFront(const T &value) {
    return insert(begin(), value);
  }
  size_t getCapacity() const { return capacity; }
  size_t getSize() const { return size; }
 private:
  size_t capacity;
  size_t size;
  T *data;
};
 
class Book {
 public:
  Book() {}
  Book(const std::string &name) : name(name) {}
  const std::string &getName() const { return name; }
 private:
  std::string name;  
};
 
bool operator==(const Book &a, const Book &b) {
  return a.getName() == b.getName();
}
 
std::ostream &operator<<(std::ostream &stream, const Book &book) {
  return stream << "Book{" <<
    "name='" << book.getName() << "'}";
}
 
class Library {
 public:
  typedef ArrayList<Book>::Iterator BookIterator;
  typedef ArrayList<Book>::ConstIterator ConstBookIterator;
  Library(size_t capacity) : name(), books(capacity) {}
  Library(size_t capacity, const std::string &name) : name(name),
    books(capacity) {}
  const std::string &getName() const { return name; }
 
  BookIterator begin() { return books.begin(); }
  ConstBookIterator begin() const { return books.begin(); }
  BookIterator end() { return books.end(); }
  ConstBookIterator end() const { return books.end(); }
 
  size_t getSize() const { return books.getSize(); }
 
  BookIterator add(const Book &book) {
    return books.pushBack(book);
  }
  BookIterator find(const Book &book) {
    return books.find(book);
  }
  BookIterator erase(BookIterator &position) {
    return books.erase(position);
  }
  bool erase(const Book &book) {
    BookIterator position = find(book);
    if (position == end()) {
      return false;
    }
    erase(position);
    return true;
  }
 private:
  std::string name;
  ArrayList<Book> books;
};
 
std::ostream &operator<<(std::ostream &stream, const Library &l) {
  stream << "Library{" <<
    "name='" << l.getName() << "'," << 
    "books=[";
  for (Library::ConstBookIterator i = l.begin(); i != l.end(); ++i) {
    stream << *i;
    if (i + 1 != l.end()) stream << ",";
  }
  return stream << "]}";
}
 
int main(int argc, char *argv[]) {
  srand(time(0));
 
  Library a(10), b(10);
 
  a.add(Book("First book"));
  a.add(Book("Second book"));
  a.add(Book("Third book"));
 
  b.add(Book("Fourth book"));
  b.add(Book("Sixth book"));
  b.add(Book("Seventh book"));
 
  // передача книги
  Book secondBook = *(a.begin() + 1); // "Second book";
  a.erase(secondBook);
  b.add(secondBook);
 
  std::cout << a << std::endl << b << std::endl;
 
};