Question

我正在编写我的Arrayhandler类，我需要重载operator+和operator++。

通过operator++重载operator+(1)是一个好主意吗？我得到一个无限循环，因为据我所知_current = _pointee + i（其中i是size_t）不会改变_current。为什么？以这种方式添加指针是否正确？

class ArrayHandler
{
private:
     size_t _size;

     Pointee *_pointee; 
     Pointee *_end;
     mutable Pointee *_current; 
  ....
}

我的Ctor：

template <typename Pointee>
    ArrayHandler<Pointee>::ArrayHandler(size_t size):
        _size(size), _pointee(new Pointee[_size]), _end(_pointee+_size), _current(_pointee)
        {};

操作员+：

ArrayHandler<Pointee>& ArrayHandler<Pointee>::operator+(size_t i)
    {
        if (!defined())
            throw MisUse(undefArray, 0);
        if ( _pointee + i > _end || _pointee + i < _pointee)
            throw MisUse(badIndex, i);
        _current = _pointee + i;
        return *this;
    };

Operator ++：

template <typename Pointee>
ArrayHandler<Pointee>& ArrayHandler<Pointee>::operator++()
{
    if (!defined())
        throw MisUse(undefArray, 0);
    if ( stop() )
        throw MisUse(badIndex, 0);
    ++_current;*/
    this->operator+(1);
    return *this;
};

导致无限执行的while循环：

while (!ar3.stop())
    {
        ++ar3;
        ++count;
    }

和stop()方法：

 bool stop() const {return _current ==_end;}

更新：

无限while循环的原因是我通过operator +实现了operator ++，在我的例子中，它确实改变了_current，每次都开始+ 1，所以在第二次迭代之后我的_current保持不变。每次开始+ 1重复RESET。

GUYS !!

Answer 1

你在运算符重载时犯了一个错误：你的operator+修改了它的参数！考虑：

int a = 1;
int b = 2;
int c = a + b;

您是否希望在致电a时修改a + b？当然不是。

您要做的是正确实施operator+=然后提供operator+和（如果您需要）operator++（可能是前缀++ i和后缀i ++版本）在内部使用您的operator+=。以下是后者的一些草图，它们将您的类定义的外部作为自由函数：

template <typename Pointee>
ArrayHandler<Pointee> operator+( ArrayHandler<Pointee> arg, size_t i )
{
    arg += i;
    return arg;
}

template <typename Pointee>
ArrayHandler<Pointee>& operator++( ArrayHandler<Pointee>& arg ) // prefix ++
{
    arg += 1;
    return arg;
}

template <typename Pointee>
ArrayHandler<Pointee> operator++( ArrayHandler<Pointee> arg, int ) // postfix ++
{
    arg += 1;
    return arg;
}

现在对于operator+=，您可以像这样实现它（作为成员函数）：

ArrayHandler<Pointee>& ArrayHandler<Pointee>::operator+=(size_t i)
{
    if (!defined())
        throw MisUse(undefArray, 0);
    if ( _current + i >= _end || _current + i < _pointee)
        throw MisUse(badIndex, i); // this message is now probably misleading
    _current += i;
    return *this;
};

这会使_current元素前进i，这是operator+=的预期语义。如果您只想访问i - 元素，则应考虑编写operator[]。

您可能还会考虑使用辅助库来处理样板代码，例如Boost.Operators，请参阅我的个人资料以获取一些链接。

Answer 2

在您的操作员+中，您不会增加电流，但每次重启都会重启+ i;

_current = _pointee + i;

你可能意味着这样做：

_current = _current + i;

通过重载operator +添加2个指针导致无限循环c ++

2 个答案: