Why are std::future and std::promise not final?
Have a look at this contrived (admittedly nonsensical) example with std::vector
:
template <class T>
struct Example : private std::vector<T> {
void doStuff(const T& t) { this->push_back(t); }
T retrieveStuff() { return this->operator[](0); }
};
Example<int> e;
e.doStuff(42);
std::cout << e.retrieveStuff() << "\n";
This works, you can't get into UB due to std::vector::~vector
not being virtual
because you can't delete an object through a base class pointer (public
inheritance is needed there).
The inheritance here is just an implementation detail. Not recommended practice, but people probably did and do this. Once the decision is made to not break existing code by making std::vector
or other container types final
, it makes sense to stick to that with different vocabulary types like std::promise
or std::future
.
As per [derivation]/4:
All types specified in the C++ standard library shall be non-final types unless otherwise specified.
And std::future
or std::promise
are not excepted.
And as mentioned in a comment, this issue has been discussed before. Do library implementers have the freedom to add final to non-polymorphic components?.
The resolution of this issue was that it was not considered a defect with the conclusion:
Unless the library uses the keyword
final
in a specification, the user clearly has freedom to derive from such a class, and so equally clearly, the library vendor does not have freedom to add afinal
overrider or class attribute.