Что такое типы POD в C++?
https://stackoverflow.com/questions/146452
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Я встречал этот термин POD-тип несколько раз.Что это значит?
Решение
ПОД означает Обычные старые данные - то есть класс (независимо от того, определен ли он с помощью ключевого слова struct или ключевое слово class) без конструкторов, деструкторов и функций виртуальных членов. Статья в Википедии о POD более подробно и определяет это как:
Простая старая структура данных в C++ — это агрегатный класс, который содержит только PODS в качестве членов, не имеет определяемого пользователем деструктора, определяемого пользователем оператора присваивания копирования и нестатических членов типа указатель на член.
Более подробную информацию можно найти в этот ответ для С++ 98/03.C++11 изменил правила, касающиеся POD, значительно их ослабив, таким образом здесь требуется дополнительный ответ.
Другие советы
Очень неформально:
POD — это тип (включая классы), в котором компилятор C++ гарантирует, что в структуре не будет происходить никакой «магии»:например, скрытые указатели на виртуальные таблицы, смещения, которые применяются к адресу, когда он приводится к другим типам (по крайней мере, если целевой POD тоже), конструкторы или деструкторы.Грубо говоря, тип — это POD, если в нем есть только встроенные типы и их комбинации.В результате получается нечто, «действующее как» тип C.
Менее неформально:
int,char,wchar_t,bool,float,doubleявляются POD, как иlong/shortиsigned/unsignedих версии.- указатели (включая указатель на функцию и указатель на член) — это POD,
enumsявляются POD- а
constилиvolatileПОД - это ПОД. - а
class,structилиunionPOD является POD при условии, что все нестатические элементы данныхpublic, и у него нет базового класса, конструкторов, деструкторов или виртуальных методов.Статические члены не перестают быть POD в соответствии с этим правилом.Это правило изменилось в C++11, и разрешены некоторые частные члены: Может ли класс со всеми закрытыми членами быть классом POD? - Википедия ошибается, утверждая, что POD не может иметь членов типа «указатель на член».Вернее, это правильно для формулировки C++98, но TC1 ясно указал, что указателями на члены являются POD.
Формально (стандарт C++03):
3.9(10): «Арифметические типы (3.9.1), типы перечисления, типы указателей и указатели на типы членов (3.9.2) и версии этих типов с указанием cv (3.9.3) являются скалярными типами вызывающего объекта.Скалярные типы, типы структур POD, типы объединения POD (раздел 9), массивы таких типов и версии этих типов с указанием cv (3.9.3) вместе называются типами POD».
9(4): «POD-структура — это агрегатный класс, который не имеет нестатических элементов данных типа, отличного от POD-структуры, не-POD-объединения (или массива таких типов) или ссылки, а также не имеет определяемого пользователем оператора копирования и не имеет определяемый пользователем деструктор.Аналогичным образом, POD-объединение — это агрегатное объединение, которое не имеет нестатических элементов данных типа, отличного от POD-структуры, не-POD-объединения (или массива таких типов) или ссылки, а также не имеет определяемого пользователем оператора копирования и не имеет определяемый пользователем деструктор.
8.5.1(1): «Агрегат — это массив или класс (пункт 9) без объявленных пользователем конструкторов (12.1), без частных или защищенных нестатических элементов данных (пункт 11), без базовых классов (пункт 10) и без виртуальных функций (10.3). ."
Короче говоря, это все встроенные типы данных (например. int, char, float, long, unsigned char, double, и т. д.) и все агрегирование данных POD.Да, это рекурсивное определение.;)
Чтобы быть более понятным, POD — это то, что мы называем «структурой»:единица или группа единиц, которые просто хранят данные.
Насколько я понимаю, POD (PlainOldData) — это просто сырые данные — ему не нужно:
- быть построенным,
- быть уничтоженным,
- иметь собственные операторы.
- Не должно быть виртуальных функций,
- и не должен переопределять операторы.
Как проверить, является ли что-то POD?Ну, для этого есть структура под названием std::is_pod:
namespace std {
// Could use is_standard_layout && is_trivial instead of the builtin.
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };
}
(Из заголовка type_traits)
Ссылка:
Объект POD (простые старые данные) имеет один из этих типов данных — фундаментальный тип, указатель, объединение, структуру, массив или класс — без конструктора.И наоборот, объект, не относящийся к POD, — это объект, для которого существует конструктор.Объект POD начинает свое существование, когда он получает хранилище соответствующего размера для своего типа, и его время жизни заканчивается, когда хранилище для объекта повторно используется или освобождается.
Типы PlainOldData также не должны иметь:
- Виртуальные функции (собственные или унаследованные)
- Виртуальные базовые классы (прямые или косвенные).
Более свободное определение PlainOldData включает объекты с конструкторами;но исключает тех, у кого есть что-либо виртуальное.Важная проблема с типами PlainOldData заключается в том, что они не являются полиморфными.Наследование может осуществляться с помощью типов POD, однако его следует выполнять только для ImplementationInheritance (повторное использование кода), а не для полиморфизма/подтипирования.
Распространенное (хотя и не совсем правильное) определение состоит в том, что тип PlainOldData — это все, что не имеет VeeTable.
Примеры всех случаев, не связанных с POD, с static_assert от C++11 до C++17 и эффекты POD
std::is_pod был добавлен в C++11, поэтому давайте пока рассмотрим этот стандарт.
std::is_pod будет удален из C++20, как указано в https://stackoverflow.com/a/48435532/895245 , давайте обновим это по мере поступления поддержки для замен.
Ограничения POD становились все более и более смягченными по мере развития стандарта. Я стремлюсь охватить все ослабления в примере с помощью ifdefs.
libstdc++ имеет небольшое тестирование: https://github.com/gcc-mirror/gcc/blob/gcc-8_2_0-release/libstdc%2B%2B-v3/testsuite/20_util/is_pod/value.cc но этого слишком мало.Сопровождающие:пожалуйста, объедините это, если вы читаете этот пост.Мне лениво проверять все проекты тестовых наборов C++, упомянутые в: https://softwareengineering.stackexchange.com/questions/199708/is-there-a-compliance-test-for-c-compilers
#include <type_traits>
#include <array>
#include <vector>
int main() {
#if __cplusplus >= 201103L
// # Not POD
//
// Non-POD examples. Let's just walk all non-recursive non-POD branches of cppreference.
{
// Non-trivial implies non-POD.
// https://en.cppreference.com/w/cpp/named_req/TrivialType
{
// Has one or more default constructors, all of which are either
// trivial or deleted, and at least one of which is not deleted.
{
// Not trivial because we removed the default constructor
// by using our own custom non-default constructor.
{
struct C {
C(int) {}
};
static_assert(std::is_trivially_copyable<C>(), "");
static_assert(!std::is_trivial<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
// No, this is not a default trivial constructor either:
// https://en.cppreference.com/w/cpp/language/default_constructor
//
// The constructor is not user-provided (i.e., is implicitly-defined or
// defaulted on its first declaration)
{
struct C {
C() {}
};
static_assert(std::is_trivially_copyable<C>(), "");
static_assert(!std::is_trivial<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
}
// Not trivial because not trivially copyable.
{
struct C {
C(C&) {}
};
static_assert(!std::is_trivially_copyable<C>(), "");
static_assert(!std::is_trivial<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
}
// Non-standard layout implies non-POD.
// https://en.cppreference.com/w/cpp/named_req/StandardLayoutType
{
// Non static members with different access control.
{
// i is public and j is private.
{
struct C {
public:
int i;
private:
int j;
};
static_assert(!std::is_standard_layout<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
// These have the same access control.
{
struct C {
private:
int i;
int j;
};
static_assert(std::is_standard_layout<C>(), "");
static_assert(std::is_pod<C>(), "");
struct D {
public:
int i;
int j;
};
static_assert(std::is_standard_layout<D>(), "");
static_assert(std::is_pod<D>(), "");
}
}
// Virtual function.
{
struct C {
virtual void f() = 0;
};
static_assert(!std::is_standard_layout<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
// Non-static member that is reference.
{
struct C {
int &i;
};
static_assert(!std::is_standard_layout<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
// Neither:
//
// - has no base classes with non-static data members, or
// - has no non-static data members in the most derived class
// and at most one base class with non-static data members
{
// Non POD because has two base classes with non-static data members.
{
struct Base1 {
int i;
};
struct Base2 {
int j;
};
struct C : Base1, Base2 {};
static_assert(!std::is_standard_layout<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
// POD: has just one base class with non-static member.
{
struct Base1 {
int i;
};
struct C : Base1 {};
static_assert(std::is_standard_layout<C>(), "");
static_assert(std::is_pod<C>(), "");
}
// Just one base class with non-static member: Base1, Base2 has none.
{
struct Base1 {
int i;
};
struct Base2 {};
struct C : Base1, Base2 {};
static_assert(std::is_standard_layout<C>(), "");
static_assert(std::is_pod<C>(), "");
}
}
// Base classes of the same type as the first non-static data member.
// TODO failing on GCC 8.1 -std=c++11, 14 and 17.
{
struct C {};
struct D : C {
C c;
};
//static_assert(!std::is_standard_layout<C>(), "");
//static_assert(!std::is_pod<C>(), "");
};
// C++14 standard layout new rules, yay!
{
// Has two (possibly indirect) base class subobjects of the same type.
// Here C has two base classes which are indirectly "Base".
//
// TODO failing on GCC 8.1 -std=c++11, 14 and 17.
// even though the example was copy pasted from cppreference.
{
struct Q {};
struct S : Q { };
struct T : Q { };
struct U : S, T { }; // not a standard-layout class: two base class subobjects of type Q
//static_assert(!std::is_standard_layout<U>(), "");
//static_assert(!std::is_pod<U>(), "");
}
// Has all non-static data members and bit-fields declared in the same class
// (either all in the derived or all in some base).
{
struct Base { int i; };
struct Middle : Base {};
struct C : Middle { int j; };
static_assert(!std::is_standard_layout<C>(), "");
static_assert(!std::is_pod<C>(), "");
}
// None of the base class subobjects has the same type as
// for non-union types, as the first non-static data member
//
// TODO: similar to the C++11 for which we could not make a proper example,
// but with recursivity added.
// TODO come up with an example that is POD in C++14 but not in C++11.
}
}
}
// # POD
//
// POD examples. Everything that does not fall neatly in the non-POD examples.
{
// Can't get more POD than this.
{
struct C {};
static_assert(std::is_pod<C>(), "");
static_assert(std::is_pod<int>(), "");
}
// Array of POD is POD.
{
struct C {};
static_assert(std::is_pod<C>(), "");
static_assert(std::is_pod<C[]>(), "");
}
// Private member: became POD in C++11
// https://stackoverflow.com/questions/4762788/can-a-class-with-all-private-members-be-a-pod-class/4762944#4762944
{
struct C {
private:
int i;
};
#if __cplusplus >= 201103L
static_assert(std::is_pod<C>(), "");
#else
static_assert(!std::is_pod<C>(), "");
#endif
}
// Most standard library containers are not POD because they are not trivial,
// which can be seen directly from their interface definition in the standard.
// https://stackoverflow.com/questions/27165436/pod-implications-for-a-struct-which-holds-an-standard-library-container
{
static_assert(!std::is_pod<std::vector<int>>(), "");
static_assert(!std::is_trivially_copyable<std::vector<int>>(), "");
// Some might be though:
// https://stackoverflow.com/questions/3674247/is-stdarrayt-s-guaranteed-to-be-pod-if-t-is-pod
static_assert(std::is_pod<std::array<int, 1>>(), "");
}
}
// # POD effects
//
// Now let's verify what effects does PODness have.
//
// Note that this is not easy to do automatically, since many of the
// failures are undefined behaviour.
//
// A good initial list can be found at:
// https://stackoverflow.com/questions/4178175/what-are-aggregates-and-pods-and-how-why-are-they-special/4178176#4178176
{
struct Pod {
uint32_t i;
uint64_t j;
};
static_assert(std::is_pod<Pod>(), "");
struct NotPod {
NotPod(uint32_t i, uint64_t j) : i(i), j(j) {}
uint32_t i;
uint64_t j;
};
static_assert(!std::is_pod<NotPod>(), "");
// __attribute__((packed)) only works for POD, and is ignored for non-POD, and emits a warning
// https://stackoverflow.com/questions/35152877/ignoring-packed-attribute-because-of-unpacked-non-pod-field/52986680#52986680
{
struct C {
int i;
};
struct D : C {
int j;
};
struct E {
D d;
} /*__attribute__((packed))*/;
static_assert(std::is_pod<C>(), "");
static_assert(!std::is_pod<D>(), "");
static_assert(!std::is_pod<E>(), "");
}
}
#endif
}
Протестировано с:
for std in 11 14 17; do echo $std; g++-8 -Wall -Werror -Wextra -pedantic -std=c++$std pod.cpp; done
в Ubuntu 18.04, GCC 8.2.0.
Понятие POD и типовая черта std::is_pod будет считаться устаревшим в C++20.Видеть этот вопрос для получения дополнительной информации.
Почему нам вообще нужно различать POD и не-POD?
C++ начал свою жизнь как расширение C.Хотя современный C++ больше не является строгой расширенной версией C, люди по-прежнему ожидают высокого уровня совместимости между ними.
Грубо говоря, тип POD — это тип, который совместим с C и, что не менее важно, совместим с определенными оптимизациями ABI.
Чтобы быть совместимым с C, нам необходимо удовлетворить два ограничения.
- Расположение должно быть таким же, как у соответствующего типа C.
- Тип должен передаваться в функции и возвращаться из них так же, как соответствующий тип C.
Некоторые функции C++ с этим несовместимы.
Виртуальные методы требуют, чтобы компилятор вставил один или несколько указателей на таблицы виртуальных методов, чего нет в C.
Пользовательские конструкторы копирования, конструкторы перемещения, присваивания копий и деструкторы влияют на передачу и возврат параметров.Многие C ABI передают и возвращают небольшие параметры в регистрах, но ссылки, передаваемые в определенный пользователем конструктор/назначение/деструктор, могут работать только с ячейками памяти.
Поэтому необходимо определить, какие типы могут быть «C-совместимыми», а какие нет.C++03 в этом отношении был несколько чрезмерно строгим.C++11 многое открыл.
В C++ Plain Old Data не просто означает, что используются только такие типы, как int, char и т. д.На практике Plain Old Data на самом деле означает, что вы можете перенести структуру memcpy из одного места памяти в другое, и все будет работать именно так, как вы ожидаете (т. е.не взорваться).Это нарушается, если ваш класс или любой класс, который содержит ваш класс, имеет в качестве члена указатель или ссылку или класс, который имеет виртуальную функцию.По сути, если где-то и должны быть задействованы указатели, то это не Plain Old Data.
