20231120学习总结.

public interface Aggregate {
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator iterator();
}


class ConcreteAggregate implements Aggregate {
    private List list = new ArrayList();

    public void add(Object obj) {
        list.add(obj);
    }

    public Iterator iterator() {
        return new ConcreteIterator(list);
    }

    public void remove(Object obj) {
        list.remove(obj);
    }
}



public class ConcreteIterator implements Iterator {
    private List list = new ArrayList();
    private int cursor =0;
    public ConcreteIterator(List list){
        this.list = list;
    }
    public boolean hasNext() {
        if(cursor==list.size()){
            return false;
        }
        return true;
    }

    public boolean isFirst() {
        if(cursor==0) {
            return false;
        }
        return true;
    }


    public Object next() {
        Object obj = null;
        if(this.hasNext()){
            obj = this.list.get(cursor++);
        }
        return obj;
    }

    public void setCursor(int i) {
        cursor=i;
    }

    public Object previous() {
        Object obj=null;
        if(this.isFirst()) {
            obj=this.list.get(--cursor);
        }
        return obj;
    }
}




public interface Iterator {
    public Object next();

    public boolean hasNext();

    public boolean isFirst();

    public Object previous();

    public void setCursor(int i);
}

#include <iostream> 
#include<string>
#include <sstream>
#include <vector> 
using namespace std;

typedef long long int object;

class Iterator
{
public:
    virtual object begin() = 0;
    virtual void   next() = 0;
    virtual object end() = 0;
    virtual object current() = 0;
    virtual bool   IsDone() = 0;
};

class ConcreteAggregate
{
private:
    vector<object> _objects;

public:
    void AddObject(object obj)
    {
        _objects.push_back(obj);
    }

    object& operator[](int index)
    {
        return _objects[index];
    }
    int size()
    {
        return _objects.size();
    }
};

class ConcreteIterator :public Iterator
{
public:
    ConcreteAggregate* agg;
    int _index;
public:
    ConcreteIterator(ConcreteAggregate* agg)
    {
        this->agg = agg;
        _index = 0;
    }
    virtual object begin()
    {
        return (*agg)[0];
    }
    virtual void next()
    {
        _index++;
    }
    virtual void preious()
    {
        _index--;
    }

    virtual object end()
    {
        _index = agg->size();
        return (*agg)[_index - 1];
    }

    virtual object current()
    {
        return (*agg)[_index];
    }

    virtual bool IsDone()
    {
        return (_index == agg->size());
    }
    virtual bool IsFirst()
    {
        return (_index == 0);
    }
};

int main()
{
    ConcreteAggregate* objects = new ConcreteAggregate();
    cout << "信1305班同学:" << endl;
    object a = 202141280001;
    int num = 44;
    while (num > 0) {
        objects->AddObject(a);
        a++;
        num--;
    }


    ConcreteIterator* iter = new ConcreteIterator(objects);
    ConcreteIterator* iter1 = new ConcreteIterator(objects);

    object tmp_begin = iter->begin();
    cout << "从小到大输出:" << endl;
    while (!iter->IsDone())
    {
        cout << iter->current() << endl;
        iter->next();
    }
    cout << endl;

    object tmp_begin1 = iter1->end();
    cout << "从大到小输出:" << endl;
    while (!iter1->IsFirst())
    {
        iter1->preious();
        cout << iter1->current() << endl;
    }
    cout << endl;

    delete objects;
    delete iter;

    system("pause");
    return 0;
}