标签: c++20

根据cppreference，std::type_info::operator!=被C ++ 20删除，但是std::type_info::operator==显然仍然存在。

背后的原因是什么？我可能会同意比较不平等是没有意义的，但是然后比较相等也同样是没有意义的，不是吗？

相比之下，必须编写if(!(id1 == id2))并不会使任何代码更清晰if(id1 != id2)，相反，相反……

考虑这个代码：

#include <iostream>
template<typename A>
struct S{
    S(const A& a){
        std::cout << "L\n";
    }
    S(A&& a){
        std::cout << "R\n";
    }
};
S<int> f1(){
    int a = 1;
    return {a};
}
S<int> f2(){
    int a = 1;
    return a;
}
S<int> f3(){
    int a = 1;
    return {std::move(a)};
}
int main()
{
    f1();
    f2();
    f3();
}

输出是

左
右
右

您可能知道 C++ 在返回值中隐式移动（在 f2 中）。当我们在初始值设定项列表中手动执行时，它可以工作（f3），但它不会在 f1 中由 C++ 自动完成。

这是否有充分的理由为什么这不起作用，或者只是被认为不够重要而无法由标准指定的极端情况？

PS 我知道编译器可以（有时必须）执行 RVO，但我不明白这如何解释输出。

void foo(const auto& collection)
{
    *collection.begin() = 104;
}

int main()
{
    std::vector<int> ints {1, 2, 3, 4, 5};
    foo(ints); // Error, as it should be
    foo(ints | std::views::all); // Compiles and modifies the vector. Why?
    return 0;
}

如果函数的参数是类型，为什么左值引用的常量性会被完全忽略std::view？

编辑：
如果，正如您在注释中所写，const 视图引用与此上下文中的 const 指针类似，那么如果同一函数采用从右值对象构造的视图作为参数，为什么代码无法编译？

std::vector<int> getVec()
{
    return std::vector{1, 2, 3, 4, 5};
}

void foo(const auto& collection)
{
    *collection.begin() = 104; // Error: assignment of read-only location
}

int main()
{
    foo(getVec() | std::views::all); // Nope! …

如何使用概念if constexpr？

给出下面的例子,if constexpr如果T满足要求,则返回1 将给予integral什么？

template<typename T>
concept integral = std::is_integral_v<T>;

struct X{};

template<typename T>
constexpr auto a () {
    if constexpr (/* T is integral */) {
        return 1;
    } 
    else {
        return 0;
    }
}

int main () {
    return a<X>();
}

考虑以下代码：

#include <cctype>
#include <functional>
#include <iostream>

int main()
{
    std::invoke(std::boolalpha, std::cout); // #1

    using ctype_func = int(*)(int);
    char c = std::invoke(static_cast<ctype_func>(std::tolower), 'A'); // #2
    std::cout << c << "\n";
}

在此，对的两个调用std::invoke已标记为将来参考。预期的输出是：

a

在C ++ 20中可以保证预期的输出吗？

（注意：有两个函数tolower，一个称为in <cctype>，另一个称为in <locale>。引入了显式强制转换以选择所需的重载。）

我有这段代码，输出如下：

链接到以下示例 https://godbolt.org/z/z8Pn9GsTv

template <typename T>
struct A1 {
    A1() {
        std::cout << "construction of a1" << std::endl;
    }

    ~A1() {
        std::cout << "destruction of a1" << std::endl;
    }
    ~A1() requires (std::is_same_v<T,int>) {
        std::cout << "it is an int" << std::endl;
    }
};

int main() {
    A1 <int>a;
    
    return 0;
}

输出：

construction of a1
destruction of a1

但交换析构函数的位置会给出其他结果：

代码链接 https://godbolt.org/z/vxj7dPqaj

template <typename T>
struct A1 {
    A1() {
        std::cout << "construction of a1" << std::endl;
    }

    ~A1() requires (std::is_same_v<T,int>) …

考虑头文件：

class T
{
private:
  int const ID;

public:
  explicit T(int const ID_) noexcept : ID(ID_) {}

  int GetID() const noexcept { return ID; }
};

或者，或者：

class T
{
private:
  int const ID;

public:
  explicit T(int const ID_) noexcept;

  int GetID() const noexcept;
};

inline T::T(int const ID_) noexcept : ID(ID_) {}

inline int T::GetID() const noexcept { return ID; }

在预模块世界中，这些标头可能会以文本形式包含在多个 TU 中，而不会违反 ODR。此外，由于涉及的成员函数相对较小，编译器可能会“内联”（在使用时避免函数调用）这些函数，甚至优化掉一些实例T。

在最近关于 C++20 完成会议的报告中，我可以阅读以下声明：

我们澄清了inline模块接口中的含义：意图是未明确声明的函数体不是inline模块 ABI 的一部分，即使这些函数体出现在模块接口中。为了让模块作者更好地控制他们的 …