{"id":4389,"date":"2021-12-23T12:17:28","date_gmt":"2021-12-23T10:17:28","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=4389"},"modified":"2021-12-23T22:35:31","modified_gmt":"2021-12-23T20:35:31","slug":"use-cases-of-variable-templates-in-cpp","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2021\/12\/23\/use-cases-of-variable-templates-in-cpp\/","title":{"rendered":"Use Cases of Variable Templates in C++"},"content":{"rendered":"\n

Since C++14 variables can also be templatized. A variable template defines a family of variable (when declared at namespace scope) or a family of static data members (when defined at class scope). The question is, what is the benefit of variable templates?<\/p>\n\n\n\n\n\n\n\n

I have seen the example of defining PI as a variable template quite often. Here it is from cppreference<\/a>:<\/p>\n\n\n\n

template<class T>\nconstexpr T pi = T(3.1415926535897932385L);  \/\/ variable template\n \ntemplate<class T>\nT circular_area(T r)                         \/\/ function template\n{\n    return pi<T> * r * r;                    \/\/ pi<T> is a variable template instantiation\n}<\/pre>\n\n\n\n
This is not necessarily a bad example but I think more complex examples would be helpful to better understand the use of variable templates. I’ll try to share such examples here. <\/p>\n\n\n\n
Use case: reducing code<\/h3>\n\n\n\n
The stduuid library<\/a> provides a cross-platform implementation for universally unique identifiers (uuids or guids). It features a function called to_string()<\/code> that returns a string representation of a uuid, such as \"47183823-2574-4bfd-b411-99ed177d3e43\"<\/code>. Recently, I have optimized the implementation of this function for speed. At the first attempt, this function looked as follows:<\/p>\n\n\n\n
template<class CharT = char,\n         class Traits = std::char_traits<CharT>,\n         class Allocator = std::allocator<CharT>>\ninline std::basic_string<CharT, Traits, Allocator> to_string(uuid const& id)\n{\n   CharT uustr[] = \"00000000-0000-0000-0000-000000000000\";\n   constexpr CharT encode[] = \"0123456789abcdef\";\n\n   for (size_t i = 0, index = 0; i < 36; ++i)\n   {\n      if (i == 8 || i == 13 || i == 18 || i == 23)\n      {\n         continue;\n      }\n      uustr[i] = encode[id.data[index] >> 4 & 0x0f];\n      uustr[++i] = encode[id.data[index] & 0x0f];\n      index++;\n   }\n\n   return uustr;\n}<\/pre>\n\n\n\n
You can create a uuid from a string and then convert back to string as follows:<\/p>\n\n\n\n
auto guid = uuids::uuid::from_string(\"47183823-2574-4bfd-b411-99ed177d3e43\").value();\nREQUIRE(uuids::to_string(guid) == \"47183823-2574-4bfd-b411-99ed177d3e43\");<\/pre>\n\n\n\n
This works fine, but if you try to convert to a string of wide characters, then it no longer works:<\/p>\n\n\n\n
auto guid = uuids::uuid::from_string(\"47183823-2574-4bfd-b411-99ed177d3e43\").value();\nREQUIRE(uuids::to_string<wchar_t>(guid) == L\"47183823-2574-4bfd-b411-99ed177d3e43\");<\/pre>\n\n\n\n
This snippet produces the following errors in VC++:<\/p>\n\n\n\n
1>test_uuid.cpp\n1>uuid.h(614,1): error C2440: 'initializing': cannot convert from 'const char [37]' to 'CharT []'\n1>        with\n1>        [\n1>            CharT=wchar_t\n1>        ]\n1>uuid.h(614,21): message : The type of the string literal is not compatible with the type of the array\n1>test_uuid.cpp(191): message : see reference to function template instantiation 'std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> uuids::to_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>(const uuids::uuid &)' being compiled\n1>uuid.h(615,1): error C2440: 'initializing': cannot convert from 'const char [17]' to 'const CharT []'\n1>        with\n1>        [\n1>            CharT=wchar_t\n1>        ]\n1>uuid.h(615,32): message : The type of the string literal is not compatible with the type of the array\n1>uuid.h(615,32): error C2131: expression did not evaluate to a constant\n1>uuid.h(615,32): message : a non-constant (sub-)expression was encountered\n<\/pre>\n\n\n\n
A possible solution to fix this problem is to specialize to_string()<\/code> for wchar_t<\/code>. This can be done as follows:<\/p>\n\n\n\n
template<>\ninline std::wstring to_string(uuid const& id)\n{\n   wchar_t uustr[] = L\"00000000-0000-0000-0000-000000000000\";\n   constexpr wchar_t encode[] = L\"0123456789abcdef\";\n\n   for (size_t i = 0, index = 0; i < 36; ++i)\n   {\n      if (i == 8 || i == 13 || i == 18 || i == 23)\n      {\n         continue;\n      }\n      uustr[i] = encode[id.data[index] >> 4 & 0x0f];\n      uustr[++i] = encode[id.data[index] & 0x0f];\n      index++;\n   }\n\n   return std::wstring(uustr);\n}<\/pre>\n\n\n\n
This works fine, the compiler errors are gone and the program runs as expected. <\/p>\n\n\n\n
However, we now have identical duplicate code. The only difference is the initialization of the uustr<\/code> and encode<\/code> arrays. This kinda defeats the purpose of template to avoid repetitive code. We can fix this, with the help of variable templates. Here is how:<\/p>\n\n\n\n
First, we will define two variable templates as follows:<\/p>\n\n\n\n
namespace detail\n{\n   template <typename CharT>\n   constexpr CharT empty_guid[37] = \"00000000-0000-0000-0000-000000000000\";\n\n   template <typename CharT>\n   constexpr CharT guid_encoder[17] = \"0123456789abcdef\";\n}<\/pre>\n\n\n\n
We will need to specialize them for the wchar_t<\/code> type so that we can initialize them with wide string literals. This is also done in the detail<\/code> namespace (not shown below):<\/p>\n\n\n\n
template <>\nconstexpr wchar_t empty_guid<wchar_t>[37] = L\"00000000-0000-0000-0000-000000000000\";\n\ntemplate <>\nconstexpr wchar_t guid_encoder<wchar_t>[17] = L\"0123456789abcdef\";<\/pre>\n\n\n\n
Having these, we can change the implementation of the to_string()<\/code> function template as follows:<\/p>\n\n\n\n
template<class CharT = char,\n         class Traits = std::char_traits<CharT>,\n         class Allocator = std::allocator<CharT>>\ninline std::basic_string<CharT, Traits, Allocator> to_string(uuid const & id)\n{\n   std::basic_string<CharT, Traits, Allocator> uustr{detail::empty_guid<CharT>};\n\n   for (size_t i = 0, index = 0; i < 36; ++i)\n   {\n      if (i == 8 || i == 13 || i == 18 || i == 23)\n      {\n         continue;\n      }\n      uustr[i] = detail::guid_encoder<CharT>[id.data[index] >> 4 & 0x0f];\n      uustr[++i] = detail::guid_encoder<CharT>[id.data[index] & 0x0f];\n      index++;\n   }\n\n   return uustr;\n}<\/pre>\n\n\n\n
We only have a primary template, there is no need for the explicit full specialization for wchar_t<\/code>. We do have that for the variable templates, so there is some duplicate code, but the implementation of to_string()<\/code> (which contains much more code) is no longer duplicated.<\/p>\n\n\n\n
Use case: improve readability<\/h3>\n\n\n\n
Apart from this, there is also the use case of simplifying the code when using type traits. Type traits that help us query properties of types provide a data member Boolean called value<\/code>, which is initialized to true<\/code> or false<\/code> depending on the property of a type. Here is an example:<\/p>\n\n\n\n
template <typename T>\nstruct is_floating_point\n{\n   static constexpr bool value = false;\n};\n\ntemplate <>\nstruct is_floating_point<float>\n{\n   static constexpr bool value = true;\n};\n\ntemplate <>\nstruct is_floating_point<double>\n{\n   static constexpr bool value = true;\n};\n\ntemplate <>\nstruct is_floating_point<long double>\n{\n   static constexpr bool value = true;\n};<\/pre>\n\n\n\n
There is a primary template and three specializations for float<\/code>, double<\/code>, and long doble<\/code>. We can use this type trait to constrain the template arguments of a function as follows:<\/p>\n\n\n\n
template <typename T>\nrequires is_floating_point<T>::value\nauto add(T a, T b)\n{\n   return a + b;\n}<\/pre>\n\n\n\n
However, this requires the use of the verbose ::value<\/code> which can lead to hard to read code in many cases. This is where a variable template can help improve readability. We can define one as follows:<\/p>\n\n\n\n
template <typename T>\nconstexpr bool is_floating_point_v = is_floating_point<T>::value;<\/pre>\n\n\n\n
And we can use it as shown below:<\/p>\n\n\n\n
template <typename T>\nrequires is_floating_point_v<T>\nauto add(T a, T b)\n{\n   return a + b;\n}<\/pre>\n\n\n\n
Starting with C++17, the standard defines variable templates like this for all the type traits from the standard library. There is, of course, a std::is_floating_point<\/code> class template, and a std::is_floating_point_v<\/code> variable template.<\/p>\n\n\n\n
Conclusion<\/h3>\n\n\n\n
In conclusion, variable templates are an important feature in the language to help us reduce template code and improve their readability.<\/p>\n\n\n\n
If you have other good examples for using variable templates please share them in the comments.<\/p>\n","protected":false},"excerpt":{"rendered":"
Since C++14 variables can also be templatized. A variable template defines a family of variable (when declared at namespace scope) or a family of static data members (when defined at class scope). The question is, what is the benefit of variable templates?<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[7],"tags":[451,513,475,323],"class_list":["post-4389","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-c14","tag-c17","tag-templates"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t