Question

简而言之：在虚拟方法具有基类（抽象）作为返回类型的派生类中，如何覆盖虚函数？

从逻辑上讲，我认为协变量足以满足此要求，但这只是给我一个错误。

错误是MSVC C2555 'class1::function1': overriding virtual function return type differs and is not covariant from 'class2::function2.'

代码如下：

在iterator.h中：

template <typename T>
class base_iterator {
public:
    using T_ptr = T*;
    using T_ref = T&;

public:

    virtual T_ref operator*() = 0;
    virtual T_ptr operator->() = 0;
    
    // ------ THESE GIVE ME ERRORS ------------
    virtual base_iterator& operator++() = 0;
    virtual base_iterator operator++(int) = 0;
 
    virtual base_iterator& operator--() = 0;
    virtual base_iterator operator--(int) = 0;
    // -----------------------------------------
    virtual bool operator==(base_iterator&) = 0;
    virtual bool operator!=(base_iterator&) = 0;
};

vector.h中的vector_iterator：

#include "iterator.h"
// ... other stuff
template <typename vector_type>
class vector_iterator : public base_iterator<typename vector_type::value_type> {
public:
    using T_ptr = typename vector_type::T_ptr;
    using T_ref = typename vector_type::T_ref;

private:
    size_t m_index;
    T_ptr m_array_ptr;

public:
    vector_iterator() : m_index(0), m_array_ptr(nullptr) noexcept {};
    vector_iterator(T_ptr array_ptr, size_t index) {
        m_index = index;
        m_array_ptr = array_ptr;
    }

    T_ref operator*() {
        return *operator->();
    }

    T_ptr operator->() {
        return m_array_ptr+index;
    }

    vector_iterator& operator++() {
        ++m_index;
        return *this;
    }

    vector_iterator operator++(int) {
        vector_iterator temp = *this;
        ++m_index;
        return temp;
    }

    vector_iterator& operator--() {
        --m_index;
        return *this;
    }
    vector_iterator operator--(int) {
        vector_iterator temp = *this;
        --m_index;
        return temp;
    }

    bool operator==(vector_iterator& other) {
        return m_array_ptr == other.m_array_ptr && m_index == other.m_index;
    }
    bool operator!=(vector_iterator& other) {
        return !operator==(other);
    }
};

在这里我也不明白的是为什么它接受operator==和operator!=的替代，而不接受增量和减量方法。

可能的解决方案编辑 正如评论中指出的那样，我们不能有这样的返回类型，因为它会破坏对协变量的要求。在我的情况下，一种有效的解决方案是将派生类添加为基类的模板参数，并将其用作返回类型。像这样：

template <typename T, typename iterator_type>
class base_iterator {
public:
    using T_ptr = T*;
    using T_ref = T&;

public:

    virtual T_ref operator*() = 0;
    virtual T_ptr operator->() = 0;

    virtual iterator_type& operator++() = 0;
    virtual iterator_type operator++(int) = 0;

    virtual iterator_type& operator--() = 0;
    virtual iterator_type operator--(int) = 0;

    virtual bool operator==(iterator_type&) = 0;
    virtual bool operator!=(iterator_type&) = 0;
};

使用抽象类返回类型覆盖虚拟方法

0 个答案: