Concepts (C++)

<h2 id="main-uses">Main uses</h2>
<p>The main uses of concepts are:
</p>
<ul><li>introducing type-checking to template programming</li>
<li>simplified compiler diagnostics for failed template instantiations</li>
<li>selecting function template overloads and class template specializations based on type properties</li>
<li>constraining automatic type deduction</li></ul>
<h2 id="constraint-types-and-usage">Constraint types and usage</h2>
<p>There are five different places in a function template signature where a constraint can be used (labeled below as C1 to C5):<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a>
</p>
template<C1 T>
requires C2<T>
C3 auto Fun(C4 auto param) requires C5<T>;

<ul><li>C1: A type-constraint. This kind replaces class or <a href="/facts/Typename/daTA9bLa">typename</a> for declaring a <a href="/facts/TypeParameter/YQEDWumc">type template parameter</a>. When using a concept instead of the former two the type is constraint.</li>
<li>C2: A requires-clause. Whenever a type-constraint does not work, for example, because the concept takes multiple parameters, a requires-clause can be used to apply more elaborated constraints.</li>
<li>C3 / C4: A constrained placeholder type. The same syntax is available for <a href="/facts/Type_inference/vX9K8Qhf">placeholder</a> variable aka. auto variable. C++20 added <a href="/facts/Abbreviated_function_template/TXEqGy7R">abbreviated function templates</a> which use auto as a placeholder type in the parameter declaration.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a> A constrained placeholder type allows to put constraints on the automatically deduced return type of a function or a variable.</li>
<li>C5: A trailing requires-clause. This form is similar to C2 with one notable exception. A trailing requires-clause can be applied to a function in a class template. This allows the function to remain a regular, template-free function, which can be enabled or disabled depending on the functions trailing requires-clause.</li></ul>
<p>The constraint forms C1 and C2 can be used in all kinds of templates.
</p>
<h2 id="example-equalitycomparable">Example: equality_comparable</h2>
<p>The following is a declaration of the concept "equality_comparable" from the <concepts> header of a C++20 standard library. This concept is satisfied by any type T such that for <a href="/facts/Value_(computer_science)/QgQPbewf">lvalues</a> a and b of type T, the expressions a==b and a!=b as well as the reverse b==a and b!=a compile, and their results are convertible to a type that satisfies the concept "boolean-testable":
</p>
// The following concept is an implementation detail used to build equality_comparable
template<typename T, typename U>
concept weakly_equality_comparable_with = requires(const remove_reference<T>& a, const remove_reference<U>& b) {
    { a == b } -> std::same_as<bool>;
    { a != b } -> std::same_as<bool>;
    { b == a } -> std::same_as<bool>;
    { b != a } -> std::same_as<bool>;
};

template<class T>
concept equality_comparable = weakly_equality_comparable_with<T, T>;

<p>A function template constrained on this concept may be declared as follows:
</p>
void f(const equality_comparable auto&); // constrained abbreviated function template declaration using a constrained placeholder type (C4 from above)

<p>or 
</p>
template <equality_comparable T>
void f(const T&); // constrained function template declaration using a type constraint (C1 from above)

<p>And may be called as usual:
</p>
f(42); // OK, int satisfies equality_comparable

<h2 id="compiler-diagnostics">Compiler diagnostics</h2>
<p>If a programmer attempts to use a template argument that does not satisfy the requirements of the template, the compiler will generate an error. When concepts are not used, such errors are often difficult to understand because the error is not reported in the context of the call, but rather in an internal, often deeply nested, implementation context where the type was used.
</p><p>For example, std::sort requires that its first two arguments be <a href="/facts/Random-access_iterator/IxqpRzWU">random-access iterators</a>. If an argument is not an iterator, or is an iterator of a different category, an error will occur when std::sort attempts to use its parameters as bidirectional iterators:
</p>
// std::list is typically a doubly-linked list, whose iterators are not random-access
std::list<int> l = {2, 1, 3};
std::sort(l.begin(), l.end());

<p>Typical compiler diagnostic without concepts is over 50 lines of output, beginning with a failure to compile an expression that attempts to subtract two iterators:
</p>
In instantiation of 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = std::_List_iterator<int>; _Compare = __gnu_cxx::__ops::_Iter_less_iter]':
 error: no match for 'operator-' (operand types are 'std::_List_iterator<int>' and 'std::_List_iterator<int>')
 std::__lg(__last - __first) * 2,

[..]

<p>If concepts are used, the error can be detected and reported in the context of the call:
</p>
error: cannot call function 'void std::sort(_RAIter, _RAIter) [with _RAIter = std::_List_iterator<int>]'
note:   concept 'RandomAccessIterator()' was not satisfied

<h2 id="overload-resolution">Overload resolution</h2>
<p>Concepts can be used to choose function template overloads and class template specializations based on properties of their template arguments, as an alternative to <a href="/facts/SFINAE/DPR1af3G">SFINAE</a> and tag dispatching. If an argument satisfies more than one concept, the overload associated with the more constrained concept is chosen.
</p>
<h2 id="type-deduction">Type deduction</h2>
<p>Concepts may be used instead of the unconstrained type deduction placeholder auto in variable declarations and function return types:
</p>
auto     x1 = f(y); // the type of x1 is deduced to whatever f returns
Sortable auto x2 = f(y); // the type of x2 is deduced, but only compiles if it satisfies Sortable

<h2 id="implementation-status">Implementation status</h2>
<p>Concepts TS, as specified in ISO/IEC TS 19217:2015, are implemented as an experimental feature in <a href="/facts/GNU_Compiler_Collection/t07jh01k">GCC 6</a>.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a> C++20 concepts are fully implemented in <a href="/facts/GNU_Compiler_Collection/t07jh01k">GCC 10</a>,<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> <a href="/facts/Microsoft_Visual_C%2B%2B/RM3sbYw5">MSVC 19.30</a>,<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> and <a href="/facts/Clang/MH7cjC67">Clang 10</a>.<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a>
</p>
<h2 id="history">History</h2>
<p>A different form of Concepts, popularly known as "C++0x Concepts", was temporarily accepted into the working paper for <a href="/facts/C%2B%2B11/fI3YCoKQ">C++11</a> but was removed in 2009.<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a> In addition to concepts themselves, "C++0x Concepts" included <i>concept maps</i> (a feature that could make it possible, for example, for the concept "Stack" to accept std::vector, automatically mapping "Stack" operations such as push() to differently named operations on std::vector, such as push_back()) and <i>axioms</i> (a facility to specify semantic properties such as associativity or commutativity, allowing the compiler to take advantage of these properties without proof).
</p><p>In contrast to this abandoned proposal, the C++20 version of Concepts is sometimes referred to as "Concepts Lite".<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a>
</p><p>During the C++ standards committee meeting in March 2016, the evolution working group moved to merge Concepts into the mainline <a href="/facts/C%2B%2B17/B3gKNeER">C++17</a> standard, but the motion was defeated in full committee.<a class="footnote-ref" id="fnref:9" href="#fn:9"><sup>9</sup></a>
</p><p>Concepts v1 was merged into the <a href="/facts/C%2B%2B20/hwpB1Vzp">C++20</a> draft.<a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a>
</p><p>"The One Range" version of Range feature that depend on concepts was also merged into <a href="/facts/C%2B%2B20/hwpB1Vzp">C++20</a>.
</p>
<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Concept_(generic_programming)/fCkxQo4W">Concept (generic programming)</a></li>
<li><a href="/facts/Type_class/MBbIhF4n">Type class</a></li></ul>
<h2 id="notes">Notes</h2>

<ul><li>Sutton, Andrew; <a href="/facts/Bjarne_Stroustrup/Be1Yq6rn">Stroustrup, Bjarne</a> (2011). <a href="http://www.stroustrup.com/sle2011-concepts.pdf"><i>Design of Concept Libraries for C++</i></a> (PDF). International Conference on Software Language Engineering.</li>
<li>Sutton, Andrew (October 2015). <a href="http://accu.org/index.php/journals/2157">"Introducing Concepts"</a>. <i><a href="/facts/Overload_(magazine)/rwhh55G9">Overload</a></i>. 129. <a href="/facts/ACCU_(organisation)/aJMq35Ca">ACCU</a>.</li>
<li>Sutton, Andrew (February 2016). <a href="http://accu.org/index.php/journals/2198">"Defining Concepts"</a>. <i><a href="/facts/Overload_(magazine)/rwhh55G9">Overload</a></i>. 131. <a href="/facts/ACCU_(organisation)/aJMq35Ca">ACCU</a>.</li></ul>
<h2 id="external-links">External links</h2>
<ul><li><a href="http://en.cppreference.com/w/cpp/language/constraints">cppreference.com</a> Constraints and Concepts</li>
<li>Stroustrup, Bjarne (26 February 2016). <a href="https://isocpp.org/blog/2016/02/a-bit-of-background-for-concepts-and-cpp17-bjarne-stroustrup">"a bit of background for concepts and C++17"</a>. isocpp.org.</li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Fertig, Andreas (2021). Programming with C++20. Fertig Publications. p. 23. ISBN 978-3-949323-01-0. <a href="978-3-949323-01-0" target="_blank">978-3-949323-01-0</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"ISO/IEC 14882:2020". ISO. December 2020. Retrieved 14 July 2022. <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=79358" target="_blank">http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=79358</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"GCC 6 Release Series - Changes, New Features, and Fixes". <a href="https://gcc.gnu.org/gcc-6/changes.html" target="_blank">https://gcc.gnu.org/gcc-6/changes.html</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"C++ compiler support (gcc)". <a href="https://gcc.gnu.org/projects/cxx-status.html" target="_blank">https://gcc.gnu.org/projects/cxx-status.html</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>"C++ compiler support". <a href="https://en.cppreference.com/w/cpp/compiler_support" target="_blank">https://en.cppreference.com/w/cpp/compiler_support</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>"C++ Support in Clang". <a href="https://clang.llvm.org/cxx_status.html" target="_blank">https://clang.llvm.org/cxx_status.html</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>Bjarne Stroustrup (22 July 2009). "The C++0x "Remove Concepts" Decision". Dr. Dobbs. <a href="/wiki/Bjarne_Stroustrup" target="_blank">/wiki/Bjarne_Stroustrup</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>Andrew Sutton (24 February 2013). "Concepts Lite: Constraining Templates with Predicates". isocpp.org. <a href="https://isocpp.org/blog/2013/02/concepts-lite-constraining-templates-with-predicates-andrew-sutton-bjarne-s" target="_blank">https://isocpp.org/blog/2013/02/concepts-lite-constraining-templates-with-predicates-andrew-sutton-bjarne-s</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
<li id="fn:9"><p>Honermann, Tom (6 March 2016). "Why Concepts didn't make C++17". honermann.net. Archived from the original on 2 October 2018. Retrieved 19 April 2016. <a href="https://web.archive.org/web/20181002123639/http://honermann.net/blog/2016/03/06/why-concepts-didnt-make-cxx17/" target="_blank">https://web.archive.org/web/20181002123639/http://honermann.net/blog/2016/03/06/why-concepts-didnt-make-cxx17/</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li>
<li id="fn:10"><p>"2017 Toronto ISO C++ Committee Discussion Thread (Concepts in C++20; Coroutines, Ranges and Networking TSes published) : cpp". 15 July 2017. <a href="https://www.reddit.com/r/cpp/comments/6ngkgc/2017_toronto_iso_c_committee_discussion_thread/" target="_blank">https://www.reddit.com/r/cpp/comments/6ngkgc/2017_toronto_iso_c_committee_discussion_thread/</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li>
</ol>

Concepts (C++) open-in-new

Concepts (C++)