What is the purpose of std::launder?

by

std::launder is aptly named, though only if you know what it’s for. It performs memory laundering.

Consider the example in the paper:

struct X { const int n; };
union U { X x; float f; };
...

U u = {{ 1 }};

That statement performs aggregate initialization, initializing the first member of U with {1}.

Because n is a const variable, the compiler is free to assume that u.x.n shall always be 1.

So what happens if we do this:

X *p = new (&u.x) X {2};

Because X is trivial, we need not destroy the old object before creating a new one in its place, so this is perfectly legal code. The new object will have its n member be 2.

So tell me… what will u.x.n return?

The obvious answer will be 2. But that’s wrong, because the compiler is allowed to assume that a truly const variable (not merely a const&, but an object variable declared const) will never change. But we just changed it.

[basic.life]/8 spells out the circumstances when it is OK to access the newly created object through variables/pointers/references to the old one. And having a const member is one of the disqualifying factors.

So… how can we talk about u.x.n properly?

We have to launder our memory:

assert(*std::launder(&u.x.n) == 2); //Will be true.

Money laundering is used to prevent people from tracing where you got your money from. Memory laundering is used to prevent the compiler from tracing where you got your object from, thus forcing it to avoid any optimizations that may no longer apply.

Another of the disqualifying factors is if you change the type of the object. std::launder can help here too:

alignas(int) char data[sizeof(int)];
new(&data) int;
int *p = std::launder(reinterpret_cast<int*>(&data));

[basic.life]/8 tells us that, if you allocate a new object in the storage of the old one, you cannot access the new object through pointers to the old. launder allows us to side-step that.

More Related Contents:

  1. What are the new features in C++17?
  2. What are template deduction guides and when should we use them?
  3. Restrict variadic template arguments
  4. Resolve build errors due to circular dependency amongst classes
  5. Why isn’t sizeof for a struct equal to the sum of sizeof of each member?
  6. How do I use arrays in C++?
  7. What is the difference between const int*, const int * const, and int const *?
  8. Default constructor with empty brackets
  9. When and why will a compiler initialise memory to 0xCD, 0xDD, etc. on malloc/free/new/delete?
  10. Why is volatile not considered useful in multithreaded C or C++ programming?
  11. How do inline variables work?
  12. Does C++ support ‘finally’ blocks? (And what’s this ‘RAII’ I keep hearing about?)
  13. How to enable C++17 compiling in Visual Studio?
  14. Does const mean thread-safe in C++11?
  15. Proper stack and heap usage in C++?
  16. Copy constructor and = operator overload in C++: is a common function possible?
  17. Convert string to int with bool/fail in C++
  18. Type erasing type erasure, `any` questions?
  19. Class template argument deduction not working with alias template
  20. How do you read directly from physical memory on Windows?
  21. Could I ever want to access the address zero?
  22. Why is std::iterator deprecated?
  23. Can I Allocate a specific memory address using pointers in c++?
  24. When do extra parentheses have an effect, other than on operator precedence?
  25. Is std::vector memory freed upon a clear?
  26. Is global memory initialized in C++?
  27. Dereferencing deleted pointers always result in an Access Violation?
  28. How to ignore false positive memory leaks from _CrtDumpMemoryLeaks?
  29. How to get the starting/base address of a process in C++?
  30. Undefined reference error with new filesystem library and clang++7

Leave a Comment