{"id":6302,"date":"2022-02-07T06:59:47","date_gmt":"2022-02-07T06:59:47","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/constespr-if\/"},"modified":"2023-06-26T09:13:39","modified_gmt":"2023-06-26T09:13:39","slug":"constespr-if","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/constespr-if\/","title":{"rendered":"constexpr if"},"content":{"rendered":"

In today’s post, I want to introduce an exciting C++17 feature: constexpr if. constexpr if<\/code> enables it to compile source code conditionally and can be used for nice tricks at compile time.<\/p>\n

<\/p>\n

 <\/p>\n

\"constexprIf\"<\/p>\n

Introducing constexpr if<\/code> is straightforward.<\/p>\n

<\/p>\n

\n
template<\/span> <<\/span>typename<\/span> T><\/span>\r\nauto<\/span> getValue(T t) {\r\n    if<\/span> constexpr (std::<\/span>is_pointer_v<<\/span>T><\/span>)      \/\/ (1)<\/span><\/em>\r\n        return<\/span> *<\/span>t; \/\/ deduces return type to int for T = int*<\/span>\r\n    else                                    <\/span> <\/span>\/\/ (2)<\/span><\/em><\/span>\r\n        return<\/span> t;  \/\/ deduces return type to int for T = int<\/span>\r\n}\r\n<\/pre>\n<\/div>\n
<\/p>\n
 <\/p>\n
The code snippet shows one exciting fact about constexpr if<\/code>: Although it is called constexpr if<\/code>, it is used as if constexpr<\/code>: if constexpr (std::is_pointer_v<T><\/code>).<\/p>\n
If T<\/code> is a pointer, the if branch in line (1) will be compiled. If not, the else branch in line (2). Two points are important to mention. The function getValue<\/code> has two different return types, and both branches of the if<\/code> statement have to be valid.<\/p>\n
The expression in constexpr if has to be a compile-time predicate. A compile time predicate is a function that returns a boolean and runs at compile time. I used in the code snippet a function from the type-traits library<\/a>. Alternatively, in C++20, you can use a concept. Here is the equivalent example using the concept std::integral:<\/code><\/p>\n
<\/p>\n
\n
template<\/span> <<\/span>typename<\/span> T><\/span>\r\nauto<\/span> get_value(T t) {\r\n    if<\/span> constexpr (std::<\/span>integral<<\/span>T><\/span>)          \/\/ (1)<\/span>\r\n        return<\/span> *<\/span>t; \/\/ deduces return type to int for T = int*<\/span>\r\n    else<\/span>                                     \/\/ (2)<\/span>\r\n        return<\/span> t;  \/\/ deduces return type to int for T = int<\/span>\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I see, the two code snippets are not so impressive. Let me continue with template metaprogramming.<\/p>\n
Thanks to constexpr if<\/code>, template metaprogramming is often easier to write and read.<\/p>\n<\/p>\n
Template Metaprogramming with constexpr if<\/code><\/h2>\n
Metaprogramming is programming on programs. C++ applies metaprogramming at compile time. It started in C++98 with template metaprogramming, was formalized in C++11 with the type-traits library, and since C++11 has steadily improved.<\/p>\n
Here is the “Hello World” of template metaprogramming: calculating the factorial of a number:<\/p>\n
\n
\/\/ factorial.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>int<\/span> N><\/span>                                                                 \/\/ (2)<\/span>\r\nstruct<\/span> Factorial{\r\n    static<\/span> int<\/span> const<\/span> value =<\/span> N *<\/span> Factorial<<\/span>N-<\/span>1<\/span>>::<\/span>value;\r\n};\r\n\r\ntemplate<\/span> <><\/span>                                                                      \/\/ (3)<\/span>\r\nstruct<\/span> Factorial<<\/span>1<\/span>><\/span>{\r\n    static<\/span> int<\/span> const<\/span> value =<\/span> 1<\/span>;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n';\r\n    \r\n    std::<\/span>cout <<<\/span> \"Factorial<5>::value: \"<\/span> <<<\/span> Factorial<<\/span>5<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;    \/\/ (1)<\/span>\r\n    std::<\/span>cout <<<\/span> \"Factorial<10>::value: \"<\/span> <<<\/span> Factorial<<\/span>10<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;  \/\/ (4)<\/span><\/em>\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The call factorial<5>::value<\/code> (line 1) causes the instantiation of the primary or general template (line 2). During this instantiation, Factorial<4>::value<\/code> will be instantiated. This recursion will end if the fully specialized class template Factorial<1> <\/code>kicks in (line 3).<\/p>\n
If you want to know more about template metaprogramming, read my previous posts:<\/p>\n
    \n
  1. Template Metaprogramming – How it All Started<\/a><\/li>\n
  2. Template Metaprogramming – How it Works<\/a><\/li>\n
  3. Template Metaprogramming – Hybrid Programming<\/a><\/li>\n<\/ol>\n
    Let me rewrite the program using constexpr i<\/code>f:<\/p>\n
    <\/p>\n
    \n
    \/\/ factorialConstexprIf.cpp<\/span>\r\n\r\ntemplate<\/span> <<\/span>int<\/span> N><\/span>                                              \/\/ (1)<\/span>\r\nstruct<\/span> Factorial{\r\n    static<\/span> int<\/span> const<\/span> value =<\/span> N *<\/span> Factorial<<\/span>N-<\/span>1<\/span>>::<\/span>value;\r\n};\r\n\r\ntemplate<\/span> <><\/span>                                                   \/\/ (2)<\/span>\r\nstruct<\/span> Factorial<<\/span>1<\/span>><\/span>{\r\n    static<\/span> int<\/span> const<\/span> value =<\/span> 1<\/span>;\r\n};\r\n\r\ntemplate<\/span> <<\/span>int<\/span> N><\/span>                                              \/\/ (3)<\/span>\r\nconstexpr int<\/span> factorial() {\r\n    if<\/span> constexpr (N >=<\/span> 2<\/span>) \r\n        return<\/span> N *<\/span> factorial<<\/span>N-<\/span>1<\/span>><\/span>();\r\n    else<\/span> \r\n        return<\/span> N;\r\n}\r\n\r\nint<\/span> main(){\r\n    \r\n    static_assert(Factorial<<\/span>5<\/span>>::<\/span>value ==<\/span> factorial<<\/span>5<\/span>><\/span>());     \/\/ (4)             <\/span>\r\n    static_assert(Factorial<<\/span>10<\/span>>::<\/span>value ==<\/span> factorial<<\/span>10<\/span>><\/span>());   \/\/ (4)<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    The primary template of Factorial<\/code> (line 1) becomes the if condition in the constexpr<\/code> function factorial<\/code> (line 3), and the full specialization of Factorial<\/code> for 1 (line 2) becomes the else case in the constexpr<\/code> function factorial (line 3). Of course, the class template Factorial<\/code> and the constexpr<\/code> function factorial<\/code> return the same result and are executed at compile time (line 4). To make it short, I prefer the constexpr function using constexpr if<\/code> because it reads almost such as a usual function.<\/p>\n
    Let’s do it once more. Here is the infamous Fibonacci function-based template metaprogramming (Fibonacci<\/code>) and constexpr if (fibonacci).
    <\/code><\/p>\n
    <\/p>\n
    \n
    \/\/ fibonacciConstexprIf.cpp<\/span>\r\n\r\ntemplate<\/span><<\/span>int<\/span> N><\/span>\r\nconstexpr int<\/span> fibonacci()\r\n{\r\n    if<\/span> constexpr (N>=<\/span>2<\/span>)\r\n        return<\/span> fibonacci<<\/span>N-<\/span>1<\/span>><\/span>() +<\/span> fibonacci<<\/span>N-<\/span>2<\/span>><\/span>();\r\n    else<\/span>\r\n        return<\/span> N;\r\n}\r\n\r\ntemplate<\/span> <<\/span>int<\/span> N><\/span>                                                  \/\/ (1)            <\/span>\r\nstruct<\/span> Fibonacci{\r\n    static<\/span> int<\/span> const<\/span> value =<\/span> Fibonacci<<\/span>N-<\/span>1<\/span>>::<\/span>value +<\/span> Fibonacci<<\/span>N-<\/span>2<\/span>>::<\/span>value;\r\n};\r\n\r\ntemplate<\/span> <><\/span>                                                      \/\/ (2)                <\/span>\r\nstruct<\/span> Fibonacci<<\/span>1<\/span>><\/span>{\r\n    static<\/span> int<\/span> const<\/span> value =<\/span> 1<\/span>;\r\n};\r\n\r\ntemplate<\/span> <><\/span>                                                      \/\/ (3)                <\/span>\r\nstruct<\/span> Fibonacci<<\/span>0<\/span>><\/span>{\r\n    static<\/span> int<\/span> const<\/span> value =<\/span> 0<\/span>;\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    static_assert(fibonacci<<\/span>7<\/span>><\/span>() ==<\/span> 13<\/span>);\r\n    static_assert(fibonacci<<\/span>7<\/span>><\/span>() ==<\/span> Fibonacci<<\/span>7<\/span>>::<\/span>value);\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    The constexpr<\/code> function fibonacci<\/code> is straightforward to read. The entire functionality is in one function body. In contrast, the template metaprogram Fibonacci<\/code> requires three classes. The primary template (line 1) and the two full specializations for the values 1 and 0 (lines 2 and 3).<\/p>\n
    More Information about my Mentoring Program, “Fundamentals for C++ Professionals”<\/h2>\n
    I created the platform for my new mentoring on https:\/\/www.modernescpp.org\/<\/a>. You can skip through each of the 28 lessons. I also presented the 6th lesson about move semantics and perfect forwarding in the post ‘More Information about my Mentoring Program “Fundamentals for C++ Professionals”‘<\/a>. Here are the next steps before I start the mentoring program.<\/p>\n