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

非正式地:

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

不那么非正式:

int,char,wchar_t,bool,float,double是豆荚,因为是long/short和signed/unsigned他们的版本.

指针(包括指向函数的指针和指向成员的指针)是POD,

enums 是POD

一个const或volatile POD是POD.

一个class,struct或union荚果的是一个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-struct是一个聚合类,它没有非POD-struct类型的非静态数据成员,非POD-union(或这类类型的数组)或引用,并且没有用户 -定义复制操作符,没有用户定义的析构函数.类似地,POD-union是一个聚合联合,它没有非POD-struct,非POD-union(或这类类型的数组)或引用类型的非静态数据成员,并且没有用户定义的复制操作符,也没有用户定义的析构函数.

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
  struct is_pod
  : public integral_constant
  { };
}

(来自header type_traits)

参考:

http://en.cppreference.com/w/cpp/types/is_pod

http://en.wikipedia.org/wiki/Plain_old_data_structure

http://en.wikipedia.org/wiki/Plain_Old_C++_Object

文件type_traits

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

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

虚函数(自己的或继承的)

虚拟基类(直接或间接).

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

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

static_assert从C++ 11到C++ 17和POD效果的所有非POD案例的例子

std::is_pod 在C++ 11中添加了,所以让我们现在考虑标准.

std::is_pod将按照/sf/ask/17360801/中的说明从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++测试项目:https://softwareengineering.stackexchange.com/questions/199708/is-there-a-compliance-test-for-c-compilers

#include 
#include 
#include 

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(), "");
                    static_assert(!std::is_trivial(), "");
                    static_assert(!std::is_pod(), "");
                }

                // 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(), "");
                    static_assert(!std::is_trivial(), "");
                    static_assert(!std::is_pod(), "");
                }
            }

            // Not trivial because not trivially copyable.
            {
                struct C {
                    C(C&) {}
                };
                static_assert(!std::is_trivially_copyable(), "");
                static_assert(!std::is_trivial(), "");
                static_assert(!std::is_pod(), "");
            }
        }

        // 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(), "");
                    static_assert(!std::is_pod(), "");
                }

                // These have the same access control.
                {
                    struct C {
                        private:
                            int i;
                            int j;
                    };
                    static_assert(std::is_standard_layout(), "");
                    static_assert(std::is_pod(), "");

                    struct D {
                        public:
                            int i;
                            int j;
                    };
                    static_assert(std::is_standard_layout(), "");
                    static_assert(std::is_pod(), "");
                }
            }

            // Virtual function.
            {
                struct C {
                    virtual void f() = 0;
                };
                static_assert(!std::is_standard_layout(), "");
                static_assert(!std::is_pod(), "");
            }

            // Non-static member that is reference.
            {
                struct C {
                    int &i;
                };
                static_assert(!std::is_standard_layout(), "");
                static_assert(!std::is_pod(), "");
            }

            // 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(), "");
                    static_assert(!std::is_pod(), "");
                }

                // POD: has just one base class with non-static member.
                {
                    struct Base1 {
                        int i;
                    };
                    struct C : Base1 {};
                    static_assert(std::is_standard_layout(), "");
                    static_assert(std::is_pod(), "");
                }

                // 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(), "");
                    static_assert(std::is_pod(), "");
                }
            }

            // 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(), "");
                //static_assert(!std::is_pod(), "");
            };

            // 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(), "");
                    //static_assert(!std::is_pod(), "");
                }

                // 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(), "");
                    static_assert(!std::is_pod(), "");
                }

                // 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(), "");
            static_assert(std::is_pod(), "");
        }

        // Array of POD is POD.
        {
            struct C {};
            static_assert(std::is_pod(), "");
            static_assert(std::is_pod(), "");
        }

        // Private member: became POD in C++11
        // /sf/ask/17360801/#4762944
        {
            struct C {
                private:
                    int i;
            };
#if __cplusplus >= 201103L
            static_assert(std::is_pod(), "");
#else
            static_assert(!std::is_pod(), "");
#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.
        // /sf/ask/17360801/
        {
            static_assert(!std::is_pod>(), "");
            static_assert(!std::is_trivially_copyable>(), "");
            // Some might be though:
            // /sf/ask/17360801/
            static_assert(std::is_pod>(), "");
        }
    }

    // # 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:
    // /sf/ask/17360801/#4178176
    {
        struct Pod {
            uint32_t i;
            uint64_t j;
        };
        static_assert(std::is_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(), "");

        // __attribute__((packed)) only works for POD, and is ignored for non-POD, and emits a warning
        // /sf/ask/17360801/#52986680
        {
            struct C {
                int i;
            };

            struct D : C {
                int j;
            };

            struct E {
                D d;
            } /*__attribute__((packed))*/;

            static_assert(std::is_pod(), "");
            static_assert(!std::is_pod(), "");
            static_assert(!std::is_pod(), "");
        }
    }
#endif
}

for std in 11 14 17; do echo $std; g++-8 -Wall -Werror -Wextra -pedantic -std=c++$std pod.cpp; done