trivial vs. standard layout vs. POD

by

I don’t think it can be done in truly layman’s terms, at least without a lot of extra explanation. One important point is static vs. dynamic initialization, but explaining that to a layman would be several pages in itself…

PODs were (mis-)defined in C++98. There are really two separate intents involved, neither expressed very well: 1) that if you compile a C struct declaration in C++, what you get should be equivalent to what you had in C. 2) A POD will only ever need/use static (not dynamic) initialization.

C++0x/11 drops the “POD” designation (almost) entirely, in favor of “trivial” and “standard layout”. Standard layout is intended to capture the first intent — creating something with a layout the same as you’d get in C. Trivial is intended to capture the support for static initialization.

Since new T vs. new T() deals with initialization, you probably want is_trivial.

I’m not sure about compiler magic being required. My immediate reaction would be probably yes, but knowing some of the things people have done with TMP, I have a hard time being certain somebody couldn’t do this too…

Edit: for examples, perhaps it’s best to just quote the examples from N3290:

struct N { // neither trivial nor standard-layout
   int i;
   int j;
    virtual ~N();
};

struct T { // trivial but not standard-layout
    int i;
private:
    int j;
};

struct SL { // standard-layout but not trivial
    int i;
    int j;
    ~SL();
};

struct POD { // both trivial and standard-layout
    int i;
    int j;
};

As you can undoubtedly guess, POD is also a POD struct.

More Related Contents:

  1. How does `is_base_of` work?
  2. Why is there not an std::is_struct type trait?
  3. Find out whether a C++ object is callable
  4. check variadic templates parameters for uniqueness
  5. Checking a member exists, possibly in a base class, C++11 version
  6. What do compilers do with compile-time branching?
  7. Check if a variable type is iterable?
  8. What is decltype with two arguments?
  9. Is it possible to determine if a type is a scoped enumeration type?
  10. Disambiguate overloaded member function pointer being passed as template parameter
  11. Which cannot be implemented without compiler hooks?
  12. Is-braces-constructible type trait
  13. Check traits for all variadic template arguments
  14. How to write `is_complete` template?
  15. False positive with is_copy_constructible on vector
  16. C++11 is_same type trait for templates
  17. How to tell if template type is an instance of a template class?
  18. Why is std::is_pod deprecated in C++20?
  19. What is the purpose of C++20 std::common_reference?
  20. Check if a type is passed in variadic template parameter pack
  21. How to test whether class B is derived from template family of classes
  22. “What happened to my SFINAE” redux: conditional template class members?
  23. should std::common_type use std::decay?
  24. How to tell if a type is an instance of a specific template class?
  25. Why should one not derive from c++ std string class?
  26. Where is Boost.Process?
  27. Function pointer as parameter
  28. Why is my object not being copied when move constructor is deleted?
  29. Can I use identical names for fields and constructor parameters?
  30. Class template for numeric types

Leave a Comment