返回对类的引用

Question

我有这样的代码:

#include <stdio.h>

class AbstractIterator{
    virtual void do_something() = 0;
};

class AbstractList{};

class Iterator : public AbstractIterator{
public:
   Iterator(const AbstractList & list) : list(list){};

   virtual void do_something() override{
       printf("hello\n");
   };

   const AbstractList & list;
};

class List : public AbstractList{
public:
  Iterator getIterator(){
     return Iterator(*this);
  }
};

int main(int argc, char** argv){
    List list;
    Iterator it = list.getIterator();

    it.do_something();

    return 0;
}

这工作,但我想"推"getIterator()方法到AbstractList类.为此,需要能够执行以下操作:

/* non const */
AbstractIterator &it = list.getIterator();
it.do_something();

没有动态分配,这可能以某种方式完成吗？

Answer 1

也许这个

class AbstractIterator{
public:
    virtual void do_something() = 0;
};

class AbstractList
{
public:
    virtual AbstractIterator* getIterator() = 0;
};

class Iterator : public AbstractIterator{
public:
    Iterator(AbstractList& list) : list(list){}

    const Iterator operator=( const Iterator& other )
    {
        list = other.list;
        return *this;
    }

    virtual void do_something() override{
        printf("hello\n");
    }

    AbstractList& list;
};

class List : public AbstractList{
    Iterator iterator;
public:
    List() : iterator( *this ) {}
    AbstractIterator* getIterator() override
    {
        iterator = Iterator( *this );
        return &iterator;
    }
};

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

    List list;

    AbstractIterator* it = list.getIterator();
    it->do_something();

    return 0;
}

BTW.重要的是要记住迭代器的有效性(修改列表,虚拟析构函数等),这个例子非常基本:)

这写得非常快

• 迭代器的失效函数应该是私有的,它可以完成,但它会使一点点源复杂化
• 注意iterface方法是通过模板方法调用的 - 好习惯

资源:

class AbstractList;

class AbstractIterator{
public:
    AbstractIterator( AbstractList* list ) : list( list ), valid( true ) {}
    virtual bool moveNext() = 0;
    void doSomething()
    {
        if( isValid() )
        {
            do_something();
        }
    }

    bool isValid() { return valid && 0 != list; }
    void invalidate()
    {
        valid = false;
    }
protected:
    AbstractList* list;
private:
    virtual void do_something() = 0;
    bool valid;
};

class AbstractList
{
public:
    virtual ~AbstractList()
    {
        for( std::shared_ptr< AbstractIterator > it : iterators )
        {
            it->invalidate();
        }
        iterators.clear();
    }
    std::shared_ptr< AbstractIterator > iterator()
    {
        std::shared_ptr< AbstractIterator > it = getIterator();
        iterators.push_back( it );
        return it;
    }
private:
    virtual std::shared_ptr< AbstractIterator > getIterator() = 0;

private:
    std::list< std::shared_ptr< AbstractIterator > > iterators;
};

class Iterator : public AbstractIterator{
public:
    Iterator( AbstractList* list ) : AbstractIterator(list){}
    ~Iterator() {printf("Iterator cleaned\n");}

    virtual bool moveNext() override
    {
        if( !isValid() )
        {
            return false;
        }

        //do ...... iterate ... whatever

        return true;
    }

    virtual void do_something() override
    {
        printf("hello\n");
    }

};

class List : public AbstractList{
public:
    ~List()
    {
        printf("List cleaned\n");
    }

    List() {}

private:
    std::shared_ptr< AbstractIterator > getIterator() override
    {
        std::shared_ptr< AbstractIterator > iterator( new Iterator( this ) );
        return iterator;
    }
};

int main(int argc, char *argv[])
{
    List* list = new List();

    std::shared_ptr< AbstractIterator > it = list->iterator();
    it->doSomething();
    if( it->isValid() )
    {
        std::cout << "It valid" << std::endl;
    }
    delete list;
    if( !it->isValid() )
    {
        std::cout << "It !valid" << std::endl;
    }

    return 0;
}

这更应该是什么样子