Странный sizeof() - C/C++

Почему sizeof() возвращает значения, которые кажутся не верными?

struct S
{
  const char cc;
  char ch;
  //const char* pcc;
}

В этом случае sizeof() возвращает 2.

struct S
{
  //const char cc;
  //char ch;
  const char* pcc;
}

В этом случае sizeof() возвращает 4.
Тогда в этом случае он должен возвращать 6, казалось бы:

struct S
{
  const char cc;
  char ch;
  const char* pcc;
}

Но возвращает — 12.
Почему так? Может это зависит от выравнивания? Тогда как выравнивать?

Здравствуйте, Magic, Вы писали:

M>Почему так? Может это зависит от выравнивания? Тогда как выравнивать?

Именно от выравнивания.
Выравниваем вот так (для примера на один байт)

#pragma pack(1)

struct S
{
  const char cc;
  char ch;
  const char* pcc;
};

#pragma pack()

Имеем sizeof(S)=6
Хотя странно, почему у тебя получается 12 ?
VC 7.1 мне выдал на такую структуру 8 байт, чего я собственно от него и ожидал

Здравствуйте, Magic, Вы писали:

M>

struct S
M>{
M>  const char cc;
M>  char ch;             // (1)
M>  const char* pcc;     // (2)
M>}

Но возвращает — 12.
M>Почему так? Может это зависит от выравнивания? Тогда как выравнивать?
Может у тебя строчки (1) и (2) местами поменяны?

Здравствуйте, Magic, Вы писали:

M>Почему так? Может это зависит от выравнивания?
Да, дело именно в выравнивании.

M>Тогда как выравнивать?
Сначала ответь: почему тебя не устраивает текущее положение?

Здравствуйте, Всеволод, Вы писали:

В>VC 7.1 мне выдал на такую структуру 8 байт, чего я собственно от него и ожидал

const char* на 4 выровнял?

... << RSDN@Home 1.1.3 beta 1 >>

Здравствуйте, Magic, Вы писали:

M>Тогда в этом случае он должен возвращать 6, казалось бы:
M>

struct S
M>{
M>  const char cc;
M>  char ch;
M>  const char* pcc;
M>}

Но возвращает — 12.
M>Почему так? Может это зависит от выравнивания? Тогда как выравнивать?
Я уже подробно отвечал на этот вопрос
Сообщение 395496 от 29.09.2003
Заголовок: Где почитать правила выравнивания структур

http://rsdn.ru/forum/?mid=395496
Автор: LaptevVV
Дата: 29.09.03

Удалено избыточное цитирование. -- ПК.

Здравствуйте, Magic, Вы писали:

M>Почему sizeof() возвращает значения, которые кажутся не верными? <...>
M>Тогда в этом случае он должен возвращать 6, казалось бы:
M>

struct S
M>{
M>  const char cc;
M>  char ch;
M>  const char* pcc;
M>}

Но возвращает — 12.
M>Почему так? Может это зависит от выравнивания? Тогда как выравнивать?

по умолчанию в MSVC выравнивание по 8, поэтому 12 получается, т.к. указатель требует выравнивания по 4 байта (иначе произойдет ошибка в системной шине, в линуксе SIGBUS), он его выравнивает с 8-го байта, вот тебе и 12 байт.
Должнобыть 6:

struct S
{
  const char* pcc;
  const char cc;
  char ch;
}

Удалено избыточное цитирование. -- ПК.

Здравствуйте, Вадим Никулин, Вы писали:

ВН>Здравствуйте, Magic, Вы писали:

M>>

struct S
M>>{
M>>  const char cc;
M>>  char ch;             // (1)
M>>  const char* pcc;     // (2)
M>>}

Но возвращает — 12.
M>>Почему так? Может это зависит от выравнивания? Тогда как выравнивать?
ВН>Может у тебя строчки (1) и (2) местами поменяны?

А от этого что-то зависит???

Здравствуйте, Magic, Вы писали:

M>>>

struct S
M>>>{
M>>>  const char cc;
M>>>  char ch;             // (1)
M>>>  const char* pcc;     // (2)
M>>>}

Но возвращает — 12.
M>>>Почему так? Может это зависит от выравнивания? Тогда как выравнивать?
ВН>>Может у тебя строчки (1) и (2) местами поменяны?

M>А от этого что-то зависит???

Многое

Если принять за постулат, что по умолчанию данные выравнены по границе 4 байта, то тогда:

struct S
{
  const char cc; // 1 byte
  // 3 bytes padding
  const char* pcc; // 4 bytes
 char ch; // 1 byte
 // 3 bytes padding
};

Итого 12 байт.

Здравствуйте, Flamer, Вы писали:

F>Многое

Если принять за постулат, что по умолчанию данные выравнены по границе 4 байта, то тогда:

F>

F>struct S
F>{
F>  const char cc; // 1 byte
F>  // 3 bytes padding
F>  const char* pcc; // 4 bytes       2)
F> char ch; // 1 byte
F> // 3 bytes padding
F>};
F>

F>Итого 12 байт.

А если мы строчку 2) поместим в конец описания, то, разве, не такой же результат получим?

Здравствуйте, Magic, Вы писали:

[]

F>>

F>>struct S
F>>{
F>>  const char cc; // 1 byte
F>>  // 3 bytes padding
F>>  const char* pcc; // 4 bytes       2)
F>> char ch; // 1 byte
F>> // 3 bytes padding
F>>};
F>>

F>>Итого 12 байт.

M>А если мы строчку 2) поместим в конец описания, то, разве, не такой же результат получим?

Не тот-же, как это ни странно. Должно получиться 8 байт. Почему? Подумайте.

З.Ы. Вот щас ПК придет и всех построит

Здравствуйте, Flamer, Вы писали:

F>Здравствуйте, Magic, Вы писали:
F>[]
F>>>

F>>>struct S
F>>>{
F>>>  const char cc; // 1 byte          1) 
F>>>  // 3 bytes padding
F>>>  const char* pcc; // 4 bytes       2)
F>>> char ch; // 1 byte                 3)
F>>> // 3 bytes padding
F>>>};
F>>>

F>>>Итого 12 байт.

M>>А если мы строчку 2) поместим в конец описания, то, разве, не такой же результат получим?

F>Не тот-же, как это ни странно. Должно получиться 8 байт. Почему? Подумайте.

Наверно поттому, что если бы строка 3) стояла вместе с 1), то полселе выравнивания на 4 байта потребовалось бы добавить только два байта после 1)+3) Так?

M>Наверно поттому, что если бы строка 3) стояла вместе с 1),

Тогда они занимали бы 2 байта, так как у каждого члена типа char выравнивание 1.

то полселе выравнивания на 4 байта потребовалось бы добавить только два байта
после 1)+3) Так?

Да, так, потому что у следующего члена-указателя выравнивание 4, а 2 + 2 == 4

Короче, есть ситуации, когда порядок расположения членов, и даже помещение их в базовый или производный класс влияет на размер объекта.

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>Да, так, потому что у следующего члена-указателя выравнивание 4, а 2 + 2 == 4

а выравнивание разве к соседним char не относится?

значит если сделать так, то структура всегда будет занимать 6 байт (если выравнивание <= 4)?

struct S
{
  char* pcc;   
  char cc; 
  char ch; 
};

Здравствуйте, Ovl, Вы писали:

Ovl>значит если сделать так, то структура всегда будет занимать 6 байт (если выравнивание <= 4)?

Ovl>

Ovl>struct S
Ovl>{
Ovl>  char* pcc;   
Ovl>  char cc; 
Ovl>  char ch; 
Ovl>};
Ovl>

При выравнивании 4 — скорее 8, чем 6: в массивах объекты размещаются непрерывно, соответственно, компилятор должен "шаманить" с самой структурой, чтобы потом ее безболезненно можно было поместить в массив.

Здравствуйте, Павел Кузнецов, Вы писали:

ПК>Здравствуйте, Ovl, Вы писали:

Ovl>>значит если сделать так, то структура всегда будет занимать 6 байт (если выравнивание <= 4)?

Ovl>>

Ovl>>struct S
Ovl>>{
Ovl>>  char* pcc;   
Ovl>>  char cc; 
Ovl>>  char ch; 
Ovl>>};
Ovl>>

ПК>При выравнивании 4 — скорее 8, чем 6: в массивах объекты размещаются непрерывно, соответственно, компилятор должен "шаманить" с самой структурой, чтобы потом ее безболезненно можно было поместить в массив.

Почему скорее? Именно так и будет. sizeof (T) всегда кратен alignof (T) -- именно из-за массивов. При необходимости добавляется паддинг в конце.

... << RSDN@Home 1.1.0 stable >>

В XXI век с CCore.

Копай Нео, копай -- летать научишься. © Matrix. Парадоксы

Здравствуйте, Flamer, Вы писали:

F>Не тот-же, как это ни странно. Должно получиться 8 байт. Почему? Подумайте.

struct S
{
const char cc; // 1 byte
char ch; // 1 byte
// 2 bytes padding
const char* pcc; // 4 bytes
};

Угадал?

... << RSDN@Home 1.1.2 beta 1 >>

Здравствуйте, Magic, Вы писали:

M>Почему так? Может это зависит от выравнивания? Тогда как выравнивать?

Обязательное чтение: C++ Language Reference: align
Внеклассное чтение: Windows Data Alignment on IPF, x86, and x86-64

	От:	Magic
	Дата:	19.02.04 06:37
	Оценка:

	От:	Всеволод
	Дата:	19.02.04 07:14
	Оценка:	1 (1) +1

От:	Вадим Никулин	Здесь
Дата:	19.02.04 07:23
Оценка:	+1

	От:	Bell
	Дата:	19.02.04 07:29
	Оценка:

От:	m.a.g.	http://dottedmag.net/
Дата:	19.02.04 07:29
Оценка:

От:	Flamer	http://users.livejournal.com/_flamer_/
Дата:	19.02.04 12:15
Оценка:

	От:	Павел Кузнецов
	Дата:	21.02.04 07:59
	Оценка:

	От:	Ovl
	Дата:	20.02.04 21:25
	Оценка: