STL | MSVC 's implementation of the C++ Standard Library

The first one should probably be:

I believe the crux of the problem is DLL compatibility.

If they change the memory of any standard classes, then that class can't be passed across a DLL boundary, because we don't know which memory format the DLL was expecting, unless we know for certain that they were compiled with the same C++ version.

This is also why Windows APIs take pointers to structs, and the first member of the struct is the size. This allows them to append members to the struct in new versions of Windows, but older applications will continue to be able to call the methods.

In general, no. The rules of C++ explicitly allow implicit conversions to take place. The fact that the authors of C++ made some of those conversions potentially unsafe is another matter.

You could add std::is_constructible static_assert or SFINAE to the code to make the compiler errors less ugly if the user inputs wrong arguments, but it won't solve implicit conversions.

From design perspective, the code should not care about this, the purpose of emplace_XXX is to allow exactly the calls that are allowed for T{args...}.

Note: You most likely want to forward the arguments like T element{std::forward(args)...}; and also move the element into the vector vec.push_back(std::move(t));.

I tried the code i pasted below and it is working fine on my local machine, please check and let me know if it's working for you also.

P.S please replace image element's source with an appropriate gif url to get it working

There's no self-move here. A self-move is something like this:

This is implementation freedom. The C++ standard defines the class, the implementation of the class is up, well, to the implementation.

There are some classes where the standard explicitly mandates a trivial destructor. For example, if an existing class is trivially destructible then its std::optional also must be trivially destructible. This needs to be spelled out.

Therefore, unless somewhere there is an explicit statement that the class is or is not trivially constructible, then this is up to the implementation (where possible).

Looking at gcc's header file: it doesn't merely declare, but it explicitly defines the destructor:

From this blog post by Eric Niebler, whose range-V3 library heavily influenced C++20 ranges

... custom view types can inher[i]t from view_interface to get a host of useful member functions, like .front(), .back(), .empty(), .size(), .operator[], and even an explicit conversion to bool so that view types can be used in if statements

When in doubt, add extra *.