标签: memory-layout

我说的是英特尔32位平台.Linux内核版本2.6.31-14.

#include <stdio.h>
#include <stdlib.h>

int init_global_var = 10;        /* Initialized global variable */
int global_var;                  /* Uninitialized global variable */
static int init_static_var = 20; /* Initialized static variable in global scope */
static int static_var;           /* Uninitialized static variable in global scope */

int main(int argc, char **argv, char **envp)
{
        static int init_static_local_var = 30;   /* Initialized static local variable */
    static int static_local_var;             /* Uninitialized static local variable */
    int init_local_var = 40;                 /* Initialized local …

我很难理解C99标准草案(N1256)关于位域(6.7.2.1:10)的确切含义:

6.7.2.1结构和联合说明符

[...]

语义

[...]

实现可以分配任何足够大的可寻址存储单元来保存位字段.如果剩余足够的空间,则紧跟在结构中的另一个位字段之后的位字段将被打包到相同单元的相邻位中.如果剩余的空间不足,则是否将不适合的位域放入下一个单元或重叠相邻单元是实现定义的.单元内的位域分配顺序(高阶到低阶或低阶到高阶)是实现定义的.未指定可寻址存储单元的对齐.

强调的句子将我的英语技能扩展到极限:我不明白它是指单元内的各个位字段,还是单个位字段内的位排序或其他内容.

我会试着通过一个例子让我更加清楚.假设无符号整数是16位,实现选择unsigned int作为可寻址存储单元(并且字节为8位宽),并且不会出现其他对齐或填充问题:

struct Foo {
    unsigned int x : 8;
    unsigned int y : 8;
};

thus, assuming x and y fields are stored inside the same unit, what is implementation-defined according to that sentence? As I understand it, it means that inside that unsigned int unit, x can be stored either at a lower address than y or vice-versa, but I'm not sure, since intuitively I'd think that if no …

在Java 8之前，我们有5个主要的运行时数据区域：

1. 方法范围
2. 堆
3. JVM堆栈
4. PC寄存器
5. 本机方法堆栈

在Java 8中，没有Perm Gen，这意味着不再有“ java.lang.OutOfMemoryError：PermGen”

很棒，但我也读过

方法区域是Perm Gen中空间的一部分

但我似乎找不到任何明确表明Java 8中不再存在“方法”区域的内容。

因此删除了Perm Gen以及Method区域，或者仅删除了Perm Gen且Method区域仍然存在于旧一代中。

请附上您可能看到的与Java 8内存模型相关的任何良好的源材料

这是一个很大的问题，因此我要求参考而不是小册子大小的答案。我正在进行Stroustrup的C ++之旅，看来对象的布局方式是内存是许多C ++功能设计的基础，例如POD，聚合，带有虚拟成员的类。

不幸的是，Tour本身并没有详细介绍此主题，而对一些标准参考文献（例如C ++ Primer 5ed和TCPPPL 4ed）的ToC进行浏览并不能显示它们是否涉及该主题。

它看起来很聪明,只能为A使用一个字节,但不够聪明,不能使用一个字节用于B,即使只有8*8 = 64种可能性.有没有办法哄Rust来解决这个问题,还是我必须手动实现更紧凑的布局？

游乐场链接.

#![allow(dead_code)]

enum A {
    L,
    UL,
    U,
    UR,
    R,
    DR,
    D,
    DL,
}

enum B {
    C(A, A),
}

fn main() {
    println!("{:?}", std::mem::size_of::<A>()); // prints 1
    println!("{:?}", std::mem::size_of::<B>()); // prints 2
}

我认为sizeof(Base)应该是12。为什么是16？

没有虚函数，我得到4和8。

class Base{
  public:
    int i;
    virtual void Print(){cout<<"Base Print";}
};

class Derived:public Base{
  public:
    int n;
    virtual void Print(){cout<<"Derived Print";}
};

int main(){
  Derived d;
  cout<<sizeof(Base)<<","<<sizeof(d);
  return 0;
}

预期结果？12？16

实际结果？16？16

这里这个问题表明，std::atomic<T>被普遍认为有大小相同T，而事实上，这似乎是对GCC，铛，和MSVC在x86，x64和ARM的情况。

在std::atomic<T>某个类型始终无锁的实现中T，是否保证其内存布局与的内存布局相同T？是否还有其他特殊要求std::atomic，例如对齐？

这是给定程序的输出:

sizeof(Empty) 1
sizeof(Derived1) 1
sizeof(Derived2) 4
sizeof(Derived3) 1
sizeof(Derived4) 8
sizeof(Dummy) 1

这是该计划:

#include <iostream>
using namespace std;

class Empty
{};

class Derived1 : public Empty
{};

class Derived2 : virtual public Empty
{};

class Derived3 : public Empty
{    
    char c;
};

class Derived4 : virtual public Empty
{
    char c;
};

class Dummy
{
    char c;
};

int main()
{
    cout << "sizeof(Empty) " << sizeof(Empty) << endl;
    cout << "sizeof(Derived1) " << sizeof(Derived1) << endl;
    cout …

假设我正在迭代一个数组，但超出了这个数组，因为我的循环很愚蠢。
如果内存中的对象直接位于与该数组相同类型的该数组之后，
检查可以array[invalid_index] == nullptr
保护我吗？

检查索引（大小未知）是否对 C 数组有效的正确方法是什么？

我刚刚了解alignof和alignasC ++的关键字，但我不敢去想如果开发者希望使用这些关键字的任何实际的案例。

有人知道这些关键字的任何实际用例吗？