why does default constructor being outside class or inside class make a difference in whether the class is POD?

In the following code, why is POD considered POD while notPOD considered not POD? The only difference between them is whether the definition for defaulted default constructor is placed inside or outside the class. I always thought that both do the same thing but it's apparently not the case.

#include <iostream>
struct POD {
    POD() = default;
};
struct notPOD {
    notPOD();
};
notPOD::notPOD() = default;
int main() {
    std::cout << std::boolalpha << std::is_pod<POD>() << ' ' << std::is_pod<notPOD>() << '\n';
}

First, the term "POD type" is out-dated and std::is_pod is deprecated since C++20. The concept has been separated into multiple more specific concepts that are more applicable to specific behaviors one expects of a POD type. In particular the new concepts are trivial types and standard-layout types.

The issue in your question is whether the class is trivial. A class is trivial if it is trivially-copyable and has at least one eligible default constructor and all such constructors are trivial.

A default constructor is trivial only if it, informally speaking, "doesn't do anything", and it is not user-provided. In your example the default constructor doesn't do anything in either case, but it is not user-provided in the first example, while it is in the second one. A constructor is user-provided if it is not implicitly-declared (i.e. the user has actually written its declaration) and it is not defaulted on its first declaration, i.e. inside the class, which is the difference between your two examples.

The reason for this rule is that all translation units must agree on whether or not the default constructor and the class are trivial. There are language rules attached to this type trait that must not be different in different translation units.

If the constructor is defaulted inside the class, then all translation units must agree on that, because a translation unit which has the definition of the class must also have the constructor defaulted in its declaration. Definitions of classes in different translation units must be token-identical, otherwise the definitions would violate the one-definition rule and the program wouldn't be valid.

If you default the constructor outside the class, then only the one translation unit with the defaulted constructor will see it. Another translation unit may include the class definition, but does not need to include the defaulted definition of the constructor and so it may not know that it is defaulted. Then it is impossible to say whether the constructor is user-provided in every translation unit and in particular the other translation unit may not know whether the constructor actually "doesn't do anything". So it can't be considered trivial.

In other words, the trait must depend only on the class definition in order to be consistent between translation units. It can't depend on additional declarations after the class definition. So, the rule is that such a constructor and class are not trivial.

TLDR;

> why is POD considered POD while notPOD considered not POD?

Because the constructor notPOD::notPOD() is not defaulted in its first declaration which means notPOD has a user-provided constructor implying that notPOD has a non-trivial default constructor which in turn means that notPOD is not a trivial class. This further means that notPOD is not a POD class. This is described in detail below.

From POD class:

> A POD class is a class that is either a POD struct or a POD union.

Now, a POD struct is defined to be:

> A POD struct 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).

(emphasis mine)

But the second requirement of being a trivial class is not fulfilled by notPOD but fullfilled by POD. From trivial class:

> A trivial class is a class that has a trivial default constructor ([class.ctor]) and is trivially copyable.

So next we come onto trivial default constructor:

> A default constructor is trivial if it is not user-provided and if:

Finally it comes down to whether the constructor notPOd::notPOD() is user-provided:

> A special member function is user-provided if it is user-declared and not explicitly defaulted or deleted on its first declaration.

(emphasis mine)

This means that POD::POD() is not user-provided and so it is a POD class while notPOD::notPOD() is user-provided since it is not defaulted at its first declaration so notPOD is not a POD class.