Can a standard library implementation specialize standard types?

Question

For instance, let's assume for the sake of the argument that a more efficient (storage, operations on it) implementation for a vector of integral types is found (compared to the generic vector implementation). Can a standard complying library do something like:

template <class T, class A, class Enable = void>
class vector { ... };

template <class T>
class vector<T, A, std::enable_if_t<std::is_integral<T>::value>> { ... };

I think that this would be illegal because of the extra template parameter.

But what about a little compiler magic: (aside from the extra implementation work) would something like that be allowed:

• vector<integral_type, A> to be internally mapped to class vector_integral<T, A> while
• vector<anything_else, A> to be internally mapped to class vector<T, A>.

---

_{- This is obviously not about specializations explicitly mentioned in the standard, like std::vector<bool>}

_{- The specialization would obviously have the same interface and observable behavior.}

_{- Let's ignore concepts, as they are not yet standard. Unless you have some facts.}

_{- This is a pure academic question (read personal curiosity).}

Answer 1

As long as the standard library implementation lives up to the guarantees issued by the standard, it is allowed to have specializations. These guarantees obviously include growth complexity, interface functions, and for certain classes the internal layout of the data.

The vector<bool> specialization is, to my knowledge, included in the standard since its internal data layout differs from the generic vector<T> library class, thus it needs to be specifically allowed by the standard.

The standtard explicitly says 17.5.1.4 ad. 7:

Complexity requirements specified in the library clauses are upper bounds, and implementations that provide better complexity guarantees satisfy the requirements.