{"id":4203,"date":"2021-03-18T22:50:49","date_gmt":"2021-03-18T20:50:49","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=4203"},"modified":"2021-03-19T12:54:45","modified_gmt":"2021-03-19T10:54:45","slug":"express-one-of-multiple-options-in-a-nice-way","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2021\/03\/18\/express-one-of-multiple-options-in-a-nice-way\/","title":{"rendered":"Express one of multiple options in a nice way"},"content":{"rendered":"\n

We often find ourselves writing if statements where a variable is compared with several values either to check if it matches one of them or that it doesn\u2019t match any. Here is an example:<\/p>\n\n\n\n

int option = ...;\n\n\/\/ at least a value is matched\nif (option == 12 || option == 23 || option == 42)\n{\n   std::cout << \"it's a good option\\n\";\n}\n\n\/\/ no value is matched\nif (option != 12 && option != 23 && option != 42)\n{\n   std::cout << \"it's a bad option\\n\";\n}<\/pre>\n\n\n\n
This example has three comparison values for each case, but it could be 5, or 10, or any number. If it\u2019s too many then perhaps a different approach should be taken. However, the question is, how do we express this in a simpler way in C++, rather than a long if condition?

Before we continue, please ignore the magic numbers used here. They are just some values to show the point in a simple manner. In real code, you should use enums, or constexpr values, or (evil option) macros. Here is a real example from some code I\u2019m working with:<\/p>\n\n\n\n
if (iCtrlType != CTRLTYPE_BUTTON &&\n    iCtrlType != CTRLTYPE_CHECKBOX &&\n    iCtrlType != CTRLTYPE_COMBOBOX &&\n    iCtrlType != CTRLTYPE_COMBOGRID &&\n    iCtrlType != CTRLTYPE_DROPDOWNCAL &&\n    iCtrlType != CTRLTYPE_EDIT)\n{\n   \/\/ do something\n}<\/pre>\n\n\n\n
In SQL, we can write statements of the following forms:<\/p>\n\n\n\n
SELECT column-names\nFROM table-name\nWHERE column-name IN (values) <\/pre>\n\n\n\n
SELECT column-names\nFROM table-name\nWHERE column-name NOT IN (values)<\/pre>\n\n\n\n
Can we achieve something similar to the SQL IN<\/code> operator in C++? Well, in C++11 we have std::all_of<\/code>, std::any_of<\/code>, std::none_of<\/code><\/a> that can help express the same intent. Using any_of<\/code> and none_of<\/code> we can rewrite the two if statements above as following:<\/p>\n\n\n\n
std::vector<int> good_options{ 12, 23, 42 };\nif (std::any_of(good_options.begin(), good_options.end(), [option](int const o) { return option == o; }))\n{\n   std::cout << \"it's a good option\\n\";\n}\n\nif (std::none_of(good_options.begin(), good_options.end(), [option](int const o) { return option == o; }))\n{\n   std::cout << \"it's a bad option\\n\";\n}<\/pre>\n\n\n\n
This is very verbose, and personally, I don\u2019t like it at all. I don\u2019t like it because you need to put the values in a container (a vector<\/code> here) and you need to supply iterators to the beginning and the end of the container, as well as a lambda to compare your value to every value in the container. There are simpler ways to do this.<\/p>\n\n\n\n
In C++20, we have ranges, and the ranges library provides a new implementation for these algorithms, called std::ranges::all_of<\/code>, std::ranges::any_of<\/code>, std::ranges::none_of<\/code><\/a>. Using these algorithms, we can simply supply a range (such as a container) instead of the pair of begin-end iterators. Therefore, our code would look as the following:<\/p>\n\n\n\n
std::vector<int> good_options{ 12, 23, 42 };\n\nif (std::ranges::any_of(good_options, [option](int const o) { return option == o; }))\n{\n   std::cout << \"it's a good option\\n\";\n}\n\nif (std::ranges::none_of(good_options, [option](int const o) { return option == o; }))\n{\n   std::cout << \"it's a bad option\\n\";\n}<\/pre>\n\n\n\n
This is simpler, but I\u2019m still not satisfied. We still need to put the values in a container. It\u2019s not possible to simplify the code as follows:<\/p>\n\n\n\n
if (std::ranges::any_of({ 12, 23, 42 }, [option](int const o) { return option == o; }))\n{\n   std::cout << \"it's a good option\\n\";\n}<\/pre>\n\n\n\n
That\u2019s closer to the code I would like to be able to write. That code is shown below:<\/p>\n\n\n\n
if (any_of({ 12, 23, 42 }, option))\n{\n   std::cout << \"it's a good option\\n\";\n}\n\nif (none_of({ 12, 23, 42 }, option))\n{\n    std::cout << \"it's a bad option\\n\";\n}<\/pre>\n\n\n\n
This is an in-place sequence of values and a variable, instead of a lambda. This does not work out of the box with any standard algorithm, but we can easily write this any_of<\/code> and none_of<\/code> ourselves. A possible implementation is listed in the following snippet:<\/p>\n\n\n\n
template <typename T>\nbool any_of(std::initializer_list<T> r, T const v)\n{\n   return std::any_of(r.begin(), r.end(), [v](int const x) { return v == x; });\n}\n\ntemplate <typename T>\nbool none_of(std::initializer_list<T> r, T const v)\n{\n   return std::none_of(r.begin(), r.end(), [v](int const x) { return v == x; });\n}<\/pre>\n\n\n\n
I know people will say that std::initializer_list<\/code> is not a container and should not be used as such, but I don\u2019t really feel it is used as one in this snippet. It basically holds a temporary sequence of values that are iterated with the std::any_of<\/code> and std::none_of_<\/code> algorithms. This implementation will enable us to write code as in the previous snippet.<\/p>\n\n\n\n
However, there is one more simplification that we could think of, which is shown here:<\/p>\n\n\n\n
if (any_of(option, 12, 23, 42))\n{\n   std::cout << \"it's a good option\\n\";\n}\n\nif (none_of(option, 12, 23, 42))\n{\n   std::cout << \"it's a bad option\\n\";\n}<\/pre>\n\n\n\n
There is no sequence of values, just a variable number of arguments, passed to a function. That means, this time, the implementation of any_of<\/code> and none_of<\/code> should be based on variadic templates. The way I wrote it, using fold expressions, is as follows:<\/p>\n\n\n\n
template <typename T, typename ...Args>\nbool any_of(T const v, Args&&... args)\n{\n   return ((args == v) || ...);\n}\n\ntemplate <typename T, typename ...Args>\nbool none_of(T const v, Args&&... args)\n{\n   return ((args != v) && ...);\n}<\/pre>\n\n\n\n
This time, the variable is supplied as the first argument, and the values to test against follow it. Unfortunately, this implementation allows calls without any values to compare to, such as any_of(option)<\/code>. However, that is relatively simple to avoid by adding a static_assert<\/code> statement, as follows:<\/p>\n\n\n\n
template <typename T, typename ...Args>\nbool any_of(T const v, Args&&... args)\n{\n   static_assert(sizeof...(args) > 0, \"You need to supply at least one argument.\");\n   return ((args == v) || ...);\n}\n\ntemplate <typename T, typename ...Args>\nbool none_of(T const v, Args&&... args)\n{\n   static_assert(sizeof...(args) > 0, \"You need to supply at least one argument.\");\n   return ((args != v) && ...);\n}<\/pre>\n\n\n\n
If you don\u2019t like static_assert<\/code>s and you are using C++20, then you can use constraints to require the parameter pack to have at least one element. The change is relatively simple and looks as the following:<\/p>\n\n\n\n
template <typename T, typename ...Args>\nbool any_of(T const v, Args&&... args) requires (sizeof...(args) > 0)\n{\n   return ((args == v) || ...);\n}\n\ntemplate <typename T, typename ...Args>\nbool none_of(T const v, Args&&... args) requires (sizeof...(args) > 0)\n{\n   return ((args != v) && ...);\n}<\/pre>\n\n\n\n
As you can see, C++ offers different standard and DIY ways of replacing some category of if statements with a function call.<\/p>\n","protected":false},"excerpt":{"rendered":"
We often find ourselves writing if statements where a variable is compared with several values either to check if it matches one of them or that it doesn’t match any. Here is an example:<\/p>\n
int option = ...;\r\n\r\n\/\/ at lease a value is matched\r\nif (option == 12 || option == 23 || option == 42)\r\n{\r\n   std::cout << \"it's a good option\\n\";\r\n}\r\n\r\n\/\/ no value is matched\r\nif (option != 12 && option != 23 && option != 42)\r\n{\r\n   std::cout << \"it's a bad option\\n\";\r\n}<\/pre>\n
This example has three comparison values for each case, but it could be 5, or 10, or any number. If it’s too many then perhaps a different approach should be taken. However, the question is, how do we express this in a simpler way in C++, rather than a long if condition?<\/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,543,635,579],"class_list":["post-4203","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-c20","tag-constraints","tag-ranges"],"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