Question

我目前正在创建一组迭代器，这些迭代器的实现细节会有所不同，但会在相同的算法中使用。因此，它们必须具有相同的接口。为此，我创建了一个抽象迭代器类，并在所有其他迭代器中继承此类。

这可以让您了解我的代码是什么样的：

class INodeIterator
{
public:
    virtual ~INodeIterator() {};
    virtual bool operator!= (const INodeIterator& other) =0;
    virtual bool operator== (const INodeIterator& other) =0;
    virtual INodeIterator& operator++ () =0;
    virtual INodeIterator& operator++ (int i) =0;
    virtual Node& operator* () =0;
};

class NodeIterator : public INodeIterator
{
public:
    /* snip */
    NodeIterator& operator++ (int i)
    {
        NodeIterator tmp(*this);
        ++(*this);
        return(tmp);
    }
};

现在我面临与C++ post-increment operator overload in iterators (compiling with -Wall -Werror)中相同的问题：我的operator ++（int）实现抛出一个警告（gcc 4.8.0），返回对临时的引用。链接问题中的解决方案是仅返回对象而不是引用。

然而，这对我不起作用。如果我更改接口和派生类以返回对象而不是引用，则会出现以下错误（摘录，删除其他文件名等）：

INodeIterator.h:16:27: error: invalid abstract return type for member function ‘virtual INodeIterator INodeIterator::operator++(int)’
     virtual INodeIterator operator++ (int i) =0;
                           ^

NodeIterator.h:33:22: error: invalid covariant return type for ‘virtual NodeIterator NodeIterator::operator++(int)’
         NodeIterator operator++ (int i);
                      ^

INodeIterator.h:16:27: error:   overriding ‘virtual INodeIterator INodeIterator::operator++(int)’
     virtual INodeIterator operator++ (int i) =0;
                           ^

将派生类的返回类型更改为对象但未在抽象类上更改预期会返回“指定的冲突返回类型”错误。

我该如何做到这一点？

Answer 1

尝试更改设计：让NodeIterator将INodeIterator作为指针。 NoteIterator的所有方法都将委托给持有的INodeIterator对象。在这种情况下，您可以使用正确的签名：

struct IteratorInterface {
    virtual ~IteratorInterface() {}
    virtual std::unique_ptr<IteratorInterface> clone() const = 0;
    virtual void next() = 0;
};

class Iterator {
    std::unique_ptr<IteratorInterface> impl;
public:
    Iterator(std::unique_ptr<IteratorInterface> r) : impl(std::move(r)) {}
    Iterator(const Iterator &r) : impl(r.impl->clone()) {}
    Iterator& operator++() {
        impl->next();
        return *this;
    }
    Iterator operator++(int ) {
        Iterator tmp(*this);
        impl->next();
        return tmp;
    }
    void swap(Iterator &other) {
        other.impl.swap(impl);
    }
};

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    struct IteratorInterfaceImpl : IteratorInterface {
        int i;
        IteratorInterfaceImpl() : i(0) {}
        virtual std::unique_ptr<IteratorInterface> clone() const {
            return std::unique_ptr<IteratorInterface>(new IteratorInterfaceImpl(*this));
        }
        virtual void next() {
            i += 1;
        }
    };
    Iterator tmp(std::unique_ptr<IteratorInterface>(new IteratorInterfaceImpl()));
    tmp++;
    ++tmp;

    return 0;
}

Answer 2

我能想到的唯一理智的方法是从void返回INodeIterator::operator++(int) - 即没有。

您不能从后增量运算符返回引用，因为您必须创建一个返回引用的实际对象（存储前一个值）。这个对象要么是动态分配的，要么必须被销毁（必须在返回的引用上显式调用delete），或者它是operator++(int)的“局部变量”并在返回之前被销毁：

virtual NodeIterator& operator++(int)
{
    NodeIterator prev_value(*this);
    ++(*this);
    return prev_value; // dangling/invalid reference, `prev_value` is destroyed
}

virtual NodeIterator& operator++(int)
{
    NodeIterator* pPrev_value = new NodeIterator(*this);
    ++(*this);
    return *pPrev_value; // have to explicitly call delete on the returned ref...
}

您也无法从INodeIterator返回INodeIterator::operator++(int)类型的对象，因为它是一个抽象类。

Answer 3

您收到错误的原因

INodeIterator.h:16:27: error: invalid abstract return type for member function ‘virtual INodeIterator INodeIterator::operator++(int)’
     virtual INodeIterator operator++ (int i) =0;

是因为您的纯虚函数返回一个抽象类对象。

一种解决方案是使用new运算符并返回在堆中创建的对象，这是安全的。

 virtual INodeIterator& operator++ (int i) =0;

    NodeIterator& operator++ (int i)
    {
        NodeIterator* tmp = new NodeIterator (*this);
        ++(*this);
        return(*tmp);
    }

Answer 4

您的原型不正确。它应该是

NodeIterator operator++ (int i)

也就是说，删除引用返回，否则你将返回对超出范围的引用的引用（你的tmp）不是一个好主意！

编译器在让你知道这一点方面非常有帮助！

我不知道你想听到什么。

operator ++（int）重载与抽象基类和Wall

4 个答案: