{"id":3551,"date":"2019-09-12T08:24:54","date_gmt":"2019-09-12T06:24:54","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=3551"},"modified":"2019-09-12T08:24:54","modified_gmt":"2019-09-12T06:24:54","slug":"cpp20-concepts-in-visual-studio-2019-16-3-preview-2","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2019\/09\/12\/cpp20-concepts-in-visual-studio-2019-16-3-preview-2\/","title":{"rendered":"C++20 Concepts in Visual Studio 2019 16.3 Preview 2"},"content":{"rendered":"

Back in mid-August, Microsoft released the 2nd preview of Visual Studio 2019 16.3<\/a>. This is the first version of Visual Studio to support concepts from C++20<\/a> both in the compiler and the standard library (header <concepts><\/tt>) without the changes made at the ISO C++ standards meeting in Cologne. These changes are available when you compile with the \/std:c++latest<\/tt> switch.<\/p>\n

Concepts allow performing compile-time validation of template arguments and function dispatch based on properties of types. Concepts are very useful in libraries where they can be used to impose compile-time checks on the template arguments of functions or types. For instance, a generic algorithm for sorting a container would require the container type to be sortable for the program to even compile.<\/p>\n

In this article, I will show an example with a concept that verifies that a type T<\/tt> can be converted to a std::string<\/tt> via a to_string()<\/tt> function, that is either a member of the class or a free function.<\/p>\n

<\/p>\n

In the code below, OverloadsToString<\/tt> is a concept that checks that a free function called to_string<\/tt> exists, and it takes a single argument of type T<\/tt> and returns a std::string<\/tt>. On the other hand, HasToString<\/tt> is a concept that checks that a type T<\/tt> has a method called to_string<\/tt> that takes no arguments and returns a std::string<\/tt>. These two concepts, are composed together using operator ||<\/tt> in a new concept called StringConvertible<\/tt>. A concept composed this way is called a disjuction<\/em>. On the other hand, a composition of two constraints with operator &&<\/tt> is called a conjunction<\/em>.<\/p>\n

#include <string>\r\n#include <concepts>\r\n\r\ntemplate <typename T>\r\nconcept OverloadsToString = requires (T v)\r\n{\r\n\t{to_string(v)}->std::string;\r\n};\r\n\r\ntemplate <typename T>\r\nconcept HasToString = requires (T v)\r\n{\r\n\t{v.to_string()}->std::string;\r\n};\r\n\r\ntemplate <typename T>\r\nconcept StringConvertible = OverloadsToString<T> || \r\n                            HasToString<T>;\r\n<\/pre>\n
We can use the StringConvertible<\/tt> concepts to perform checks on types. In the following example, an instance of the class foo<\/tt> can be converted to a std::string<\/tt> using the function to_string<\/tt> (for simplicity, this function does not to much except returning the same string for all instances). For the class bar<\/tt> there is no way to convert an instance of it to a std::string<\/tt>. On the other hand, the class foobar<\/tt> has a method called to_string<\/tt>. We can verify that a type is satifsfying the concept or not using static_assert<\/tt>, as shown below:<\/p>\n
\r\nstruct foo {};\r\nstruct bar {};\r\nstruct foobar\r\n{\r\n\tstd::string to_string() { return \"foobar\"; }\r\n};\r\n\r\nstd::string to_string(foo const& f)\r\n{\r\n\treturn \"foo\";\r\n}\r\n\r\nstatic_assert(StringConvertible<foo>);\r\nstatic_assert(!StringConvertible<bar>);\r\nstatic_assert(StringConvertible<foobar>);\r\n<\/pre>\n
As mentioned earlier, concepts are useful to express expectations on the template arguments of a function template or a class template. In the following example, serialize<\/tt> is a function template that expects its template argument to be convertible to a std::string<\/tt>. Similarly, Serializable<\/tt> is a class template that expects the template argument T<\/tt> to be convertible to a std::string<\/tt>.<\/p>\n
template <typename T> requires StringConvertible<T>\r\nvoid serialize(T const & value)\r\n{\t\r\n}\r\n\r\ntemplate <typename T> requires StringConvertible<T>\r\nstruct Serializable\r\n{\r\n\tT value;\r\n};\r\n\r\nint main()\r\n{\r\n\tserialize(foo{});\r\n\tserialize(bar{});         \/\/ error: the associated constraints are not satisfied\r\n\tserialize(foobar{});\r\n\r\n\tSerializable<foo> f;\r\n\tSerializable<bar> b;      \/\/ error: the associated constraints are not satisfied\r\n\tSerializable<foobar> fb;\r\n}<\/pre>\n
If you compile this code, the lines marked with error (in the comments) will produce the following errors:<\/p>\n
\r\nconcepts_test.cpp(50,2) : error C2672: 'serialize': no matching overloaded function found\r\nconcepts_test.cpp(50,17) : error C7602: 'serialize': the associated constraints are not satisfied\r\nconcepts_test.cpp(37) : message : see declaration of 'serialize'\r\n\r\nconcepts_test.cpp(54,18) : error C7602: 'Serializable': the associated constraints are not satisfied\r\nconcepts_test.cpp(43) : message : see declaration of 'Serializable'\r\nconcepts_test.cpp(54,20) : error C7602: 'Serializable': the associated constraints are not satisfied\r\nconcepts_test.cpp(43) : message : see declaration of 'Serializable'\r\nconcepts_test.cpp(54) : error C2641: cannot deduce template arguments for 'Serializable'\r\nconcepts_test.cpp(54,21) : error C2783: 'Serializable<T> Serializable(void)': could not deduce template argument for 'T'\r\nconcepts_test.cpp(43) : message : see declaration of 'Serializable'\r\nconcepts_test.cpp(54,20) : error C2512: 'Serializable': no appropriate default constructor available\r\nconcepts_test.cpp(43,1) : message : see declaration of 'Serializable'<\/pre>\n
The syntax used above (template <typename T> requires StringConvertible<T><\/tt>) to specify the expectations on the template argument is a bit cumbersome. An alternative that is simpler and more intuitive exists:<\/p>\n
template <StringConvertible T>\r\nvoid serialize(T const& value)\r\n{\r\n}\r\n\r\ntemplate <StringConvertible T>\r\nstruct Serializable\r\n{\r\n\tT value;\r\n};<\/pre>\n
All the code shown here compiles with Visual Studio 2019 16.3 Preview 2.<\/p>\n
Of course, this is barely an introduction to concepts. There are many more things you need to learn about concepts, which you can find on thw web. You can learn more about concepts here:<\/p>\n