When is a type in c++11 allowed to be memcpyed?

by

You can copy an object of type T using memcpy when is_trivially_copyable<T>::value is true. There is no particular need for the type to be a standard layout type. The definition of ‘trivially copyable’ is essentially that it’s safe to do this.

An example of a class that is safe to copy with memcpy but which is not standard layout:

struct T {
  int i;
private:
  int j;
};

Because this class uses different access control for different non-static data members it is not standard layout, but it is still trivially copyable.

More Related Contents:

  1. C++11 lambda implementation and memory model
  2. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  3. Error while passing vector to instance of object in main
  4. Converting std::__cxx11::string to std::string
  5. Concurrency: Atomic and volatile in C++11 memory model
  6. Implementing comparison operators via ‘tuple’ and ‘tie’, a good idea?
  7. Create N-element constexpr array in C++11
  8. The new syntax “= default” in C++11
  9. Why does passing object reference arguments to thread function fails to compile?
  10. What is the point of noreturn?
  11. Convert std::tuple to std::array C++11
  12. If we seed c++11 mt19937 as the same on different machines, will we get the same sequence of random numbers
  13. How to create the Cartesian product of a type list?
  14. What is the difference between packaged_task and async
  15. How to directly bind a member function to an std::function in Visual Studio 11?
  16. Exception safety and make_unique
  17. Passing shared_ptr as shared_ptr
  18. Best way for interprocess communication in C++
  19. C++11 Thread safety of Random number generators
  20. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  21. Is an object guaranteed to be moved when it is returned?
  22. std::pow produce different result in 32 bit and 64 bit application
  23. C++11 rvalue reference calling copy constructor too
  24. C++ terminate called without an active exception
  25. Conflict between copy constructor and forwarding constructor
  26. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  27. Initialization difference with or without curly braces in C++
  28. Should std::unique_ptr be permitted
  29. Initializing an std::array of non-default-constructible elements?
  30. Does the C++ standard specify anything on the representation of floating point numbers?

Leave a Comment