13 Templates [temp]

13.5 Template constraints [temp.constr]

13.5.4 Partial ordering by constraints [temp.constr.order]

A constraint P subsumes a constraint Q if and only if, for every disjunctive clause

P_{i}

in the disjunctive normal form130 of P,

P_{i}

subsumes every conjunctive clause

Q_{j}

in the conjunctive normal form131 of Q, where

(1.1)
a disjunctive clause $P_{i}$ subsumes a conjunctive clause $Q_{j}$ if and only if there exists an atomic constraint $P_{i a}$ in $P_{i}$ for which there exists an atomic constraint $Q_{j b}$ in $Q_{j}$ such that $P_{i a}$ subsumes $Q_{j b}$ , and
(1.2)
an atomic constraint A subsumes another atomic constraint B if and only if A and B are identical using the rules described in [temp.constr.atomic].

[ Example

Let A and B be atomic constraints .

The constraint

A \land B

subsumes A, but A does not subsume

A \land B

The constraint A subsumes

A \lor B

, but

A \lor B

does not subsume A.

Also note that every constraint subsumes itself.

— end example

]

[ Note

The subsumption relation defines a partial ordering on constraints.

This partial ordering is used to determine

(2.1)
the best viable candidate of non-template functions ([over.match.best]),
(2.2)
the address of a non-template function ([over.over]),
(2.3)
the matching of template template arguments,
(2.4)
the partial ordering of class template specializations, and
(2.5)
the partial ordering of function templates .

— end note

]

A declaration D1 is at least as constrained as a declaration D2 if

(3.1)
D1 and D2 are both constrained declarations and D1's associated constraints subsume those of D2; or
(3.2)
D2 has no associated constraints.

A declaration D1 is more constrained than another declaration D2 when D1 is at least as constrained as D2, and D2 is not at least as constrained as D1.

[ Example

template<typename T> concept C1 = requires(T t) { --t; };
template<typename T> concept C2 = C1<T> && requires(T t) { *t; };

template<C1 T> void f(T);       // #1
template<C2 T> void f(T);       // #2
template<typename T> void g(T); // #3
template<C1 T> void g(T);       // #4

f(0);                           // selects #1
f((int*)0);                     // selects #2
g(true);                        // selects #3 because C1<bool> is not satisfied
g(0);                           // selects #4