I got what POD means, and I know that when I declare a structure in C++ as
struct f {};
there's a default constructor, a default copy constructor, a default destructor, etc.. (if I got this correctly)
My question is: how can I declare a POD structure with just plain data (like 4 int values) without implicit constructors/destructors/etc.. getting in the way?
Did I miss something?
Every object type has a constructor—else how would you construct it?—and a destructor—else how would it be destroyed? They don’t “get in the way” of anything, because the default implementations are no-ops in the case of POD-only fields, just as if you had said:
struct f {
f() {}
~f() {}
int a, b, c, d;
};
However, if you write an empty constructor, the type becomes non-POD. C++11 solves this with defaulting:
f() = default;
~f() = default;
The situation is slightly different with copy constructors, where the implicitly generated one is just a convenience that does “the right thing” for POD types:
f(const f& other) : a(other.a), b(other.b), c(other.c), d(other.d) {}
There is no reason to rewrite this yourself. If you want to make a type noncopyable, you can mark the copy constructor as deleted with f(const f&) = delete; or declare it private.
It’s also important to note that member functions are not stored on the object as member variables are. You can think of a class or struct as simultaneously two things:
A description of a data layout
A namespace containing functions and types for manipulating that data
The C++ model of object-oriented programming simply couples these two things in one place.
how can I declare a POD structure with just plain data (like 4 int values) without implicit constructors/destructors/etc.. getting in the way?
Like this:
struct f {
int i1, i2, i3, i4;
};
Compiler-generated constructors don't get in the way of it being a POD.
10) A POD struct109 is a non-union class that is both a trivial class and a standard-layout class, and has no non-static data members of type non-POD struct, non-POD union (or array of such types). Similarly, a POD union is a union that is both a trivial class and a standard layout class, and has no non-static data members of type non-POD struct, non-POD union (or array of such types). A POD class is a class that is either a POD struct or a POD union.
So, it has to be
a) A trivial class and
b) A standard-layout class.
which are described below:
7) A standard-layout class is a class that:
— has no non-static data members of type non-standard-layout class (or array of such types) or reference,
— has no virtual functions (10.3) and no virtual base classes (10.1),
— has the same access control (Clause 11) for all non-static data members,
— has no non-standard-layout base classes,
— either has no non-static data members in the most derived class and at most one base class with
non-static data members, or has no base classes with non-static data members, and
— has no base classes of the same type as the first non-static data member.
and
6) [...] A trivial class is a class that has a trivial default constructor (12.1) and is trivially copyable
Detailed in:
5) [...]A default constructor is trivial if it is not user-provided and if:
— its class has no virtual functions (10.3) and no virtual base classes (10.1), and
— no non-static data member of its class has a brace-or-equal-initializer, and
— all the direct base classes of its class have trivial default constructors, and
— for all the non-static data members of its class that are of class type (or array thereof), each such class has a trivial default constructor.
As all conditions above apply, the class is a POD.
Firstly, all these implicit member function exist only conceptually. The don't really affect anything until you actually attempt to use them. This means that they should not be "getting in the way" if you don't want them to.
Secondly, non-virtual member functions (regardless of whether they are explicitly declared or not) have no effect on data layout of the class. I.e. they are not "getting in the way" in that regard (if that's what you meant).
Yes, the definition of POD explicitly excludes the implicitly generated special member functions. It gets trickier if you specify one of them that does exactly the same as the default generated one: Your type is no longer POD. In C++11 this problem is solved with the default keyword.
With all this, the definition of a POD is (usually) just the same as you would have in C code:
struct X { int a, b, c, d; };
