小编sof*_*ver的帖子

我试图了解一个类的vtable在C ++中的敏感程度，为此，我需要知道对于下面列出的3个更改方案是否需要重新编译整个类层次结构（总共3个头文件）。首先，这是我的班级层次结构：

class A {
   public:
   virtual void method1() = 0;
   virtual void method2() = 0;
   virtual ~A() {} 
};

class B : public A {
    public:
    virtual void method1() {};
    virtual void method2() {};
    virtual ~B() {} 
};

class C : public A {
    public:
    virtual void method1() {};
    virtual void method2() {};
    virtual ~C() {} 
};

这是我的情况：

1. 非虚拟方法被添加到基类A：

   void method3() {};
   

   Run Code Online (Sandbox Code Playgroud)

2. 具有主体的虚拟方法被添加到基类A中：

   virtual void method3() {};
   

   Run Code Online (Sandbox Code Playgroud)

3. 将纯虚拟方法添加到基类A：

   virtual void method3() = 0;
   

   Run Code Online (Sandbox Code Playgroud)

在方案1中，不对vtable进行任何更改。是否仍然需要重新编译B和C？

在方案2中，是否会针对基数A并因此针对B和C重构vtable？

我知道方案3将强制类B和C提供新方法的实现。因此，必须重新编译整个层次结构。

我试图看到调用属于长层次结构的类的虚拟析构函数的影响:类A到类E.

奇怪的是,析构函数不会向控制台写任何内容.我首先想到也许它正在发生,因为主要也在退出.因此,我将所有测试代码放在一个名为test()的函数中,并从main()中调用,这样当测试返回时,我会看到析构函数的脚印.但是,没有!控制台上没有"cout"标志出现!

#include <iostream>

using namespace std;

//A constructor cannot be virtual but a destructor can.
class A {
public:
A() {
    cout << "A constructor" << endl;
}
virtual ~A() {cout << "A destructor" << endl;}
};

class B :public A {
public:
    B() {
    cout << "B constructor" << endl;
    }
    virtual ~B() {cout << "B destructor" << endl;}
};

class C :public B {
public:
    C() {
    cout << "C constructor" << endl;
    }
    virtual ~C() {cout …

我用TDM-GCC 4.6.1编译器对rvalue引用做了一些实验,并做了一些我无法用理论解释的有趣观察.我想那里的专家帮我解释一下.

我有一个非常简单的程序,不处理对象,但int原语,并定义了2个函数:foo1(通过rvalue引用返回局部变量)和foo2(按值返回局部变量)

#include <iostream>

using namespace std;

int &&foo1();
int foo2();

int main()
{

int&& variable1 = foo1();
//cout << "My name is softwarelover." << endl;
cout << "variable1 is: " << variable1 << endl; // Prints 5.
cout << "variable1 is: " << variable1 << endl; // Prints 0.

int&& variable2 = foo2();
cout << "variable2 is: " << variable2 << endl; // Prints 5.
cout << "variable2 is still: " << variable2 << endl; // Still prints …

这是C++中的一段简单代码,它只为一个名为Foo的类的实例动态分配内存,并且忘记以后释放内存.让我们假设Foo非常简单.

int main() {
  Foo *abcd = new Foo();
  return 0;
}

由于程序终止,它真的是内存泄漏吗？如果我重新运行此程序,先前分配的内存是否可用于分配？

这是等效的Java代码:

public static void main(String[] args) {
  Foo abcd = new Foo();
}

由于程序快速终止,如果垃圾收集器没有足够的时间来释放内存怎么办？如果我重新运行此程序,先前分配的内存是否可用于分配？