Fedor's questions

可以通过复制前一个活跃成员的值来更改联合中的活跃成员吗std::construct_at？

这个最小的例子

#include <memory>

constexpr int f() {
    union U {
        char x{0};
        int y;
    } u;
    std::construct_at(&u.y, u.x);
    return u.y;
}

static_assert( f() == 0 );

被 GCC 和 MSVC 接受，但 Clang 拒绝它并出现错误：

/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__memory/construct_at.h:41:50: 
note: read of member 'x' of union with active member 'y' is not allowed in a constant expression
   41 |   return ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...);

在线演示：https://gcc.godbolt.org/z/xrj57jroj

这里哪种实现是正确的？

constinit从 C++20 开始可以使用说明符声明结构化绑定吗？

例如

struct A { int i, j; };

constinit auto [x, y] = A{ 0, 1 };

编译器在这方面有些分歧。MSVC 抱怨：

错误 C3694：结构化绑定声明不能包含除“static”、“thread_local”、“auto”和 cv-qualifiers 之外的其他说明符

Clang 紧随其后

错误：分解声明不能声明为“constinit”

但 GCC 只接受该示例。在线演示：https://gcc.godbolt.org/z/jaY7ncsPP

这里哪种实现是正确的？

要在派生类模板中使用依赖基类中的名称（例如B<T>），必须向编译器添加一个前缀突出显示的依赖名称（B<T>::）。为了避免多次执行此操作，可以使用 using 声明。

下面的代码带有这样的使用声明：

template <class T>
struct A {
    constexpr static int x = 0;
};

template <class T>
struct B : A<T> {
    // ok everywhere
    constexpr static int y = B<T>::x;

    // ok in MSVC
    using B<T>::x;
    constexpr static int z = x;
};

在 MSVC 编译器中运行良好，但其他人不喜欢它。Clang 尤其抱怨

错误：'B' 中没有名为 'x' 的成员

y = B<T>::x但是 Clang 在上面一行中没有看到任何错误。在线演示： https ://gcc.godbolt.org/z/PvKW753M8

这里哪种实现是正确的以及为什么？

我的程序在 Visual Studio 的 C++20 模式下表现符合预期，但我需要让它在 C++17 模式下运行，在该模式下程序会改变其输出。

最小化后，它看起来如下：

template <typename T>
int f() { return g(T{}); }

namespace {
    struct A{
        friend int g(const A &) { return 1; }
    };
}

template <typename T>
int g(T&&) { return 2; }

int main() { return f<A>(); }

在 C++20 模式下输出为main()，1而在 C++17 模式下输出为2。在线演示： https: //gcc.godbolt.org/z/h8b8qoGGj

我想知道 C++20 的哪个新特性（C++17 中没有）导致了结果的差异。

C++23 中类的比较运算符是否可以具有与类类型不同的类型的显式对象参数？

例如

struct A {
    int i;
    constexpr bool operator==(this int x, int y) { return x == y; }
    constexpr operator int() const { return i; }
};

现在比较不平等

static_assert( A{0} != A{1} );

被 GCC 和 Clang 接受，但 MSVC 抱怨：

error C2803: 'operator ==' must have at least one formal parameter of class type
error C2333: 'A::operator ==': error in function declaration; skipping function body

平等的比较

static_assert( A{2} == A{2} );

仅被 GCC 接受，而 Clang 已经不喜欢它了：

error: use of overloaded operator '==' is ambiguous (with operand types 'A' and 'A')
   11 | static_assert( A{2} == A{2} );
note: candidate function
    3 |     constexpr bool operator==(this int x, int y) { return x == y; }
note: built-in candidate operator==(int, int)

在线演示：https://gcc.godbolt.org/z/dnKc1fhcT

这里哪个编译器是正确的？

下面的程序已尽可能地缩减，以显示 Visual Studio C++ 编译器遇到的问题。

f是接受输入谓词对象的某个算法函数P p，它具有用户定义的复制构造函数，用于记住源对象上的指针。在该构造函数中，检查源对象和复制对象是否确实不同，if (s == this) throw 0;但在operator ()同一次检查中返回相反的结果：

struct P {
    const P * s = nullptr;
    constexpr P() {}
    constexpr P(const P & p) : s(&p) {
        if (s == this) throw 0; // never happens
    }
    constexpr bool operator()() const {
        return s != this; // shall be always true?
    }
};

constexpr bool f(P p) {
    return p.s ? p() : f(p);
}

int main() {
    static_assert( f(P{}) ); // fails in MSVC, where static_assert( f(P{}) == false );
}

在线演示：https://gcc.godbolt.org/z/nqYoshExj

如何解释同样的检查在对象的构造函数中通过，但在其方法中却失败了？

下面是一个递归 lambda 表达式，它可以在运行时和常量求值期间计算斐波那契数列的值：

auto fib = [](this auto && f, auto && p) {
    if ( p < 3 ) return 1;
    decltype(+p) v{};
    v = p - 2;
    return f(v+1) + f(v);
};

// ok everywhere
static_assert( fib(1) == 1 );
static_assert( fib(2) == 1 );
static_assert( fib(3) == 2 );
static_assert( fib(4) == 3 );
static_assert( fib(5) == 5 );
static_assert( fib(6) == 8 );
static_assert( fib(7) == 13 );
static_assert( 20 <= fib(8) && fib(8) <= 21 );
// fails in MSVC
static_assert( fib(8) == 21 );

据我所知，它在 GCC 和 Clang 中运行良好，但在 Visual Studio 中，它只适用于前 7 个元素，并且fib(8)计算不准确，导致静态断言失败。在线演示：https://gcc.godbolt.org/z/dMM6f16do

如果程序正确，为什么它对于小数表现良好，而对于大数却不行（例如整数溢出，递归调用太多）？

在以下 C++23 程序中

struct A {
    A() {}
    A(A&&) = default;
    void f(this A) {}
    void operator() (this A) {}
};

int main() {
    A{}.f(); // ok
    A{}();   // Clang error
}

struct A是可移动的，并且其成员函数f()和operator()具有显式的对象参数(this A)。

在 Clang 中，编译器令人惊讶A{}.f()地工作正常，但A{}()失败并出现错误：

<source>:10:5: error: call to implicitly-deleted copy constructor of 'A'
<source>:3:5: note: copy constructor is implicitly deleted because 'A' has a user-declared move constructor

在线演示：https://gcc.godbolt.org/z/hbfzMvE9f

f()从语言的角度来看，函数之间是否存在一些差异operator()，可以解释编译器对它们的可观察处理？

如果调用临时对象的显式对象成员函数，是否必须在显式对象参数中省略临时对象的移动？

考虑以下示例，其中struct A移动构造函数已被删除并且f(this A)为临时对象调用A：

struct A {
    A() {}
    A(A&&) = delete;
    void f(this A) {}
};

int main() {
    A{}.f();
}

该程序在 GCC 中被接受，但是 Clang 和 MSVC 都拒绝它：

调用已删除的“A”构造函数

错误 C2280：'A::A(A &&)'：尝试引用已删除的函数

在线演示：https://gcc.godbolt.org/z/rbv14cnz5

这里哪个编译器是正确的？

从 C++20 开始，编译器可以为类生成默认比较运算符，包括作为友元非成员函数，请参阅cppreference.com中的 (2) 。

我遇到了在 MSVC 中工作的代码，它为函数内的本地类执行此操作：

void foo() {
    struct A;
    bool operator ==(const A&, const A&);
    struct A { 
        friend bool operator ==(const A&, const A&) = default;
    };
}

不幸的是，它在 Clang 或 GCC 中不起作用，它们抱怨：

error: cannot define friend function 'operator==' in a local class definition

在线演示： https: //godbolt.org/z/Ts1fer1d1

有一种方法可以让代码被GCC接受：

void foo() {
    struct A;
    bool operator ==(const A&, const A&);
    struct A { 
        friend bool operator ==(const A&, const A&);
    };
    bool operator ==(const A&, const A&) = default;
}

现在只打印一些模糊的警告：

warning: declaration of 'bool operator==(const foo()::A&, const foo()::A&)' has 'extern' and is initialized

但另外两个编译器不喜欢，在线演示：https://godbolt.org/z/he1zjj46G

只要编译器存在分歧，上面两个示例中哪一个是正确的？