class CloneNotSupported {
};


class Object {

public:

    virtual ~Object() {}

    virtual Object *clone() const {

        throw CloneNotSupported();

    }

};


class List : public Object {

    friend class Iterator;

    class ListElement {

    public:

        ListElement *next;

        Object *object;

    };

    ListElement *start;

    ListElement *end;


public:

    List() { start = end = 0; }

    ~List() { free(); }

    List(const List &other) { copy(other); }

    List &operator=(const List &other) {

        if (&other != this) {

            free();

            copy(other);

        }

        return *this;

    }


    void pushBack(Object *object) {

        ListElement *le = new ListElement();

        le->next = 0;

        le->object = object;

        if (end)end->next = le;

        end = le;

        if (!start)start = end;

    }

    void pushFront(Object *object) {

        ListElement *le = new ListElement();

        le->object = object;

        le->next = start;

        start = le;

        if (!end)end = start;

    }

protected:

    void free() {

        while (start) {

            ListElement *tmp = start;

            start = start->next;

            delete tmp->object;

            delete tmp;

        }

        start = end = 0;

    }

    void copy(const List &other) {

        start = end = 0;

        for (ListElement *i = other.start; i; i = i->next) {

            pushBack(i->object->clone());

        }

    }

};


class Iterator {

    const List &list;

    List::ListElement *current;

public:

    Iterator(const List &l) : list(l), current(l.start) {}

    Iterator &operator++() {

        if (current)current = current->next;

        return *this;

    }

    Iterator &operator++(int) {

        if (current->next)current = current->next; //?

        return *this;

    }

    operator bool() const { return current != 0; }

    Object *get() const { return current->object; }

};


class Int : public Object {

public:

    int value;

    Int(int v = 0) { value = v; }

    void dump() const { std::cout << value << std::endl; }

    // Object*clone()const{return new Int(*this);}

};


int main(int argc, char *argv[]) {

    // stwórz listę, dodaj elementy, wypisz

    List list;

    for (int i = 0; i < 100; i++) {

        list.pushFront(new Int(2 * i));

        list.pushBack(new Int(2 * i + 1));

    }

    for (Iterator i(list); i; i++) {

        Int *pi = dynamic_cast<Int *>(i.get());

        if (pi)pi->dump();

    }

// utwórz kopię listy i wypisz zawartość

    try {

        List list2(list);

        for (Iterator i(list2); i; i++) {

            Int *pi = dynamic_cast<Int *>(i.get());

            if (pi)pi->dump();

        }

    }

    catch (CloneNotSupported) {

        std::cout << "Clone not supported" << std::endl;

    }


    return 0;

}