Oersted's questions

这个问题可能被认为是理论上的，因为我不明白为什么在实际代码中会有这样的设计。我有两个带有一些转换运算符的类：

class B;
class A {
   public:
    A() = default;
    A(B const &);
};
class B {
   public:
    B() = default;
    operator A();
};

A::A(B const &) {};
B::operator A() { return A{}; };

int main() {
    [[maybe_unused]] A ad{B{}};   // direct init
    [[maybe_unused]] A ac = B{};  // copy init
}

居住

仅使用 gcc 并且仅使用复制初始化我收到此警告：

警告：选择“B::operator A()”而不是“A::A(const B&)”[-Wconversion]
警告：从“B”到“A”的转换 [-Wconversion]
注意：因为参数的转换顺序更好

由于不熟悉转换规则，我不明白这个警告是否相关？如果不相关，如何才能让它保持沉默（这可能会很痛苦-Werror）？

NB：添加一些跟踪后，我观察到根据编译器和初始化性质的不同行为。转换序列是否在某种程度上依赖于实现？

我听说过 clang-cl 是 clang 的“微软风格”版本，但查看我的配置时，我观察到以下情况：

• 我的 msys2 目录中有一个可执行 clang
• 我的 msys2 目录中有一个可执行文件 clang-cl
• 我的 visual-studio 构建工具目录中有一个可执行 clang
• 我的 visual-studio 构建工具目录中有一个可执行文件 clang-cl

这些版本之间有什么区别？（最终我想看看是否值得在我的编译框架中添加对 clang-cl 的支持）

附加数据：使用 -v 调用每个数据，可以Target: x86_64-w64-windows-gnu得到第一个和Target: x86_64-pc-windows-msvc所有其他数据。

我知道这是S{}.rval一个左值表达式。我想知道将其视为左值表达式背后的理由。

为什么可以访问引用类型左值的非静态成员，即使对象是右值？

struct S {
    int val;
    int& rval = val;
};
int main() {
    S{}.val; // xvalue
    S{}.rval; // lvalue
}

我原本以为“即将消亡的实体”的提法也会是“即将消亡”。所以我想了解这些规则的原理。

在研究值类别的定义时，我尝试了这里提出的一个片段：https://stackoverflow.com/a/16638081/21691539

template <typename T>
struct value_category {
    // Or can be an integral or enum value
    static constexpr auto value = "prvalue";
};

template <typename T>
struct value_category<T&> {
    static constexpr auto value = "lvalue";
};

template <typename T>
struct value_category<T&&> {
    static constexpr auto value = "xvalue";
};

// Double parens for ensuring we inspect an expression,
// not an entity
#define VALUE_CATEGORY(expr) value_category<decltype((expr))>::value

但测试时，我不明白在暗示引用的情况下它的输出。这是我的“测试台”：

#include <iostream>

struct S {
    int val;
    int& rval = val;
};

int f();
int& rf();

// VALUE_CATEGORY as in previous snippet

#define SHOW_CATEGORY(expr) std::cout << #expr << "\t" << VALUE_CATEGORY(expr) << '\n';

int main() {
    SHOW_CATEGORY(f());
    SHOW_CATEGORY(rf());    // expecting prvalue, got lvalue
    SHOW_CATEGORY(S{}.val);
    SHOW_CATEGORY(S{}.rval);    // expecting xvalue, got lvalue
}

居住

和输出

f()      prvalue
rf()     lvalue
S{}.val  xvalue
S{}.rval lvalue

在两种情况下，当表达式与引用相关时，我都会得到意外的结果lvalue。

这段代码正确吗？为什么？如果是错的，那么正确的值类别是什么（以及为什么）？

NB 来自https://timsong-cpp.github.io/cppwp/n4861/basic.lval#4.4我知道这S{}.rval不是一个xvalue，但我想知道其理由。

我不确定我的问题标题是否最合适，如果我得到足够的建议，我会很乐意将其更改为更清晰的内容。

在一个主题不是这里的 C++ 视频中，我看到了这个定义：

#include <vector>

// before ":" V is forward declared, it's enough for std::vector?
// node in a tree
struct V : std::vector<V> {};

（评论是我自己的）。

我的理解是，这种看似循环的声明是可能的，因为在该base-clause位置，struct V已经（向前）声明了。

但这是合法的 C++ 吗？因为我发现类声明对此没有明确说明。

forward declaration由其自身定义 ( struct V;，那么您可以声明 astd::vector<V>)但不能使用完整的类声明语法。

派生类中的写法：

任何类类型（无论是使用类键 class 还是 struct 声明）都可以声明为派生...

（粗体我的）似乎暗示class-key classor class-key struct（没有结束;）已经是完整的声明。是真的吗，标准中是否更明确？

如果是的话，它可能会给我带来有趣设计的机会，所以我想确保它是合法的。

[编辑]一个更明确的例子，没有std::vector

template <typename T>
struct refwrapper {
    T* wrapped;
    virtual ~refwrapper() = default;
};

template <typename T>
struct plainwrapper {
    T wrapped;
    virtual ~plainwrapper() = default;
};

// OK? R is declared at the base-clause
struct R : refwrapper<R> {};

// KO P is incomplete at the base-clause
// struct P: plainwrapper<P>
// {};

居住