{"id":3566,"date":"2019-10-04T18:08:43","date_gmt":"2019-10-04T16:08:43","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=3566"},"modified":"2019-10-04T09:12:26","modified_gmt":"2019-10-04T07:12:26","slug":"concepts-versus-sfinae-based-constraints","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2019\/10\/04\/concepts-versus-sfinae-based-constraints\/","title":{"rendered":"Concepts versus SFINAE-based constraints"},"content":{"rendered":"

In some situations, we need to makes sure function templates can only be invoked with some specific types. SFINAE (that stands for Substitution Failure Is Not An Error) is a set of rules that specify how compilers can discard specializations from the overload resolution without causing errors. A way to achieve this is with the help of std::enable_if<\/a>. <\/p>\n

<\/p>\n

Let us look at an example. Suppose we want to write a function template called product()<\/tt> that returns the product of its two arguments. We only want to be able to call it with arithmetic types. Using std::enable_if<\/tt> we can define such a function as follows:<\/p>\n

template <typename T,\r\n          typename = typename std::enable_if_t<std::is_arithmetic_v<T>>>\r\nT product(T const t1, T const t2)\r\n{\r\n   return t1 * t2;\r\n}<\/pre>\n
We can use it to multiply integers or doubles for example, even booleans (bools can be converted to integers, with true<\/tt> becoming 1 and false<\/tt> becoming 0), but not other types, such as std::string<\/tt>.<\/p>\n
using namespace std::string_literals;\r\n\r\nauto v1 = product(3, 4);\r\nauto v2 = product(13.4, 2.55);\r\nauto v3 = product(false, true);\r\nauto v4 = product(\"one\"s, \"two\"s);  \/\/ error<\/pre>\n
The last line above would produce the following compiler error when compiling with Visual Studio: <\/p>\n
error C2672: 'product': no matching overloaded function found\r\nerror C2783: 'T product(const T,const T)': could not deduce template argument for '<unnamed-symbol>'<\/pre>\n
SFINAE-based constraints are not the most intuitive code to read. Eventually, they model concepts with template trickery. But C++20 provides concepts as a first-class experience to make metaprogramming simpler and more expressive both to the compiler and developers. So let us look at how we can do the same and better with concepts.<\/p>\n
We can start by providing concepts for numerical types (a type that is either integral, or floating-point). You can see these below. Notice that the standard library provides two concepts called std::integral<\/tt> and std::floating_point<\/tt> in the header <concepts><\/tt>. The implementation below is identical to the standard one.<\/p>\n
template <typename T>\r\nconcept integral = std::is_integral_v<T>;\r\n\r\ntemplate <typename T>\r\nconcept floating_point = std::is_floating_point_v<T>;\r\n\r\ntemplate <typename T>\r\nconcept numeric = integral<T> || floating_point<T>;\r\n<\/pre>\n
Having this numeric<\/tt> concept available, we can change the definition of the product()<\/tt> function to the following:<\/p>\n
\r\ntemplate <numeric T>\r\nT product(T const t1, T const t2)\r\n{\r\n   return t1 * t2;\r\n}<\/pre>\n
Compiling the lines above would again produce an error for the last invocation of product()<\/tt> using std::string<\/tt> arguments. This time, the errors yield by the Visual Studio compiler are as follows:<\/p>\n
error C2672: 'product': no matching overloaded function found\r\nerror C7602: 'product': the associated constraints are not satisfied<\/pre>\n
But what if we want to extend the function template product()<\/tt> so that it works for every type for which the operator* is overloaded? That’s difficult to do with SFINAE but rather straight-forward with concepts. The only thing we need to do is define a concept that expresses that. Below, this concept is called multiplicative<\/tt>.<\/p>\n
template<typename T>\r\nconcept multiplicative = requires(const T a, const T b)\r\n{\r\n    { a * b }->T;\r\n};\r\n<\/pre>\n
The changes to the definition of product()<\/tt> are minimal: we just replace numeric<\/tt> with multiplicative<\/tt>.<\/p>\n
\r\ntemplate <multiplicative T>\r\nT product(T const t1, T const t2)\r\n{\r\n   return t1 * t2;\r\n}<\/pre>\n
So what can we do to make product(\"one\"s, \"two\"s)<\/tt> compile? We can overload operator* for std::string<\/tt>. The following is an implementation that “zips” two strings together. The product of “abc” and “xywz” is “axbycwz”. The actual implementation is not important; this is provided just for the sake of making the example produce some actual values.<\/p>\n
std::string operator*(std::string const& s1, std::string const& s2)\r\n{\r\n   std::string result(s1.length() + s2.length(), '\\0');\r\n   size_t i = 0;\r\n   size_t j = 0;\r\n   while(i < s1.length() && i < s2.length())\r\n   {\r\n      result[j++] = s1[i];\r\n      result[j++] = s2[i];\r\n      i++;\r\n   }\r\n   \r\n   for (size_t k = i; k < s1.length(); ++k)\r\n      result[j++] = s1[k];\r\n\r\n   for (size_t k = i; k < s2.length(); ++k)\r\n      result[j++] = s2[k];\r\n\r\n   return result;\r\n}<\/pre>\n
With this available the code we’ve seen above compiles without errors.<\/p>\n
using namespace std::string_literals;\r\n\r\nauto v1 = product(3, 4);\r\nauto v2 = product(13.4, 2.55);\r\nauto v3 = product(false, true);\r\nauto v4 = product(\"one\"s, \"two\"s);<\/pre>\n
And that’s how simple concepts can make the code. More about the advantages of concepts can be found here: Why I want Concepts, and why I want them sooner rather than later<\/a>.<\/p>\n
See also on this topic:<\/p>\n