标签: memory-layout

有这个代码：

#include <iostream>

class Base
{
   int x;
};

class Derived : virtual public Base
{
   int y;
};

int main()
{
    std::cout << sizeof(Derived) << std::endl; // prints 12
    return 0;   
}

我已经读过，当某个类被虚拟继承时，会为类派生创建空虚表，因此内存布局如下：

Derived::ptr to empty vtable
Derived::y
Base::x

它是 12 个字节。问题是 -如果没有任何虚拟方法，这个空的vtable 的目的是什么，它是如何使用的？

我知道标准没有规定如何打包数据.我只是试图了解类的内存布局(尤其是如何dynamic_cast<void*>保证返回指向最派生类的开头的指针).我想不出有关以下代码输出的任何解释:

struct A{ int a;};
struct B{ int b;};
struct C: public A, public B { int c;};
struct D:public C {int d;};


int main(){
  D* ob=new D;
  A* a = ob;
  B* b = ob;
  C* c = ob;
}

打印指针的值表明,a,c,d有总是相同的值,只b添加4个字节偏移量.这是偶然的吗？或者背后有一个逻辑？

编辑: 从概念上讲,布局应该像图像一样,但不知何故,点A,C和D合并为一个.

我有以下堆栈和堆分配的变量:

let var1 = 10;
let var2 = Box::new(10);

打印这些输出相同的值,10:

println!("var1 ={} var2 ={}", var1, * var2);

当我检查尺寸时mem::size_of_val(),var1是4并且var2是8.

不是var2指向堆的指针？为什么指针大于堆栈变量(var1)？

是,使用" *"(即*var2)println!()应该做什么不同？无论如何,我得到10分.

我试图测量结构及其字段(Playground)的大小:

use std::mem;

struct MyStruct {
    foo: u8,
    bar: char,
}

println!("MyStruct: {}", mem::size_of::<MyStruct>());

let obj = MyStruct { foo: 0, bar: '0' };
println!("obj:      {}", mem::size_of_val(&obj));
println!("obj.foo:  {}", mem::size_of_val(&obj.foo));
println!("obj.bar:  {}", mem::size_of_val(&obj.bar));

该程序打印:

MyStruct: 8
obj:      8
obj.foo:  1
obj.bar:  4

因此结构的大小大于其字段大小的总和(这将是5).这是为什么？

我知道类之外的常量变量可以直接优化到编译器的函数调用中,但编译器对常量类变量执行相同操作是否合法？

如果有一个类声明如下:

class A {
public:
const int constVar;
    //other, modifiable variables

A(int val): constVar(val) {
         //code to initialize modifiable variables

}
};

我创建一个A的实例并调用这样的函数:

A obj(-2);
int absoluteVal = std::abs(A.constVar);

是否允许编译器执行此操作并使类sizeof(int)更小？:

A obj();
int absoluteVal = std::abs(-2);

我有以下代码:

#pragma pack(push, 4)

class C {
    public:
        char a;
        char b;
        short c;
        char d;
};
C e;

我不明白为什么sizeof(e)是6.我认为sizeof(e)将是8 => 1(a)+ 1(b)+ 2(c)+ 1(d)+ 3(对齐)

我有如下的小代码片段:

char global=100;        

void main()
{
            char p = NULL;
            printf("%p\n", &p);
            printf("%p\n", &global);
}

在编译并生成二进制可执行映像之后,在每次执行相同的二进制可执行文件时,我会看到本地变量的不同虚拟内存地址p.
但是,全局变量的虚拟内存地址global保持不变.我理解C内存布局; 并且我希望在每次执行时使用相同的二进制图像为给定变量提供相同的内存位置.

在运行时为本地变量分配的虚拟地址的原因是什么？
只有一个功能,没有机会改变功能的执行顺序,从而改变堆栈存储器布局.

运行此程序4次的结果:

0x7fff181b4b2f
0x601034

0x7ffe34abd62f
0x601034

0x7ffe2813b98f
0x601034

0x7fffcef6b52f
0x601034

我需要摆脱这个警告。据我了解，这似乎是因为 DerivedClass 不被视为普通旧数据。我阅读了关于POD和标准布局类型的cppreference，但我仍然不明白为什么 DerivedClass 不是 POD。如果我将 BaseClass 的成员放入 DerivedClass 并且不使用继承 - 则一切正常。我使用 C++11

下面是一个例子：

#include <iostream>

using namespace std;

class BaseClass
{
public:
    int a;
};

class DerivedClass : public BaseClass
{
public:
    int b;
};

int main(int argc, char *argv[])
{
    // warning: offset of on non-standard-layout type 'DerivedClass'
    int offset = offsetof(DerivedClass, b);

    cout << offset;
}

我很感激任何帮助。

在这里，在这段代码中，ob1的大小为16，这很好（由于虚拟指针），但我不明白为什么ob2的大小为24。

#include <iostream>
using namespace std;
class A {
    int x;
};
class B {
    int y, z;
};
class C : virtual public A {
    int a;
};
class D : virtual public B {
    int b;
};
int main() {
    C ob1;
    D ob2;
    cout << sizeof(ob1) << sizeof(ob2) << "\n";
}

我预计ob2的大小为20，但输出为24

抱歉，如果问题可能重复，我既无法在此处找到，也无法使用 Google。

我是不安全 Swift 的新手，我想知道为什么 Bools 数组的大小（例如 10 个字节）仍然是 8 个字节？

如果我不能说出我的意思，我会想知道你是否可以看看这段代码：

var boolArray = [Bool]()
for _ in 1...10{
    boolArray.append(true)
}
print(MemoryLayout.size(ofValue: boolArray))

我不明白为什么它打印 8 而数组有 10 个至少包含 10 个字节的 bool。