Хранение переменных в памяти

Question

Если у меня есть список глобальных переменных, как это ...

int a; 
char b; 
float c[10]; 
double d[3]; 

и у меня есть идентичную последовательность переменных, перечисленных в классе ...

class test_type 
{ 
    int a; 
    char b; 
    float c[10]; 
    double d[3]; 
} 

гарантировано, что расположение всех переменных в памяти идентично. то есть «b» гарантированно хранится сразу после «a» как в списке глобальных таблиц, так и в списке классов?

EDIT: Я прошу, потому что я хотел, чтобы A) скопировал данные из одного в другое как «место работы» и B). Я хотел проверить любые различия между ними в качестве задания. Если ответ на главный вопрос «нет», то есть ли у кого-нибудь какие-либо предложения относительно того, как я обойду проблему, предпочтительно оставляя существующий код как можно более неизменным.

Answer 1

Нет. Я не думаю, что стандарт C++ гарантирует что-либо о макете памяти глобальных переменных.

Answer 2

Распределение памяти зависит от компилятора. Таким образом, непрерывное распределение или идентичное распределение глобальных переменных и переменных класса не может быть гарантировано.

Answer 3

Нет, вы не можете положиться на это. Речь идет о компиляторе, как распределять память для переменных.

Answer 4

Нет, это не гарантировано. В зависимости от того, что вы хотели бы сделать, вы можете использовать операторы «указатель-член», чтобы убедиться, что вы знаете относительный адрес переменной-члена.

Так что в вашем классе:

class test_type 
{ 
    int a; 
    char b; 
    float c[10]; 
    double d[3]; 
} 

void* pa = &test_type::a; 
void* pb = &test_type::b; 
void* pc = &test_type::c; 
void* pd = &test_type::d; 

void main() 
{ 
    std::cout << "Relative address of member 'a' " << (int)pa << std::endl; 
    std::cout << "Relative address of member 'b' " << (int)pb << std::endl; 
    std::cout << "Relative address of member 'c' " << (int)pc << std::endl; 
    std::cout << "Relative address of member 'd' " << (int)pd << std::endl; 
} 

Насколько я знаю, она работает с MSVC и GCC, а также.

Answer 5

Стандарты C/C++ не требуют сохранения переменных в порядке их деклараций. Поэтому компиляторы могут хранить переменные в том порядке, в котором они хотят. Но гарантируется, что они будут инициализированы в порядке их объявления. Это справедливо как для глобальных переменных, так и для переменных класса.

Некоторые примечания по глобальным переменным: в блоке компиляции они будут инициализированы в указанном порядке, но этот gurantee не применяется через единиц компиляции.

Answer 6

Мик - для того, чтобы делать то, что вы хотите (копия/тест), вам просто нужно

• добавить конструктор test_type класса, а также не-конструктор init_from_globals() (чей код копирует 4 значения по одному, массивы, скопированные в цикле или через memcopy).

• Добавить «diff_from_globals) (» метод, который снова Diffs 4 членов индивидуально

Это немного менее эффективным/элегантнее, чем то, что вы хотели, насколько реализации, но завернутые в методе, в-элегантность полностью скрыта от остальной части кода:

Answer 7

Почему бы вам просто не использовать глобальный объект типа test_type вместо определения нескольких глобальных переменных?

class test_type 
{ 
    int a; 
    char b; 
    float c[10]; 
    double d[3]; 
}; 

test_type global; 

Теперь это кусок пирога, чтобы инициализировать новый объект test_type с копией «глобальной».

Answer 8

Я думаю, что людям не хватает точки. Всегда опасно предполагать любую компоновку, поскольку это может измениться с CPU на CPU, компилятор на компилятор и даже на степень оптимизации.

C++ генерирует функцию присваивания копии по умолчанию, как если бы вы написали это:

class test_type 
{ 
    int a; 
    char b; 
    float c[10]; 
    double d[3]; 
public: 
    test_type &operator=(const test_type &other) 
    { 
    // copy all of the members one by one. 
    } 
} 

Единственное ограничение в том, что оператор по умолчанию просто копируют элементы и что включает в себя указатели. Если вы динамически выделили что-то, прикрепленное к указателю, вам придется иметь дело с новым распределением памяти и копированием данных в операторе.