小编Ami*_*rsh的帖子

通常我更喜欢unique_ptr从工厂回来。unique_ptr最近我遇到了为继承的类返回 a 的问题enable_shared_from_this。此类的用户可能会意外地调用shared_from_this()，尽管它不属于任何shared_ptr，这会导致std::bad_weak_ptr异常（或在 C++17 之前未定义的行为，通常作为异常实现）。

代码的简单版本：

class Foo: public enable_shared_from_this<Foo> {
    string name;
    Foo(const string& _name) : name(_name) {}
public:
    static unique_ptr<Foo> create(const string& name) {
        return std::unique_ptr<Foo>(new Foo(name));
    }
    shared_ptr<Foo> get_shared() {return shared_from_this();}
    void doIt()const {cout << "Foo::doIt() <" << name << '>' << endl;}
    virtual ~Foo() {cout << "~Foo() <" << name << '>' << endl;}
};

int main() {
    // ok behavior
    auto pb1 = …

给出以下代码:

class A;

struct B {
    static void doIt(A* pa);
};

struct C {
    static void doIt(A* pa);
};

class A {
    int i = 9;
    // below works but requires a line per each type
    friend void B::doIt(A* pa);
    friend void C::doIt(A* pa);

    // the below however doesn't work
    // template<typename T>
    // friend void T::doIt(A* pa);
      // (gcc error: member 'void T::doIt(A*)' declared as friend before type 'T' defined)
      // (clang just ignores the above and the error …

很明显,std :: initializer_list不是一个实际的容器.该标准明确定义了使用std :: initializer_list可以做什么和不能做什么.

但是为什么语言会保留做愚蠢事情的选择,比如将一个临时的std :: initializer_list分配给另一个 - 当它可以在std :: initializer_list的移动赋值运算符上用= delete时很容易被阻塞？

这是一个破解的代码示例,它编译:

void foo(std::initializer_list<int> v) {
    std::cout << *v.begin() << std::endl;
}

int main() {
    int a = 1, b = 2, c = 3;
    auto val = {a, b, c}; // ok, extending the lifetime of {a, b, c}
    foo(val); // prints ok
    int i = 7;
    val = {i}; // doesn't handle well assignment of temporary
    foo(val); // prints garbage...
}

输出,由@nwp提供: …

以下代码与clang（x86_64-pc-linux-gnu 上的版本 5.0.0-3~16.04.1）和gcc (9.2.0) 的行为不同。

void operator delete(void* ptr) noexcept {
    std::cout << "overloaded delete" << std::endl;
    free(ptr);
}

int main() {
    int* pint = new int;
    delete pint; // clang doesn't go through overloaded operator delete, gcc does
}

gcc通过重载，operator delete而clang避免它更喜欢global delete.

（当添加重载时，operator new两个编译器都同意并通过两个重载版本）。

代码：http : //coliru.stacked-crooked.com/a/0903bd53a8c04a9b

C++20 增加了可寻址函数 规则16.5.4.2.1 [namespace.std]/6 : -- 重点是我的 --

让F表示标准库函数（[global.functions]）、标准库静态成员函数或标准库函数模板的实例化。除非F被指定为 可寻址函数，否则C++ 程序的行为是未指定的（可能格式错误），如果它显式或隐式地尝试形成指向 F 的指针。 [注意：形成此类指针的可能方法包括应用一元 &运算符 ([expr.unary.op])、addressof ([specialized.addressof]) 或函数到指针的标准转换 ([conv.func])。— 尾注 ] 此外，如果 C++ 程序试图形成对 F 的引用，或者如果它试图形成一个指向成员的指针来指定标准库非静态成员函数（[member .functions]) 或标准库成员函数模板的实例化。

据我所知，数学函数没有被规范标记为可寻址函数。

这是否意味着以下代码自 C++20 以来是非法的（如cppreference和其他标准库函数的示例所指出的）：

// unspecified and illegal?
auto func = static_cast<float (*)(float, float)>(std::pow);
std::cout << func(2, 4) << std::endl;

下面的代码呢，它合法吗？

// legal? or unspecified and illegal?
std::function<float(float, float)> f = static_cast<float(*)(float, float)>(std::pow);
std::cout …

以下代码使用 clang 编译，但不使用 gcc 编译：

template<typename T>
class number {
    T num;
public:
    number(T num = 0): num(num) {}
    
    friend auto add(auto a, auto b);
};

auto add(auto a, auto b) {
    // the decltype(a) is needed to make clang happy
    // see: /sf/ask/4394546971/
    return number<decltype(a)>{a}.num + number<decltype(b)>{b}.num;
}

int main() {
    auto result = add(1.0, 2.0);
}

gcc 提供的编译错误（版本 10.1 with -std=c++20）：

In instantiation of 'auto add(auto:13, auto:14) [with auto:13 = double; auto:14 = double]':
error: 'double …

C++20 弃用了类型上的某些特定操作volatile（遵循P1152）。

以下代码在 C++20 之前有效：

void busyLoop(std::size_t count) {
  for (volatile size_t counter = 0; counter < count; ++counter);
}

现在生成弃用警告：

warning: '++' expression of 'volatile'-qualified type is deprecated [-Wvolatile]

更改++to+=或 tocounter = counter + 1没有帮助，因为问题似乎在于基于易失性类型计算新值。

上面的代码如何调整以适应新的C++20规则？