避免 C++14 中的字段零初始化

Question

Since C++14 (it might be C++11, i'm not sure), zero initialization happens on class construction on certain conditions, depending on the way the constructor is called. Is there a way to ensure a raw value field (let's say a pointer) is never zero initialized ?

I guess not because it seems that zero initialization happens at the class level and not at the field level (surely a kind of memset(this, 0, sizeof(TheClass)) ), but I'm still hoping there is way, a hack, something...

The idea is to be able to initialize a field before a placement new is called so that that member is available during construction time.

Answer 1

According to cppreference's take on zero initialization :

If T is an non-union class type, all base classes and non-static data members are zero-initialized, and all padding is initialized to zero bits. The constructors, if any, are ignored.

If your object is a victim of zero initialization you're out of luck. And every object with static or thread local storage duration will always be zero initialized (except for constant initialization).

Answer 2

Is there a way to ensure a raw value field (let's say a pointer) is never zero initialized ?

It is possible, yes.

If the class is trivially default constructible, then simply default initialise the object, and its members will be default initialised as well:

int main() {
    T t; // default initialised

If the class is not trivially default constructible, you can write a user defined constructor that leaves the member uninitialised (note that doing this is generally discouraged):

struct S {
    int member;
    S(){} // member is left default initialised

Warning: With a user defined constructor, the member would be left default initialised even if the object is value initialised.

---

Objects with static storage duration are always zero or constant initialised. Neither of those leave members uninitialised. Only way to avoid that initialisation is to not create objects with static storage duration.

---

The idea is to be able to initialize a field before a placement new is called so that that member is available during construction time.

If you mean your idea is to initialise a field of an object that hasn't yet been created with placement new, then the idea is not possible to implement.

Members are available during construction time. You don't need any tricks to achieve this. All members that can be used by their siblings in order of their initialisation. And the constructor body is run after all members have been initialised.

Answer 3

As @eerorika's answer suggests:

struct S {
    int member;
    S(){} // member is left default initialised

...note that doing this is generally discouraged

I would say that the clearest way to achieve this without confusing the user of the class would be not to use a int , but a std::aligned_storage_t as it is clear that this member is used just for storage of objects that might be created later rather than a value that can be used on its own.

Depending how much code you would like to write, this might be tedious, because you have to write placement new s and use std::launder (since c++17) to be compliant with the standard. However, this is IMO the best way to express your intent.

cppreference gives agood example of how to use std::aligned_storage (with some modification, see comments):

#include <iostream>
#include <type_traits>
#include <string>

template<class T, std::size_t N>
class static_vector
{
    // properly aligned uninitialized storage for N T's
    typename std::aligned_storage<sizeof(T), alignof(T)>::type data[N];
    std::size_t m_size = 0;

public:
    // My modification here suppresses zero-initialization
    // if initialized with empty braces
    static_vector() {};

    // Create an object in aligned storage
    template<typename ...Args> void emplace_back(Args&&... args) 
    {
        if( m_size >= N ) // possible error handling
            throw std::bad_alloc{};

        // construct value in memory of aligned storage
        // using inplace operator new
        new(&data[m_size]) T(std::forward<Args>(args)...);
        ++m_size;
    }

    // Access an object in aligned storage
    const T& operator[](std::size_t pos) const 
    {
        // note: needs std::launder as of C++17
        return *reinterpret_cast<const T*>(&data[pos]);
    }

    // Delete objects from aligned storage
    ~static_vector() 
    {
        for(std::size_t pos = 0; pos < m_size; ++pos) {
            // note: needs std::launder as of C++17
            reinterpret_cast<T*>(&data[pos])->~T();
        }
    }
};

int main()
{
    static_vector<std::string, 10> v1;
    v1.emplace_back(5, '*');
    v1.emplace_back(10, '*');
    std::cout << v1[0] << '\n' << v1[1] << '\n';

    static_vector<std::size_t, 10> v2{};

    // This is undefined behavior.
    // Here it's just used to demonstrate that
    // the memory is not initialized.
    std::cout << v2[0] << "\n";
}

Run it on compiler explorer

---

However, since the c++ standard only mandates when zero-initialization must happen, but not when it must not happen, sometimes you really have to wrestle with your compiler in order to suppress zero initialization.

See this question and this question for more details.