Detailed explanation of the definition and usage of std::launder in C++17

Why do I need std::launder?

In the C++ language running mechanism, the compiler will build a memory model based on the logic of the source code. This memory model describes in detail the specific layout of objects in memory and their life cycle. Based on this memory model, the compiler will perform a series of optimization operations, the most common of which is to eliminate redundant memory access to improve the operation efficiency of the program.

However, when usingreinterpret_castOr when re-representing an object in other special ways, it may break the compiler's original memory model assumption. For example, in C++ we can useplacement newThe operator creates a new object at an existing memory location. In this case, the compiler may not be able to detect in time that the object's type has changed. If you directly access the newly created object through the old pointer at this time, the compiler operates according to the old memory model, it may lead to wrong results and even cause program crashes. The root of this error is that the behavior of the program violates the compiler's expectations, resulting in the occurrence of undefined behavior.

std::launderThe function is that it can clearly convey a message to the compiler: "I have changed the representation of the object. Please give up the assumptions made based on the representation of the old object and re-optimize according to the representation of the new object." In this way, the compiler can make reasonable optimizations based on the new situation, thereby effectively avoiding the occurrence of undefined behavior and ensuring the correctness and stability of the program.

Definition and usage of std::launder

std::launderThe definitions in the C++17 standard are as follows:

template &lt;class T&gt;
constexpr T* launder(T* p) noexcept;    // C++17 rise

As can be seen from the definition,std::launderis a template function that accepts a type ofT*PointerpAs an argument, and return a same typeT*pointer. Its specific function is to return a pointer located atpPointer to the object representing the address.

In usestd::launderWhen it comes to this, developers need to pay close attention to the following important conditions:

The object must be in lifetime：std::launderOnly used to access objects that are within a valid life cycle. If you trystd::launderAccessing an object that has been destructed or has not been created yet will result in undefined behavior.
Type Match: The type of the target object must be with the template parametersTSame, what needs to be noted here is thatstd::launderWill ignorecvQualifier (constandvolatilequalifier). That is, no matter the object isconstType orvolatileType, as long as its actual type and template parametersTConsistent, you can use itstd::launderPerform processing.
Tapping:passstd::launderThe result pointer returned by the operation must also be accessible through the original pointer.ptouch. This means usingstd::launderWhen the pointer cannot change the accessibility of the memory area pointed to. If this condition is violated,std::launderThe behavior will be undefined.

If any of the above conditions are not satisfied,std::launderThe behavior cannot be guaranteed and may cause unpredictable errors.

Typical usage scenarios

1. Handle new objects created by placement new

When we useplacement newWhen creating a new object in an existing memory location, the original pointer may not be able to access the newly created object correctly. in this case,std::launderIt can play an important role to obtain a valid pointer to a new object.

Here is a specific example code:

struct X { 
    const int n; 
    double d; 
};
X* p = new X{7, 8.8};
new (p) X{42, 9.9};  // Create a new object in pint i = std::launder(p)-&gt;n;  // OK, i is 42auto d = std::launder(p)-&gt;d; // OK，d yes 9.9

In the above code, first passnewThe operator creates aXobject of type and assign its pointer top. Then, useplacement newexistpA new memory location is createdXObject of type. At this time, if not usedstd::launder, directly throughpGoing to access members of a new object will result in undefined behavior. Bystd::launder(p)To get a pointer to the new object, you can correctly access the members of the new object, ensuring that the behavior of the program is predictable.

2. Handle updates of virtual function tables

In scenarios involving virtual functions, when the type of an object changes, it may cause updates to the virtual function table (vtable). in this case,std::launderThis ensures that the new virtual function table is accessed through the correct pointer, thus avoiding undefined behavior.

Here is a specific example:

struct A { 
    virtual int transmogrify(); 
};
struct B : A { 
    int transmogrify() override { 
        new(this) A; 
        return 2; 
    } 
};
int A::transmogrify() { 
    new(this) B; 
    return 1; 
}
A i;
int n = ();  // Call A::transmogrify to create a B objectint m = std::launder(&amp;i)-&gt;transmogrify(); // OK，Call B::transmogrify

In this example,AClass andBClasses are inheritance relationships and all define virtual functions.transmogrify. existA::transmogrifyIn the function, useplacement newWillAConvert object of type toBobject of type; inB::transmogrifyIn the function, theBType object conversion backAObject of type. CallingtransmogrifyAfter the function, if not usedstd::launder, directly through&iCalltransmogrifyFunctions, since the virtual function table has changed, will cause undefined behavior. Bystd::launder(&i)To obtain the correct pointer, you can ensure that the correct virtual function is called and the correct operation of the program.

3. In a scenario similar to std::optional

In similarstd::optionalIn the implementation ofstd::launderYou can ensure that the behavior is correct when accessing a new object through a member pointer.std::optionalis a very practical type introduced in C++17, which can be used to represent a value that may or may not exist.

Here is a simplifiedstd::optionalImplementation example:

template&lt;typename T&gt;
class optional {
private:
    T payload;
public:
    template&lt;typename... Args&gt;
    void emplace(Args&amp;&amp;... args) {
        payload.~T();
        ::new (&amp;payload) T(std::forward&lt;Args&gt;(args)...);
    }
    const T&amp; operator*() const &amp; {
        return *(std::launder(&amp;payload)); // Use std::launder to ensure access to new objects    }
};

In the above code,optionalClassicemplaceFunctions are used inpayloadCreate a new object on the member. existoperator*In the function,std::launder(&payload)to get the correct pointer to the new object, thus ensuring accesspayloadThe behavior of members is correct, avoiding the occurrence of undefined behavior.

Summarize

std::launderIt is a very powerful and practical tool introduced by the C++17 standard. It effectively helps developers avoid undefined behavior that may occur in complex memory operation scenarios by explicitly informing the compiler of re-representation of objects. Involvedplacement new, virtual function table update or similarstd::optionalIn the implementation of thestd::launderAll can play an important role in ensuring the correctness and stability of the procedures.

However, it should be clear thatstd::launderNot a universal solution, it doesn't solve all pointer-related problems. Its use requires developers to be cautious when meeting specific conditions, fully understand its working principle and usage limitations.

Anyway,std::launderAs an important feature in modern C++, it is of great significance to improving the quality and reliability of C++ programs, and it deserves in-depth understanding and proficiency of every C++ developer. I hope this article can help readers understand betterstd::launderfunction and usage. If readers are interested in this topic, it is recommended to read the relevant standard documents of C++17 in depth, or try to apply this feature in actual projects to deepen their understanding and mastery.
Bold style

This is all about this article about std::launder in C++17. For more related contents of C++17, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!