C ++ 中的 POD 类型是什么?

我已经多次遇到过这个术语 POD 类型。这是什么意思?

答案

POD代表普通旧数据 - 即不带构造函数,析构函数和虚拟成员函数的类(无论是使用关键字struct还是关键字class )。 Wikipedia 上有关 POD 的文章更加详细,并将其定义为:

C ++ 中的 Plain Old Data Structure 是一个聚合类,它仅包含 PODS 作为成员,没有用户定义的析构函数,没有用户定义的副本分配运算符,并且没有指针到成员类型的非静态成员。

C ++ 98/03 的答案中可以找到更多详细信息。 C ++ 11 更改了围绕 POD 的规则,大大放松了它们,因此需要在此处进行后续解答

非常非正式地:

POD 是一种类型(包括类),在这种类型中,C ++ 编译器保证结构中不会出现 “魔术” 现象:例如,指向 vtables 的隐藏指针,将其转换为其他类型时应用于地址的偏移量(至少是目标的 POD),构造函数或析构函数。粗略地说,当类型中的唯一内容是内置类型及其组合时,它就是 POD。结果是 “类似于” C 类型的行为。

非正式地:

  • intcharwchar_tboolfloatdouble是 POD, long/short和有signed/unsigned版本也是如此。
  • 指针(包括指向功能的指针和指向成员的指针)是 POD,
  • enums是 POD
  • constvolatile POD 是 POD。
  • POD 的classstructunion是 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)。”

原始数据

简而言之,它是所有内置数据类型(例如, intcharfloatlongunsigned chardouble等)以及 POD 数据的所有聚合。是的,这是一个递归定义。 ;)

更清楚地说,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)>
  { };
}

POD(普通旧数据)对象具有以下数据类型之一(基本类型,指针,联合,结构,数组或类),而没有构造函数。相反,非 POD 对象是为其构造函数的对象。 POD 对象在获得具有适合其类型的大小的存储空间时开始其生命周期,而当该对象的存储空间被重新使用或释放时,其生命周期结束。

PlainOldData 类型也不得具有以下任何一种:

  • 虚函数(自己的或继承的)
  • 虚拟基类(直接或间接)。

对 PlainOldData 的较宽松定义包括带有构造函数的对象。但排除具有虚拟事物的人。 PlainOldData 类型的重要问题是它们是非多态的。可以使用 POD 类型进行继承,但是仅应对 ImplementationInheritance(代码重用)进行继承,而不应对多态性 / 子类型进行继承。

一个常见的(尽管不是严格正确的)定义是 PlainOldData 类型是没有 VeeTable 的任何类型。

#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

为什么我们需要完全区分 POD 和非 POD?

C ++ 作为 C 的扩展而开始其生命。尽管现代 C ++ 不再是 C 的严格超集,但人们仍然期望两者之间具有高度的兼容性。

粗略地说,POD 类型是与 C 兼容的类型,也许同样重要的是与某些 ABI 优化兼容的类型。

为了与 C 兼容,我们需要满足两个约束。

  1. 布局必须与相应的 C 类型相同。
  2. 该类型必须以与对应的 C 类型相同的方式传递给函数并从函数返回。

某些 C ++ 功能与此不兼容。

虚拟方法要求编译器插入一个或多个指向虚拟方法表的指针,这在 C 语言中是不存在的。

用户定义的副本构造函数,移动构造函数,副本分配和析构函数对参数的传递和返回有影响。许多 C ABI 在寄存器中传递并返回较小的参数,但是传递给用户定义的构造函数 / 辅助函数 / 析构函数的引用只能与内存位置一起使用。

因此,需要定义哪些类型可以期望是 “C 兼容的”,哪些类型不能。在这方面,C ++ 03 有点过分严格,任何用户定义的构造函数都将禁用内置的构造函数,而任何将它们添加回的尝试都将导致它们是用户定义的,因此类型为非 Pod。通过允许用户重新引入内置构造函数,C ++ 11 大大提高了性能。

POD 的概念和类型特征std::is_pod在 C ++ 20 中将被弃用。有关更多信息,请参见此问题。

使用 C ++ 时,Plain Old Data 不仅意味着 int,char 等是唯一使用的类型。普通的旧数据实际上意味着在实践中,您可以将其从内存中的一个位置转移到另一位置,并且事情将按预期运行(即不会崩溃)。如果您的类或您的类包含的任何类的成员是指针,引用或具有虚函数的类,则这会中断。本质上,如果必须将指针包含在某个地方,则它不是普通的旧数据。