Was sind POD-Typen in C ++?

Ich bin ein paar Mal auf diesen Begriff POD-Typ gestoßen.
Was bedeutet das?

POD steht für Plain Old Data - eine Klasse (ob mit dem Schlüsselwort structoder dem Schlüsselwort definiert class) ohne Konstruktoren, Destruktoren und Funktionen für virtuelle Mitglieder. Der Wikipedia-Artikel über POD geht etwas detaillierter vor und definiert ihn als:

Eine einfache alte Datenstruktur in C ++ ist eine Aggregatklasse, die nur PODS als Mitglieder enthält, keinen benutzerdefinierten Destruktor, keinen benutzerdefinierten Kopierzuweisungsoperator und keine nicht statischen Elemente vom Typ Zeiger auf Mitglied hat.

Weitere Details finden Sie in dieser Antwort für C ++ 98/03 . C ++ 11 hat die Regeln für POD geändert und stark gelockert, sodass hier eine Antwort erforderlich ist .

Sehr informell:

Ein POD ist ein Typ (einschließlich Klassen), bei dem der C ++ - Compiler garantiert, dass in der Struktur keine "Magie" stattfindet: zum Beispiel versteckte Zeiger auf vtables, Offsets, die auf die Adresse angewendet werden, wenn sie in andere Typen umgewandelt wird ( Zumindest wenn auch der POD des Ziels), Konstruktoren oder Destruktoren. Grob gesagt ist ein Typ ein POD, wenn die einzigen darin enthaltenen Dinge eingebaute Typen und Kombinationen davon sind. Das Ergebnis ist etwas, das sich wie ein C-Typ "verhält".

Weniger informell:

• int, char, wchar_t, bool, float, doubleSind PODs, wie sind long/shortund signed/unsignedVersionen davon.
• Zeiger (einschließlich Zeiger auf Funktion und Zeiger auf Mitglied) sind PODs,
• enums sind PODs
• a constoder volatilePOD ist ein POD.
• a class, structoder unionvon Hohlkörpern ist ein POD vorausgesetzt , dass alle nicht-statische Datenelemente sind public, und es hat keine Basisklasse und keine Konstruktoren, Destruktoren oder virtuelle Methoden. Statische Mitglieder hören nach dieser Regel nicht auf, dass etwas ein POD ist. Diese Regel hat sich in C ++ 11 geändert und bestimmte private Mitglieder sind zulässig: Kann eine Klasse mit allen privaten Mitgliedern eine POD-Klasse sein?
• Wikipedia ist falsch zu sagen, dass ein POD keine Mitglieder vom Typ Zeiger auf Mitglied haben kann. Oder besser gesagt, es ist korrekt für den C ++ 98-Wortlaut, aber TC1 hat deutlich gemacht, dass Zeiger auf Mitglieder POD sind.

Formal (C ++ 03 Standard):

3.9 (10): "Arithmetische Typen (3.9.1), Aufzählungstypen, Zeigertypen und Zeiger auf Elementtypen (3.9.2) und cv-qualifizierte Versionen dieser Typen (3.9.3) sind kollektiv aufrufende Skalartypen. Skalar Typen, POD-Strukturtypen, POD-Vereinigungstypen (Abschnitt 9), Arrays solcher Typen und cv-qualifizierte Versionen dieser Typen (3.9.3) werden zusammen als POD-Typen bezeichnet. "

9 (4): "Eine POD-Struktur ist eine Aggregatklasse, die keine nicht statischen Datenelemente vom Typ Nicht-POD-Struktur, Nicht-POD-Vereinigung (oder Array solcher Typen) oder Referenz hat und keine Benutzer- hat. Definieren Sie einen Kopieroperator und keinen benutzerdefinierten Destruktor. In ähnlicher Weise ist eine POD-Vereinigung eine aggregierte Vereinigung, die keine nicht statischen Datenelemente vom Typ Nicht-POD-Struktur, Nicht-POD-Vereinigung (oder Array solcher Typen) oder Referenz enthält. und hat keinen benutzerdefinierten Kopieroperator und keinen benutzerdefinierten Destruktor.

8.5.1 (1): "Ein Aggregat ist ein Array oder eine Klasse (Klausel 9) ohne vom Benutzer deklarierte Konstruktoren (12.1), ohne private oder geschützte nicht statische Datenelemente (Klausel 11), ohne Basisklassen (Klausel 10). und keine virtuellen Funktionen (10.3). "

Einfache alte Daten

Kurz gesagt, ist es alle eingebauten Datentypen (zB int, char, float, long, unsigned char, double, etc.) und alle Aggregation von POD - Daten. Ja, es ist eine rekursive Definition. ;)

Um es klarer zu machen, ein POD ist das, was wir "eine Struktur" nennen: eine Einheit oder eine Gruppe von Einheiten, die nur Daten speichern.

Soweit ich weiß, handelt es sich bei POD (PlainOldData) nur um Rohdaten, die nicht benötigt werden:

• gebaut werden,
• zerstört sein,
• benutzerdefinierte Operatoren zu haben.
• Darf keine virtuellen Funktionen haben,
• und darf Operatoren nicht überschreiben.

Wie überprüfe ich, ob etwas ein POD ist? Nun, dafür gibt es eine Struktur namens 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)>
  { };
}

(Aus dem Header type_traits)

Referenz:

• 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
• Dateityp_traits

Ein POD-Objekt (Plain Old Data) hat einen dieser Datentypen - einen Grundtyp, einen Zeiger, eine Vereinigung, eine Struktur, ein Array oder eine Klasse - ohne Konstruktor. Umgekehrt ist ein Nicht-POD-Objekt eines, für das ein Konstruktor existiert. Ein POD-Objekt beginnt seine Lebensdauer, wenn es Speicher mit der richtigen Größe für seinen Typ erhält, und seine Lebensdauer endet, wenn der Speicher für das Objekt entweder wiederverwendet oder freigegeben wird.

PlainOldData-Typen dürfen außerdem keine der folgenden Eigenschaften haben:

• Virtuelle Funktionen (entweder eigene oder geerbte)
• Virtuelle Basisklassen (direkt oder indirekt).

Eine lockerere Definition von PlainOldData enthält Objekte mit Konstruktoren. schließt aber diejenigen mit virtuellem irgendetwas aus. Das wichtige Problem bei PlainOldData-Typen ist, dass sie nicht polymorph sind. Die Vererbung kann mit POD-Typen erfolgen, sollte jedoch nur für ImplementationInheritance (Wiederverwendung von Code) und nicht für Polymorphismus / Subtypisierung erfolgen.

Eine übliche (wenn auch nicht streng korrekte) Definition ist, dass ein PlainOldData-Typ alles ist, was keine VeeTable hat.

Warum müssen wir überhaupt zwischen PODs und Nicht-PODs unterscheiden?

C ++ begann sein Leben als Erweiterung von C. Während modernes C ++ keine strikte Obermenge von C mehr ist, erwarten die Leute immer noch ein hohes Maß an Kompatibilität zwischen beiden.

Grob gesagt ist ein POD-Typ ein Typ, der mit C kompatibel ist und vielleicht ebenso wichtig mit bestimmten ABI-Optimierungen kompatibel ist.

Um mit C kompatibel zu sein, müssen wir zwei Bedingungen erfüllen.

1. Das Layout muss mit dem entsprechenden C-Typ übereinstimmen.
2. Der Typ muss auf dieselbe Weise wie der entsprechende C-Typ an Funktionen übergeben und von diesen zurückgegeben werden.

Bestimmte C ++ - Funktionen sind damit nicht kompatibel.

Bei virtuellen Methoden muss der Compiler einen oder mehrere Zeiger auf virtuelle Methodentabellen einfügen, was in C nicht vorhanden ist.

Benutzerdefinierte Kopierkonstruktoren, Verschiebungskonstruktoren, Kopierzuweisungen und Destruktoren haben Auswirkungen auf die Übergabe und Rückgabe von Parametern. Viele C-ABIs übergeben und geben kleine Parameter in Registern zurück, aber die an den benutzerdefinierten Konstruktor / Zuweisung / Destruktor übergebenen Referenzen können nur mit Speicherorten arbeiten.

Es muss also definiert werden, welche Typen voraussichtlich "C-kompatibel" sind und welche nicht. C ++ 03 war in dieser Hinsicht etwas zu streng. Jeder benutzerdefinierte Konstruktor würde die integrierten Konstruktoren deaktivieren, und jeder Versuch, sie wieder hinzuzufügen, würde dazu führen, dass sie benutzerdefiniert sind und der Typ daher kein Pod ist. C ++ 11 hat die Dinge ziemlich geöffnet, indem es dem Benutzer ermöglicht hat, die integrierten Konstruktoren erneut einzuführen.

Beispiele für alle Nicht-POD-Fälle mit static_assertC ++ 11 bis C ++ 17 und POD-Effekten

std::is_pod wurde in C ++ 11 hinzugefügt, also betrachten wir diesen Standard erst einmal.

std::is_podwird aus C ++ 20 entfernt, wie unter https://stackoverflow.com/a/48435532/895245 erwähnt. Aktualisieren wir dies, sobald die Unterstützung für die Ersetzungen eintrifft.

POD-Einschränkungen wurden mit der Entwicklung des Standards immer lockerer. Ich möchte alle Relaxationen im Beispiel durch ifdefs abdecken.

libstdc ++ hat einige Tests unter: https://github.com/gcc-mirror/gcc/blob/gcc-8_2_0-release/libstdc%2B%2B-v3/testsuite/20_util/is_pod/value.cc aber es einfach zu wenig. Betreuer: Bitte führen Sie dies zusammen, wenn Sie diesen Beitrag lesen. Ich bin faul, alle C ++ - Testsuite-Projekte zu überprüfen, die unter /software/199708/is-there-a-compliance-test-for-c-compilers erwähnt werden

#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
        // /programming/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.
        // /programming/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:
            // /programming/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:
    // /programming/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
        // /programming/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 stromaufwärts .

Getestet mit:

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

unter Ubuntu 18.04, GCC 8.2.0.

Das Konzept von POD und das Typmerkmal std::is_podwerden in C ++ 20 nicht mehr unterstützt. Weitere Informationen finden Sie in dieser Frage.

In C ++ bedeutet "Einfache alte Daten" nicht nur, dass nur Dinge wie "int", "char" usw. verwendet werden. Einfache alte Daten bedeuten in der Praxis wirklich, dass Sie eine Struktur von einem Speicherort zum anderen speichern können und die Dinge genau so funktionieren, wie Sie es erwarten würden (dh nicht explodieren). Dies bricht ab, wenn Ihre Klasse oder eine Klasse, die Ihre Klasse enthält, als Mitglied einen Zeiger oder eine Referenz oder eine Klasse mit einer virtuellen Funktion hat. Wenn Zeiger irgendwo beteiligt sein müssen, handelt es sich im Wesentlichen nicht um einfache alte Daten.