c++ - 对unique_ptr的递增会导致用户定义的运算符出现意外行为!=

Question

这是一个非常具体的问题，需要解释很长一段时间，因此，请尽我所能，请尽量忍受。

我创建了2种用户类型，第一种在第二种内部使用:

struct mySubType {
    int val;
    mySubType () {}
    mySubType ( int _val) : val(_val){}
    bool operator!=(const mySubType& rhs) const { return val != rhs.val; }
};

struct myType {
    mySubType start;
    mySubType stop;
    myType () {}
    myType (mySubType _start, mySubType _stop) : start(_start), stop(_stop) {}
};

在 main()中，我将 vector的 unique_ptr创建为 myType并按如下方式进行填充:

vector<unique_ptr<myType>> v;

for (int i = 0; i < 10; ++i)
    v.push_back( unique_ptr<myType>(new myType( mySubType(i), mySubType(i+1))) );

因此，每个元素的 val和 start的 stop如下:

start:0 stop:1
start:1 stop:2
start:2 stop:3
start:3 stop:4
start:4 stop:5
start:5 stop:6
start:6 stop:7
start:7 stop:8
start:8 stop:9
start:9 stop:10

start应该始终与先前的 stop相同(在此示例中就是这种情况)。为了对此进行检查，我尝试了以下操作:

for (auto it = v.begin(); it != --v.end(); )
{
    if ((*it)->stop != (*(++it))->start)
        cout << "1";
}

令我惊讶的是，输出是: 111111111，当它们全部相等时都不同。

我尝试了其他一些方法来尝试了解错误的来源。我将循环的内部替换为

mySubType stop = (*it)->stop;
mySubType next_start = (*(++it))->start;
if (stop != next_start)
    cout << "2";

然后

if ((*it)->stop.val != (*(++it))->start.val)
    cout << "3";

那些都不打印任何东西(所有测试均被平等地解决)。

这仅在使用 unique_ptr时发生( vector<myType>没有相同的问题)。我也尝试使用后增量，但得到的结果完全相同。

有谁知道为什么会这样吗？

我知道有很多方法可以解决此问题(例如上述2)。我感兴趣的是为什么会发生这种行为。

Answer 1

if语句中的表达式

    if ((*it)->stop != (*(++it))->start)

具有未定义的行为。

看来您的意思是以下循环

#include <iterator>

// ...

for (auto it = v.begin(); it != v.end(); ++it )
{
    auto next = std::next( it );
    if ( next != v.end() && (*it)->stop != (*( next ))->start)
        std::cout << "1";
}  

可以使用标准算法 std::adjacent_find代替for循环。例如

#include <iostream>
#include <memory>
#include <vector>
#include <iterator>
#include <algorithm>

struct mySubType {
    int val;
    mySubType () {}
    mySubType ( int _val) : val(_val){}
    bool operator!=(const mySubType& rhs) const { return val != rhs.val; }
};

struct myType {
    mySubType start;
    mySubType stop;
    myType () {}
    myType (mySubType _start, mySubType _stop) : start(_start), stop(_stop) {}
};

int main()
{
    std::vector<std::unique_ptr<myType>> v;

    for (int i = 0; i < 10; ++i)
        v.push_back( std::unique_ptr<myType>(new myType( mySubType(i), mySubType(i+1))) );

    auto it = std::adjacent_find( std::begin( v ), std::end( v ),
                                 []( const auto &left, const auto &right )
                                 {
                                     return left->stop != right->start;
                                 } );

    if ( it != std::end( v ) ) std::cout << "there is an error\n";
    else std::cout << "The sequence is correct\n";
}

程序输出为

The sequence is correct