Thanks for your replies.  I think that std::optional is similar to what I was thinking about, but was requesting an extension to C++ to produce different behaviour.

The implementation of std::optional with my Microsoft compiler has a union which is something like....

union {

     char _Dummy;

     T       _Value;

};

This is an excellent example of my use-case.  The code in the library has to side-step the behaviour of the compiler of constructing items, and would be replaced by my proposal with  ....

[[unconstructed]] _Value;

We would simplify implementations of std::optional, focusing on the behaviour we require, rather than hiding from the compiler the use cases.

The pmr:: (polymorphic-memory-resources) list presented by Jason Turner offers alternative memory stores.  Which is for a different problem.

aligned_storage_t performs the same job as I was after, but you are left with a storage space, but would have to cast to the underlying type in order to use the memory.  I feel these are creating more awkward code results which  is harder  to maintain, than the idea of [[unconstructed]], which would help in library implementations.

Sent from Mail for Windows 10

From: Steve Hearnden via Std-Proposals
Sent: 02 September 2020 19:47
To: std-proposals@lists.isocpp.org
Cc: Steve Hearnden
Subject: [std-proposals] C++ create a class with array members which are notconstructed.

I was looking at a performance issue, with some code and found that the cost of creating the dynamic heap memory was the significant cost.

It would have been handy to have a class which implemented something like std::vector, but with a *small* buffer of values  to use as an alternative piece of memory when the vector size was below a threshold.

Unfortunately, an array of the constructed type, would cause the constructor to be called for each array element,  and for complex types, could undo the benefit of the pre-bought memory.

My proposal would be for classes (or structures) to  have the ability for a member to be declared with an attribute 

[[unconstructed]]

which would cause none of the constructors to actually construct the object.

The class would not naturally also call destructors.

e.g.

template< class T, size_t size>

class temp_vector

{

                [[unconstructed]] T _V[size];

                size_t m_constructed = 0;

public:

                ~temp_vector()

                {

///// Destroy the array manually.

                                for( size_t i = 0; i < m_constructed; i++ ){

                                                _V[i].~T();

}

}

}

Sent from Mail for Windows 10