Упорядоченный односвязный список - C++ - Ответ 2389290

#include <iostream>
 
struct NodeBase {
  NodeBase *next;
  NodeBase() : next(this) {}
  NodeBase(NodeBase *next_) : next(next_) {}
};
 
template <class T>
struct NodeType : public NodeBase {
  NodeType(NodeBase *next_, const T &data_) : NodeBase(next_), data(data_) {}
  T data;
};
 
template <class T>
class SortedList {
 public:
  typedef NodeType<T> Node;
  class Iterator {
   public:
    Iterator(const Iterator &iterator) : node_(iterator.node_) {}
    Iterator(const NodeBase *node) : node_(node) {}
    Iterator &operator++() { node_ = node_->next; return *this; }
    const T &operator*() const { return static_cast<const Node*>(node_)->data; }
    const T &operator->() const { return static_cast<const Node*>(node_)->data; }
    bool operator==(const Iterator &other) { return other.node_ == node_; }
    bool operator!=(const Iterator &other) { return !(*this == other); }
   private:
    const NodeBase *node_;
  };
  SortedList() : base_() {}
  SortedList(const SortedList &other) : base_() {
    for (Iterator i = other.begin(); i != other.end(); ++i)
      insertSorted(*i);
  }
  ~SortedList() { clear(); }
  SortedList &operator=(const SortedList &other) {
    if (this != &other) {
      for (Iterator i = other.begin(); i != other.end(); ++i)
        insertSorted(*i);
      clear();
    }
    return *this;
  }
  void insertSorted(const T &data) {
    NodeBase *prev = &base_;
    NodeBase *next = base_.next;
    while (next != &base_ && static_cast<Node*>(next)->data < data) {
      next = next->next;
      prev = prev->next;
    }
    Node *node = new Node(next, data);
    prev->next = node;
  }
  Iterator begin() const { return Iterator(base_.next); }
  Iterator end() const { return Iterator(&base_); }  
  bool isEmpty() const {
    return base_.next == &base_;
  }
  void clear() {
    while (base_.next != &base_) {
      NodeBase *node = base_.next->next;
      delete base_.next;
      base_.next = node;
    }
  }
 private:
  NodeBase base_;
};
 
SortedList<int> operator*(const SortedList<int> &list, int multiplier) {
  SortedList<int> result;
  for (SortedList<int>::Iterator i = list.begin(); i != list.end(); ++i)
    result.insertSorted(*i * multiplier);
  return result;
}
 
template <class T>
std::ostream &operator<<(std::ostream &stream, const SortedList<T> &list) {
  for (typename SortedList<T>::Iterator i = list.begin(); i != list.end(); ++i)
    stream << *i << " ";
  return stream;
}
 
int main(int argc, char *argv[]) {
  SortedList<int> a;
  a.insertSorted(5);
  a.insertSorted(5);
  a.insertSorted(7);
  a.insertSorted(6);
  a.insertSorted(4);
  a.insertSorted(4);
  a.insertSorted(8);
  std::cout << a << std::endl;
  std::cout << (a * 2) << std::endl;
  std::cout << (a * -1) << std::endl;
  std::cout << std::endl;
}