为什么我的对象似乎在堆上而没有使用“new”？

Question

我开始学习动态内存分配的主题。

我有以下代码：

#include <iostream>
#include "A.h"
#include "B.h"

using namespace std;

int main() {

   /* Both objects on Stack */

   A classAStack;
   B classBStack;

   /* Both objects on Heap*/
   //  A *classAHeap = new A();
   //  B *classBHeap = new B();

   /* A objects on Heap B ???*/
   A *classAHeap = new A();

   return 0;
}

#ifndef A_H_
#define A_H_

#include <iostream>
#include "B.h"

class A {
public:
   A();
   virtual ~A();

public:
   B b;
};

#endif /* A_H_ */

#include "A.h"

A::A() {
   std::cout <<"Constructor A called" << std::endl;
}

A::~A() {
}

#ifndef B_H_  
#define B_H_

#include <iostream>

class B {
public:
  B();
  virtual ~B();
};

#endif /* B_H_ */

#include "B.h"

B::B() {
  std::cout <<"Constructor B called" << std::endl;
}

B::~B() {
}

调试器的输出是：

Temporary breakpoint 6, main () at ../src/HeapStackTest02.cpp:18
18    A classAStack;

Breakpoint 4, B::B (this=0x23aa58) at ../src/B.cpp:12
12    std::cout <<"Constructor B called" << std::endl;

Breakpoint 5, A::A (this=0x23aa50) at ../src/A.cpp:13
13    std::cout <<"Constructor A called" << std::endl;

Breakpoint 4, B::B (this=0x23aa40) at ../src/B.cpp:12
12    std::cout <<"Constructor B called" << std::endl;

Breakpoint 4, B::B (this=0x60004b048) at ../src/B.cpp:12
12    std::cout <<"Constructor B called" << std::endl;

Breakpoint 5, A::A (this=0x60004b040) at ../src/A.cpp:13
13    std::cout <<"Constructor A called" << std::endl;

Breakpoint 1, main () at ../src/HeapStackTest02.cpp:30
30    return 0;

对于我的问题：

类A的成员变量b在哪里？

如果我查看第0x23a节中的地址，它似乎是堆栈，而第0x6000节似乎是堆。

我正在使用Windows 64位系统。

为什么成员变量b也在堆上，而没有调用new运算符？

Answer 1

考虑一下：

#include <iostream>
#include <string>

class B {
public:
    int64_t x = 42;
    int64_t y = 7;
};

class A1 {
public:
    B b;
};

class A2 {
public:
    A2() { b = new B(); }
    B* b;
    ~A2() { delete b; }
};

int main() {
    std::cout << sizeof(A1) << std::endl;   // prints 16
    std::cout << sizeof(A2) << std::endl;   // prints 8

    // Section (2)
    A1 a1;  // Instance of A1 and B are on the stack
    A2 a2;  // Instance of A2 is on the stack. B is on the heap.

    A1* a3 = new A1();
    std::cout << a3 == &(a3->b) << std:: endl;  // prints true

    A2* a4 = new A2();
    std::cout << a4 == a4->b << std::endl;  // prints false

    return 0;
}   

Answer 2

为了回答这个问题，让我们从找出我们有多少B类型的实例开始。答案是3。

一个实例是类型A的成员b（在堆栈上）。另一个是堆栈上B的实例，第三个是堆上A类型的成员B的实例。

为什么会堆起来？它就在那里，因为您在堆上创建了类型A的实例，而A的实例的成员是B的实例。

所以B的三个实例中有一个在堆上，另外两个在堆栈上。

Answer 3

成员是b是您动态分配的对象的一部分，因此它是该动态分配的一部分，并且位于内存中的同一位置。

如果成员不是对象的一部分，会剩下什么？你会动态分配什么？

这就是为什么在看到new时，应该避免使用术语“在堆上”。不仅仅是你新的东西是“堆上的”。不，new动态分配一个对象以及该对象直接包含的所有内容。你如何写一个对象的声明和它是“在堆上”还是“在堆栈上”之间的任何心理联系都注定要失败。

确定物体存储时间的唯一可靠方法是了解其历史；确定对象存储位置的唯一可靠方法是不要麻烦，因为你不需要麻烦。