#include <iostream>
#include <iterator>
#include <vector>

using namespace std;

template <typename T>
class MyIterator;

template <typename T>
class Sequence;


template <typename T>
class Drob {
public:
    T chisl;
    T znam;
    friend class MyIterator<T>;
    friend class Sequence<T>;

    Drob(T chisl, T znam) : chisl(chisl), znam(znam) {}

    Drob<T> operator +(Drob<T> &obj) {
        T a = this->chisl + obj.chisl;
        T b = this->znam + obj.znam;
        Drob<T> help (a,b);
        return help;
    }

    bool operator == (const Drob<T> &obj) {
        return this->chisl == obj.chisl && this->znam == obj.znam;
    }

    bool operator != (const Drob<T> &obj) {
        return this->chisl != obj.chisl || this->znam != obj.znam;
    }

    friend ostream& operator<< (ostream& os, Drob n) {
        os << n.chisl << "/" << n.znam;
        return os;
    }

};

template <typename T>
class Sequence {
private:
    vector<Drob<T>> seq;
public:
    Sequence(Drob<T> &a) {
        seq.push_back(a);
    }

    void addDrob(Drob<T> &a) {
        seq.push_back(a);
    }

    MyIterator<T> begin() {
        return seq[0];
    }

    MyIterator<T> end() {
        return seq[seq.size() - 1];
    }

};


template <typename T>
class MyIterator:
        public iterator<
                forward_iterator_tag,
                int,
                ptrdiff_t,
                Drob<T>*,
                Drob<T>
        >
{
private:
    vector<Drob<T>> vec;
    int count;
public:
    MyIterator<T> () {
        auto vec = new vector<Drob<T>>;
        count = 0;
    }

    MyIterator<T> (Drob<T> &drob) {
        vec.push_back(drob);
        count = 0;
    }

    bool operator == (const MyIterator<T> &obj) {
        if (this->vec.size() != obj.vec.size()) return false;
        for (int i = 0; i < this->vec.size(); i++) {
            if (this->vec[i] != obj.vec[i]) return false;
        }
        return true;
    }

    bool operator != (const MyIterator<T> &obj) {
        return !(*this == obj);
    }

    Drob<T> operator * () {
        if (vec.size() == 0) {
            Drob<T> nulld(0,1);
            return nulld;
        }
        if (count != vec.size()) {
            return vec[count]+vec[count+1];
        }
        return vec[count];
    }

    Drob<T>& operator = (Drob<T> &f) {
        if ((vec.size() <= 1) || (count == vec.size())) {
            throw "Error";
        }
        if (count != vec.size()) {
            vec[count].chisl = f.chisl*vec[count+1].znam - f.znam*vec[count+1].chisl;
            vec[count].znam = f.znam * vec[count+1].znam;
            return vec[count];
        }
    }

    MyIterator<T> operator ++() {
        count++;
        return *this;
    }

    MyIterator<T> operator ++(int) {
        count++;
        return *this;
    }

    Drob<T> operator [] (int a) {
        return vec[a];
    }
};


int main() {

    Drob<int> drob(1,2);
    Drob<int> drob1(2,3);
    Drob<int> drob2(4,6);
    Drob<int> drob3(1,8);
    Drob<int> drob4(1,1);

    cout << drob << endl;
    cout << endl;

    Sequence<int> seq(drob);
    seq.addDrob(drob1);seq.addDrob(drob2);seq.addDrob(drob3);seq.addDrob(drob4);

    for (auto it = seq.begin(); it != seq.end(); it++) {
        cout << *it << endl;
    }

    return 0;
}