#pragma once
#include <type_traits>
#include <concepts>
#include <new>
#include <utility>

template<typename T>
concept ndi_concept = std::is_trivial_v<T>;

template<ndi_concept T>
union ndi
{ ndi();
ndi( ndi const & );
ndi( T const &value );
ndi &operator =( T const &assign );
operator T &();
operator T const &() const;
T *operator &();
T const *operator &() const;
T *operator ->()
requires std::is_compound_v<T>;
T const *operator ->() const
requires std::is_compound_v<T>;
private:
T m_value;
};

template<ndi_concept T>
inline ndi<T>::ndi()
{ }

template<ndi_concept T>
inline ndi<T>::ndi( ndi const &other ) :
m_value( other.m_value )
{ }

template<ndi_concept T>
inline ndi<T>::ndi( T const &value )
{ m_value = value;
}

template<ndi_concept T>
inline ndi<T> & ndi<T>::operator =( T const &assign )
{ m_value = assign;
return *this;
}

template<ndi_concept T>
inline ndi<T>::operator T &()
{ return m_value;
}

template<ndi_concept T>
inline ndi<T>::operator T const &() const
{ return m_value;
}

template<ndi_concept T>
inline T *ndi<T>::operator &()
{ return &m_value;
}

template<ndi_concept T>
inline T const *ndi<T>::operator &() const
{ return &m_value;
}

template<ndi_concept T>
inline T *ndi<T>::operator ->()
requires std::is_compound_v<T>
{ return &m_value;
}

template<ndi_concept T>
inline T const *ndi<T>::operator ->() const
requires std::is_compound_v<T>
{ return &m_value;
}

This class was to prevent default initialization of trivial types.
If you have a trivial type inside a vector and you resize the vector
the elements are default-initialized. If you chose to pre-reserve
the entitities of the vector and you do incremental emplace_back()s
the last-pointer would be updated repeatedly.

This code shows the performance difference:

#include <iostream>
#include <chrono>
#include <vector>
#include "ndi.h"

using namespace std;
using namespace chrono;

int main()
{ constexpr size_t N = 1'000'000'000;
auto bench = []( auto init, auto append, char const *what )
{
auto start = high_resolution_clock::now();
auto vec = init();
for( size_t i = 0; i != N; ++i )
append( vec, i );
cout << what << duration_cast<nanoseconds>(
high_resolution_clock::now() - start ).count() / 1.0e9 << endl;
};
bench( [&]() -> vector<ndi<int>>
{
return vector<ndi<int>>( N );
},
[&]( vector<ndi<int>> &vec, size_t i )
{
vec[i] = (int)i;
},
"vector<ndi<int>>: " );
bench( [&]() -> vector<int>
{
auto vec = vector<int>();
vec.reserve( N );
return vec;
},
[&]( vector<int> &vec, size_t i )
{
vec.emplace_back( (int)i );
},
"vector<int>: " );
}

With MSVC the ndi-variant has about 72% more throughput on my
AMD 7950X. With g++ on my AMD 3990X I get 63% more throughput.

If I touch all pages after reserving the vector with madvise()
/ MAP_POPULATE_WRITE I even get about 2,67 times the performance
on my AMD 3990X.

#include <iostream>
#include <chrono>
#include <vector>
#include "ndi.h"
#if defined(__unix__)
#include <sys/mman.h>
#endif

using namespace std;
using namespace chrono;

int main()
{ constexpr size_t N = (1ull << 30) / sizeof(int);
auto bench = []( auto init, auto append, char const *what )
{
auto start = high_resolution_clock::now();
auto vec = init();
for( size_t i = 0; i != N; ++i )
append( vec, i );
cout << what << duration_cast<nanoseconds>(
high_resolution_clock::now() - start ).count() / 1.0e9 << endl;
};
bench( [&]() -> vector<ndi<int>>
{
auto vec = vector<ndi<int>>( N );
#if defined(__unix__)
constexpr size_t PAGE_SIZE = 0x1000;
char
*begin = (char *)(((size_t)vec.data() + PAGE_SIZE - 1) &
-(ptrdiff_t)PAGE_SIZE),
*end = (char *)((size_t)(vec.data() + N) & -(ptrdiff_t)PAGE_SIZE);
if( end > begin && madvise( begin, end - begin, MADV_POPULATE_WRITE )
< 0 )
terminate();
#endif
return vec;
},
[&]( vector<ndi<int>> &vec, size_t i )
{
vec[i] = (int)i;
},
"vector<ndi<int>>: " );
bench( [&]() -> vector<int>
{
auto vec = vector<int>();
vec.reserve( N );
return vec;
},
[&]( vector<int> &vec, size_t i )
{
vec.emplace_back( (int)i );
},
"vector<int>: " );
}