Связанные составные назначения с секвенированием С ++ 17 все еще не определены?

Чтобы лучше понять, что происходит на самом деле, давайте попробуем имитировать то же самое с нашим собственным шрифтом и добавим распечатки:

class Number {
    int num = 0;
public:
    Number(int n): num(n) {}
    Number operator+=(int i) {
        std::cout << "+=(int) for *this = " << num
                  << " and int = " << i << std::endl;
        num += i;
        return *this;
    }
    Number& operator+=(Number n) {
        std::cout << "+=(Number) for *this = " << num
                  << " and Number = " << n << std::endl;
        num += n.num;
        return *this;
    }
    operator int() const {
        return num;
    }
};

Затем, когда мы бежим:

Number a {5};
(a += 1) += a;
std::cout << "result: " << a << std::endl;

Мы получаем разные результаты с gcc и clang (и без всякого предупреждения!).

gcc:

+=(int) for *this = 5 and int = 1
+=(Number) for *this = 6 and Number = 6
result: 12

лязг:

+=(int) for *this = 5 and int = 1
+=(Number) for *this = 6 and Number = 5
result: 11

Это тот же результат, что и для целых чисел в вопросе. Хотя это не та же самая история: встроенное присваивание имеет свои собственные правила последовательности, в отличие от перегруженного оператор, который является вызовом функции, все же интересное сходство.

Кажется, что хотя gcc сохраняет правую сторону в качестве ссылки и превращает ее в значение при вызове + =, clang, с другой стороны, превращает правую сторону в значение в первую очередь.

Следующим шагом будет добавление конструктора копирования в наш класс Number, чтобы точно следовать, когда ссылка превращается в значение. Выполнение этого приводит к вызову конструктора копирования в качестве первой операции, как clang и gcc, и результат будет одинаковым для обоих: 11.

Похоже, что gcc задерживает ссылку на преобразование значения (как во встроенном назначении, так и в случае определенного пользователем типа без определяемого пользователем конструктора копирования). Является ли это последовательным с C ++ 17 определенная последовательность? Мне это кажется ошибкой gcc, по крайней мере, для встроенного присваивания, как в вопросе, поскольку кажется, что преобразование из ссылки в значение является частью вычисления значения , который должен быть упорядочен перед назначением.

Что касается странного поведения clang, о котором сообщалось в предыдущей версии исходного сообщения - возврат разных результатов в assert и при печати:

constexpr int foo() {
    int res = 0;
    (res = 5) |= (res *= 2);
    return res;
}

int main() {
    std::cout << foo() << std::endl; // prints 5
    assert(foo() == 5); // fails in clang 11.0 - constexpr foo() is 10
                        // fixed in clang 11.x - correct value is 5
}

Это связано с ошибкой в ​​clang. Ошибка утверждения неверна и связана с неправильным порядком оценки этого выражения в clang во время постоянной оценки во время компиляции. Значение должно быть 5. Эта ошибка уже исправлена ​​ в магистрали clang.