首页 文章

C中的POD类型是什么？

提问于
浏览 次
810

我曾几次遇到这个术语POD型 . 这是什么意思？

c++ types c++-faq

9 回答

  • 574

    对于C，Plain Old Data并不仅仅意味着像int，char等这样的东西是唯一使用的类型 . 普通的旧数据在实践中实际上意味着你可以将一个struct memcpy从内存中的一个位置转移到另一个位置，并且事情将完全像你期望的那样工作（即不会爆炸） . 如果您的类或您的类包含的任何类具有作为指针或引用的成员或具有虚函数的类，则会中断 . 基本上，如果指针必须涉及到某个地方，那么它不是普通旧数据 .

    回复于
  • 1

    非常非正式地：

    POD是一种类型（包括类），其中C编译器保证结构中不会出现“魔法”：例如，隐藏指向vtable的指针，在转换为其他类型时应用于地址的偏移量（至少如果目标的POD也是），构造函数或析构函数 . 粗略地说，类型是POD，当它中的唯一内容是内置类型和它们的组合时 . 结果是“像C”一样的行为 .

    非正式地：

    [0009_ int ， char ， wchar_t ， bool ， float ， double 是POD，它们的 long/short 和 signed/unsigned 版本也是如此 .

    • 指针（包括指向函数的指针和指向成员的指针）是POD，

    • enums 是POD

    • a const 或 volatile POD是POD .

    • a class ， struct 或 union 的POD是POD，前提是所有非静态数据成员都是 public ，并且它没有基类，也没有构造函数，析构函数或虚方法 . 静态成员不会根据此规则阻止某个POD . 此规则在C 11中已更改，并且允许某些私人成员：Can a class with all private members be a POD class?

    • 维基百科说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-struct类型的非静态数据成员，非POD-union（或此类型的数组）或引用，并且没有用户定义的复制操作符，也没有用户定义的析构函数 . 类似地，POD-union是一个聚合联合，它没有非POD-struct，非POD-union（或这类类型的数组）或引用类型的非静态数据成员，并且没有用户定义的复制操作符，也没有用户定义的析构函数.8.5.1（1）：“聚合是一个数组或类（第9节），没有用户声明的构造函数（12.1），没有私有或受保护的非静态数据成员（第11节），没有基础课程（第10条） d没有虚函数（10.3） . “

    回复于
  • -5

    POD代表普通旧数据 - 即没有构造函数，析构函数和虚拟成员函数的类（无论是使用关键字 struct 还是关键字 class 定义） . Wikipedia's article on POD进入更多细节并将其定义为：

    C中的普通旧数据结构是一个聚合类，它只包含PODS作为成员，没有用户定义的析构函数，没有用户定义的复制赋值运算符，也没有指向成员类型的非静态成员 .

    更多细节可以在this answer for C++98/03找到 . C 11改变了围绕POD的规则，大大放松了它们，因此necessitating a follow-up answer here .

    回复于
  • 10

    Examples of all non-POD cases with static_assert from C++11 to C++17 and POD effects

    在C 11中添加了 std::is_pod ，所以让我们暂时考虑标准 .

    如https://stackoverflow.com/a/48435532/895245所述， std::is_pod 将从C 20中移除，让我们在支持到达替换时更新 .

    随着标准的发展，POD限制变得越来越宽松，我的目标是通过ifdef覆盖示例中的所有放松 .

    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 testuite项目：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
}

    GitHub upstream .

    经测试：

    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上 .

    回复于
  • 8

    据我所知，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)>
  { };
}

    （来自header type_traits）

    参考：

    回复于
  • 3

    为什么我们需要区分POD和非POD？

    C作为C的延伸开始了它的生命 . 虽然现代C不再是C的严格超集，人们仍然期望高水平两者之间的兼容性 .

    粗略地说，POD类型是与C兼容的类型，并且可能同样重要的是与某些ABI优化兼容 .

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

    • 布局必须与相应的C类型相同 .

    • 类型必须以与相应C类型相同的方式传递给函数并从函数返回 .

    某些C功能与此不兼容 .

    虚方法要求编译器插入一个或多个指向虚方法表的指针，这些指针在C中不存在 .

    用户定义的复制构造函数，移动构造函数，复制赋值和析构函数对参数传递和返回有影响 . 许多C ABI在寄存器中传递和返回小参数，但传递给用户定义的构造函数/ assigment /析构函数的引用只能用于内存位置 .

    因此，需要定义哪些类型可以预期为“C兼容”，哪些类型不能 . 在这方面，C 03有点严格 . C 11打开了很多东西 .

    回复于
  • 15

    POD的概念和类型特征 std::is_pod 将在C 20中弃用 . 有关详细信息，请参阅this问题 .

    回复于
  • 302

    Plain Old Data

    简而言之，它是所有内置数据类型（例如 int ， char ， float ， long ， unsigned char ， double 等）以及POD数据的所有聚合 . 是的，这是一个递归定义 . ;）

    更清楚一点，POD就是我们所说的“结构”：一个单元或一组只存储数据的单元 .

    回复于
  • 4

    POD（普通旧数据）对象具有以下数据类型之一 - 基本类型，指针，联合，结构，数组或类 - 没有构造函数 . 相反，非POD对象是构造函数所在的对象 . POD对象在获得具有适当大小的存储的类型时开始其生命周期，并且当对象的存储被重用或取消分配时，其生命周期结束 .

    PlainOldData类型也不能包含以下任何内容：

    • 虚函数（自己的，或继承的）

    • 虚拟基类（直接或间接） .

    PlainOldData的更宽松定义包括具有构造函数的对象;但不包括虚拟的东西 . PlainOldData类型的重要问题是它们是非多态的 . 可以使用POD类型进行继承，但是它应该仅针对ImplementationInheritance（代码重用）而不是多态/子类型进行 .

    一个常见的（虽然不是严格正确的）定义是PlainOldData类型是没有VeeTable的任何东西 .

    回复于

相关问题