小编cur*_*guy的帖子

我听说C++类成员函数模板不能是虚拟的.这是真的？

如果它们可以是虚拟的,那么一个人可以使用这样一个函数的场景的例子是什么？

我开始研究C++ 11的智能指针,我没有看到任何有用的用法std::weak_ptr.有人能告诉我什么时候std::weak_ptr有用/必要吗？

为什么不允许对一个临时对象进行非const引用,哪个函数getx()返回？显然,这是C++标准禁止的,但我对这种限制的目的感兴趣,而不是对标准的引用.

struct X
{
    X& ref() { return *this; }
};

X getx() { return X();}

void g(X & x) {}    

int f()
{
    const X& x = getx(); // OK
    X& x = getx(); // error
    X& x = getx().ref(); // OK
    g(getx()); //error
    g(getx().ref()); //OK
    return 0;
}

1. 很明显,对象的生命周期不是原因,因为C++标准不禁止对对象的持续引用.
2. 很明显,上面的示例中的临时对象不是常量,因为允许调用非常量函数.例如,ref()可以修改临时对象.
3. 此外,ref()允许您欺骗编译器并获取此临时对象的链接,这解决了我们的问题.

此外:

他们说"为const引用分配一个临时对象可以延长这个对象的生命周期","但是对于非const引用却没有任何说法".我的其他问题.以下赋值是否延长了临时对象的生命周期？

X& x = getx().ref(); // OK

默认构造函数(由编译器创建)是否初始化内置类型？

我明白这std::atomic<>是一个原子对象.但原子到什么程度？根据我的理解,操作可以是原子的.使对象成为原子意味着什么？例如,如果有两个线程同时执行以下代码:

a = a + 12;

然后是整个操作(比方说add_twelve_to(int))原子？或者是变量原子(so operator=())的变化？

是否有充分的理由不为类声明虚拟析构函数？什么时候应该特别避免写一个？

我只是看着Stephan T. Lavavej谈论CppCon 2018"课程模板论证演绎",他在某些时候偶然说:

在C++类型中,信息几乎从不向后流动...... 我不得不说"差不多",因为有一两个案例,可能更多但很少.

尽管试图找出他可能指的是哪些案件,但我无法想出任何建议.因此问题是:

在哪些情况下,C++ 17标准要求类型信息向后传播？

问题确实符合标题:我很想知道这种差异的技术原因是什么,还有理由？

std::shared_ptr<void> sharedToVoid; // legal;
std::unique_ptr<void> uniqueToVoid; // ill-formed;

class A                     { public: void eat(){ cout<<"A";} }; 
class B: virtual public A   { public: void eat(){ cout<<"B";} }; 
class C: virtual public A   { public: void eat(){ cout<<"C";} }; 
class D: public         B,C { public: void eat(){ cout<<"D";} }; 

int main(){ 
    A *a = new D(); 
    a->eat(); 
} 

我理解钻石问题,上面的代码没有那个问题.

虚拟继承究竟是如何解决问题的？

我的理解: 当我说A *a = new D();,编译器想要知道类型的对象是否D可以分配给类型的指针A,但它有两个可以遵循的路径,但不能自己决定.

那么,虚拟继承如何解决问题(帮助编译器做出决定)？

假设我有一个类型,我想将其默认构造函数设为私有.我写了以下内容:

class C {
    C() = default;
};

int main() {
    C c;           // error: C::C() is private within this context (g++)
                   // error: calling a private constructor of class 'C' (clang++)
                   // error C2248: 'C::C' cannot access private member declared in class 'C' (MSVC)
    auto c2 = C(); // error: as above
}

大.

但是,构造函数结果证明不像我想象的那样私密:

class C {
    C() = default;
};

int main() {
    C c{};         // OK on all compilers
    auto c2 = C{}; // OK on …