Как читать:
Эта статья довольно длинная. Если вы хотите узнать об агрегатах и POD (простые старые данные), найдите время и прочитайте его. Если вас интересуют только агрегаты, прочитайте только первую часть. Если вы заинтересованы только в стручках , то вы должны сначала прочитать определение, значение и примеры агрегатов , а затем вы можете перейти к стручкам , но я бы рекомендовал читать первую часть в полном объеме. Понятие агрегатов необходимо для определения POD. Если вы обнаружите какие-либо ошибки (даже незначительные, включая грамматику, стилистику, форматирование, синтаксис и т. Д.), Пожалуйста, оставьте комментарий, я буду редактировать.
Этот ответ относится к C ++ 03. Для других стандартов C ++ смотрите:
Что такое агрегаты и почему они особенные
Формальное определение из стандарта C ++ ( C ++ 03 8.5.1 §1 ) :
Агрегат - это массив или класс (раздел 9) без объявленных пользователем конструкторов (12.1), без закрытых или защищенных нестатических элементов данных (пункт 11), без базовых классов (пункт 10) и без виртуальных функций (10.3 ).
Итак, хорошо, давайте разберем это определение. Прежде всего, любой массив является агрегатом. Класс также может быть совокупным, если ... подождите! ничего не сказано о структурах или союзах, разве они не могут быть совокупностями? Да, они могут. В C ++ этот термин classотносится ко всем классам, структурам и объединениям. Таким образом, класс (или структура, или объединение) является совокупностью тогда и только тогда, когда он удовлетворяет критериям из приведенных выше определений. Что подразумевают эти критерии?
Это не означает, что агрегатный класс не может иметь конструкторов, фактически он может иметь конструктор по умолчанию и / или конструктор копирования, если они неявно объявлены компилятором, а не явно пользователем.
Нет частных или защищенных нестатических членов данных . Вы можете иметь столько приватных и защищенных функций-членов (но не конструкторов), сколько столько приватных или защищенных статических данных-членов и функций-членов, сколько вам нравится, и не нарушать правила для агрегатных классов.
Агрегатный класс может иметь объявленный пользователем / определенный пользователем оператор копирования и / или деструктор
Массив является агрегатом, даже если это массив неагрегированного типа класса.
Теперь давайте посмотрим на некоторые примеры:
class NotAggregate1
{
virtual void f() {} //remember? no virtual functions
};
class NotAggregate2
{
int x; //x is private by default and non-static
};
class NotAggregate3
{
public:
NotAggregate3(int) {} //oops, user-defined constructor
};
class Aggregate1
{
public:
NotAggregate1 member1; //ok, public member
Aggregate1& operator=(Aggregate1 const & rhs) {/* */} //ok, copy-assignment
private:
void f() {} // ok, just a private function
};
Вы поняли идею. Теперь посмотрим, насколько особенными являются агрегаты. Они, в отличие от неагрегированных классов, могут быть инициализированы с помощью фигурных скобок {}. Этот синтаксис инициализации обычно известен для массивов, и мы только что узнали, что это агрегаты. Итак, начнем с них.
Type array_name[n] = {a1, a2, …, am};
если (m == n)
i- й элемент массива инициализируется с помощью a i,
если (m <n)
первые m элементов массива инициализируются с помощью a 1 , a 2 ,…, a m и другихn - mэлементов если возможно, инициализируются значением (объяснение термина см. ниже),
иначе, если (m> n),
компилятор выдаст ошибку,
иначе (это случай, когда n вообще не задано, например int a[] = {1, 2, 3};)
размер массив (n) предполагается равным m, поэтомуint a[] = {1, 2, 3};эквивалентенint a[3] = {1, 2, 3};
Когда объект скалярного типа ( bool, int, char, double, указатели и т.д.) является значением инициализирован это означает , что она инициализируется 0для данного типа ( falseдля bool, 0.0для doubleи т.д.). Когда объект класса с объявленным пользователем конструктором по умолчанию инициализируется значением, вызывается его конструктор по умолчанию. Если конструктор по умолчанию неявно определен, то все нестатические члены рекурсивно инициализируются значением. Это определение неточное и немного неправильное, но оно должно дать вам основную идею. Ссылка не может быть инициализирована значением. Инициализация значения для неагрегированного класса может завершиться неудачей, если, например, у класса нет соответствующего конструктора по умолчанию.
Примеры инициализации массива:
class A
{
public:
A(int) {} //no default constructor
};
class B
{
public:
B() {} //default constructor available
};
int main()
{
A a1[3] = {A(2), A(1), A(14)}; //OK n == m
A a2[3] = {A(2)}; //ERROR A has no default constructor. Unable to value-initialize a2[1] and a2[2]
B b1[3] = {B()}; //OK b1[1] and b1[2] are value initialized, in this case with the default-ctor
int Array1[1000] = {0}; //All elements are initialized with 0;
int Array2[1000] = {1}; //Attention: only the first element is 1, the rest are 0;
bool Array3[1000] = {}; //the braces can be empty too. All elements initialized with false
int Array4[1000]; //no initializer. This is different from an empty {} initializer in that
//the elements in this case are not value-initialized, but have indeterminate values
//(unless, of course, Array4 is a global array)
int array[2] = {1, 2, 3, 4}; //ERROR, too many initializers
}
Теперь давайте посмотрим, как агрегатные классы могут быть инициализированы фигурными скобками. Примерно так же. Вместо элементов массива мы будем инициализировать нестатические элементы данных в порядке их появления в определении класса (все они по определению общедоступны). Если инициализаторов меньше, чем членов, остальные инициализируются значением. Если невозможно инициализировать значение одним из членов, которые не были явно инициализированы, мы получаем ошибку времени компиляции. Если инициализаторов больше, чем необходимо, мы также получаем ошибку во время компиляции.
struct X
{
int i1;
int i2;
};
struct Y
{
char c;
X x;
int i[2];
float f;
protected:
static double d;
private:
void g(){}
};
Y y = {'a', {10, 20}, {20, 30}};
В приведенном выше примере y.cинициализируется с 'a', y.x.i1с 10, y.x.i2с 20, y.i[0]с 20, y.i[1]с 30и y.fинициализируется значением, то есть инициализируется с 0.0. Защищенный статический член dвообще не инициализируется, потому что это так static.
Совокупные союзы отличаются тем, что вы можете инициализировать только их первого члена скобками. Я думаю, что если вы достаточно продвинуты в C ++, чтобы даже рассмотреть возможность использования союзов (их использование может быть очень опасным и должно быть тщательно продумано), вы можете сами найти правила для союзов в стандарте :).
Теперь, когда мы знаем, что особенного в агрегатах, давайте попробуем понять ограничения для классов; вот почему они там. Мы должны понимать, что инициализация для членов с фигурными скобками подразумевает, что класс является не чем иным, как суммой его членов. Если присутствует определяемый пользователем конструктор, это означает, что пользователю необходимо проделать дополнительную работу для инициализации членов, поэтому инициализация фигурной скобки будет неправильной. Если виртуальные функции присутствуют, это означает, что объекты этого класса имеют (в большинстве реализаций) указатель на так называемую vtable класса, который устанавливается в конструкторе, поэтому инициализация скобок будет недостаточной. Вы можете выяснить остальные ограничения так же, как упражнение :).
Так что хватит о агрегатах. Теперь мы можем определить более строгий набор типов, то есть POD
Что такое POD и почему они особенные
Формальное определение из стандарта C ++ ( C ++ 03 9 § 4 ) :
POD-структура - это агрегатный класс, который не имеет нестатических членов-данных типа non-POD-struct, non-POD-union (или массива таких типов) или ссылки, и не имеет никакого пользовательского оператора назначения копирования и не имеет пользовательский деструктор. Аналогично, POD-объединение - это совокупное объединение, которое не имеет нестатических членов-данных типа non-POD-struct, non-POD-union (или массива таких типов) или ссылки, и не имеет пользовательского оператора назначения копирования и нет определенного пользователем деструктора. POD-класс - это класс, который является POD-структурой или POD-объединением.
Вау, это сложнее разобрать, не так ли? :) Давайте оставим союзы (на тех же основаниях, что и выше) и перефразируем немного яснее:
Агрегатный класс называется POD, если у него нет определяемого пользователем оператора и деструктора копирования, и ни один из его нестатических членов не является классом без POD, массивом без POD или ссылкой.
Что означает это определение? (Я упоминал, что POD обозначает Простые Старые Данные ?)
- Все POD-классы являются агрегатами, или, другими словами, если класс не является агрегатом, то он точно не POD
- Классы, как и структуры, могут быть POD, даже если в обоих случаях стандартным термином является POD-структура.
- Как и в случае агрегатов, не имеет значения, какие статические члены в классе
Примеры:
struct POD
{
int x;
char y;
void f() {} //no harm if there's a function
static std::vector<char> v; //static members do not matter
};
struct AggregateButNotPOD1
{
int x;
~AggregateButNotPOD1() {} //user-defined destructor
};
struct AggregateButNotPOD2
{
AggregateButNotPOD1 arrOfNonPod[3]; //array of non-POD class
};
POD-классы, POD-объединения, скалярные типы и массивы таких типов вместе называются POD-типами.
POD являются особенными во многих отношениях. Я приведу только несколько примеров.
POD-классы наиболее близки к C-структурам. В отличие от них, POD могут иметь функции-члены и произвольные статические члены, но ни один из этих двух не меняет структуру памяти объекта. Поэтому, если вы хотите написать более или менее переносимую динамическую библиотеку, которую можно использовать из C и даже .NET, вы должны попытаться заставить все экспортируемые функции принимать и возвращать только параметры POD-типов.
Время жизни объектов класса не POD начинается, когда конструктор завершается, и заканчивается, когда деструктор завершает работу. Для классов POD время жизни начинается, когда хранилище для объекта занято, и заканчивается, когда это хранилище освобождается или используется повторно.
Для объектов типов POD по стандарту гарантируется, что когда вы memcpyпомещаете содержимое вашего объекта в массив char или unsigned char, а затем memcpyсодержимое обратно в ваш объект, объект будет сохранять свое первоначальное значение. Обратите внимание, что нет такой гарантии для объектов не POD-типов. Кроме того, вы можете безопасно копировать объекты POD с помощью memcpy. В следующем примере предполагается, что T является POD-типом:
#define N sizeof(T)
char buf[N];
T obj; // obj initialized to its original value
memcpy(buf, &obj, N); // between these two calls to memcpy,
// obj might be modified
memcpy(&obj, buf, N); // at this point, each subobject of obj of scalar type
// holds its original value
Перейти к заявлению. Как вы, возможно, знаете, это незаконно (компилятор должен выдать ошибку), чтобы сделать переход через goto из точки, где некоторая переменная еще не была в области видимости, до точки, где она уже находится в области видимости. Это ограничение применяется, только если переменная имеет тип не POD. В следующем примере f()плохо сформирован, тогда g()как хорошо сформирован. Обратите внимание, что компилятор Microsoft слишком либерален с этим правилом - он просто выдает предупреждение в обоих случаях.
int f()
{
struct NonPOD {NonPOD() {}};
goto label;
NonPOD x;
label:
return 0;
}
int g()
{
struct POD {int i; char c;};
goto label;
POD x;
label:
return 0;
}
Гарантируется, что в начале объекта POD не будет заполнения. Другими словами, если первый член POD-класса A имеет тип T, вы можете безопасно перейти reinterpret_castот и получить указатель на первый член и наоборот.A*T*
У этого списка нет конца…
Вывод
Важно понимать, что такое POD, потому что многие языковые функции, как вы видите, ведут себя по-разному для них.