В C/C++ размер произвольной структуры в памяти определяется размерами её полей, выравниванием и возможным паддингом (добавочными байтами). На практике размер структуры может быть больше суммы размеров её полей, из-за особенностей выравнивания и архитектуры процессора.

🔹 Что влияет на размер структуры?

1. **Размеры полей
   **
2. **Выравнивание (alignment)
   **
3. **Порядок следования полей
   **
4. **Паддинг (padding)
   **
5. **Архитектура (32/64-бит)
   **
6. **Компилятор и его настройки
   **
7. **Выравнивание всей структуры (struct alignment)
   **

📘 1. Сумма размеров полей (в теории)

Например:

struct A {
int a; // 4 байта
char b; // 1 байт
float c; // 4 байта
};

На первый взгляд кажется, что размер будет 4 + 1 + 4 = 9 байт, но это неправда, потому что вступает в силу выравнивание.

📗 2. Выравнивание и паддинг

Процессоры читают данные быстрее, когда они выравнены по границам. Например, int чаще всего должен начинаться с адреса, кратного 4 байтам. Поэтому компилятор может вставлять неиспользуемые байты (padding) между полями.

Пример:

struct A {
char c; // 1 байт
int i; // 4 байта
};

Память:

| c | pad | pad | pad | i i i i |

Здесь char занимает 1 байт, но из-за выравнивания int начинается с адреса, кратного 4. Поэтому между char и int добавляется 3 байта паддинга. В итоге размер A — 8 байт, а не 5.

Проверка:

#include <iostream>
struct A {
char c;
int i;
};
int main() {
std::cout << sizeof(A) << std::endl; // выведет 8
}

📙 3. Итоговое выравнивание структуры

Структура также может иметь общий паддинг в конце, чтобы соответствовать выравниванию в массивах структур. Например:

struct B {
char c; // 1
short s; // 2
};

Сумма = 3 байта, но sizeof(B) скорее всего будет 4, чтобы выровнять следующий элемент в массиве.

📒 4. Порядок полей имеет значение

Перестановка полей может уменьшить размер структуры:

struct C1 {
char c; // 1
int i; // 4
char d; // 1
};
// здесь: c(1) + pad(3) + i(4) + d(1) + pad(3) = 12 байт
struct C2 {
int i; // 4
char c; // 1
char d; // 1
// pad(2)
};
// всего: 4 (int) + 1 + 1 + 2(pad) = 8 байт

Таким образом, C2 компактнее, чем C1, из-за другого порядка.

🧱 5. Вложенные структуры

Если структура содержит другую структуру, размер будет включать её размер + выравнивание:

struct Inner {
int x;
char y;
}; // размер 8 из-за паддинга
struct Outer {
Inner a;
int b;
}; // размер зависит от компилятора, но скорее всего будет 16

🧮 6. Проверка размера sizeof()

Официально узнать размер можно с помощью оператора sizeof():

struct MyStruct {
int a;
char b;
double c;
};
std::cout << sizeof(MyStruct) << std::endl;

📌 Пример с выводом выравнивания

#include <iostream>
#include <cstddef>
struct Example {
char a;
int b;
char c;
double d;
};
int main() {
std::cout << "sizeof(Example): " << sizeof(Example) << '\\n';
std::cout << "offsetof(a): " << offsetof(Example, a) << '\\n';
std::cout << "offsetof(b): " << offsetof(Example, b) << '\\n';
std::cout << "offsetof(c): " << offsetof(Example, c) << '\\n';
std::cout << "offsetof(d): " << offsetof(Example, d) << '\\n';
}

🎛 Выравнивание вручную: #pragma pack

Для изменения поведения компилятора можно использовать #pragma pack:

#pragma pack(push, 1)
struct PackedStruct {
char a;
int b;
};
#pragma pack(pop)

Это заставит компилятор не добавлять паддинг, и sizeof(PackedStruct) будет 5 байт. Но такой подход может привести к падению производительности и ошибкам при доступе к памяти на некоторых архитектурах.

🧠 Вывод (внутренний)

Размер произвольной структуры зависит от:

• количества и типов полей;

• порядка их следования;

• требований выравнивания каждого поля;

• требований выравнивания всей структуры.

Чтобы точно определить размер:

• Используйте sizeof();

• Анализируйте порядок и типы полей;

• Помните о паддинге;

• При необходимости — применяйте #pragma pack, но осторожно.