{"id":6664,"date":"2015-04-29T11:41:00","date_gmt":"2015-04-29T11:41:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/2015\/04\/29\/c11-constant-expressions-in-visual-studio-2015-rc\/"},"modified":"2019-02-18T18:05:05","modified_gmt":"2019-02-18T18:05:05","slug":"c11-constant-expressions-in-visual-studio-2015-rc","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/c11-constant-expressions-in-visual-studio-2015-rc\/","title":{"rendered":"C++11 Constant Expressions in Visual Studio 2015 RC"},"content":{"rendered":"

In Visual Studio 2015 RC<\/a>, we have implemented C++11’s Constant Expressions<\/a>, a feature that has been in development since the November 2013 CTP<\/a>. This article will describe some neat things that you can do with it, the differences in capabilities between this feature’s current and older implementations, and our future plans for it.<\/p>\n

What Are Constant Expressions?<\/h2>\n

The Constant Expressions feature allows you to create, using the constexpr<\/span> keyword, computations that can run during compilation and whose results can be considered const<\/span>. Something can only be declared constexpr<\/span> if it satisfies all necessary constraints that allow it to be evaluated by the compiler using only the information available at compile time.<\/p>\n

What Can They Be Used For?<\/h2>\n

Type Safety<\/h2>\n

Prior to the introduction of constant expressions, it was common to use macros to compute const<\/span> values:\n     #define <\/span>LENGTHOF<\/span>(x) (<\/span>sizeof<\/span>(x) \/ <\/span>sizeof<\/span>(x[0]))<\/span>
     char<\/span><\/span> x[10];<\/span>
     char<\/span> y[<\/span>LENGTHOF<\/span>(x)]; <\/span>\/\/ y also has 10 elements<\/span>\nBut macros are not type safe. The following code compiles despite the fact that x<\/span> is a pointer, which results in the calculation of nonsense:\n     char<\/span> *x;<\/span>
     char<\/span> y[<\/span>LENGTHOF<\/span>(x)];<\/span> \/\/ No error! Expands to (sizeof(char *) \/ sizeof(x[0]))<\/span>\nTo avoid this issue, we can use constant expressions:\n     template<\/span><<\/span>typename <\/span><\/span>T<\/span>, <\/span>size_t <\/span>length><\/span>
     constexpr <\/span><\/span><\/span>size_t<\/span><\/span> lengthof(<\/span>T <\/span>(&)[length])<\/span>
     {<\/span>
         return <\/span>length;<\/span>
     }<\/span>\nThis function works just like the LENGTHOF<\/span> macro:\n     char <\/span>x[10];<\/span>
     char <\/span>y[lengthof(x)];<\/span>\nExcept that the compiler emits an error if x<\/span> is not an array, which prevents this function from being used in ways that don’t make sense:\n     char <\/span>*x;<\/span>
     char <\/span>y[lengthof(x)]; <\/span>\/\/ Error C2784: ‘size_t lengthof(T (&)[N])’: could not deduce template argument for ‘T (&)[N]’ from ‘char *’<\/span><\/p>\n

Generally speaking, you should use constant expressions instead of macros wherever you can, because the former lets the compiler perform the same type checking that it does for normal C++ code.<\/p>\n

Meta-Programming<\/h2>\n

C++’s template system is actually a full-fledged functional programming language, and as such, it is often used to perform complex compile-time computations. But because it was not designed as a general purpose language, it is usually cumbersome and sometimes difficult to express these computations.\nFor example, if for some reason you need to compute exponentiation at the type level, you’d have to write something like:\n     #include <\/span><type_traits><\/span>
     template <\/span><<\/span>int <\/span>x, <\/span>int <\/span>n, <\/span>typename <\/span>Cond <\/span>= <\/span>void<\/span>><\/span> <\/p>\n

     struct <\/span>Exp<\/span>
     {<\/span>
         static <\/span>const <\/span>int <\/span>result =<\/span> Exp<\/span><\/span><x * x, n \/ 2>::result;<\/span>
     };<\/span> <\/p>\n

     template<\/span><<\/span>int <\/span>x, <\/span>int <\/span>n><\/span>
     struct <\/span>Exp<\/span><x, n, std::<\/span>enable_if_t<\/span><n % 2 == 1>><\/span>
     {<\/span>
         static <\/span>const <\/span>int <\/span>result = <\/span>Exp<\/span><x * x, (n – 1) \/ 2>::result * x;<\/span>
     };<\/span> <\/p>\n

     template<\/span><<\/span>int <\/span>x><\/span>
     struct <\/span>Exp<\/span><x, 0><\/span>
     {<\/span>
         static <\/span>const <\/span>int <\/span>result = 1;<\/span>
     };<\/span>\nStrange syntax, spread out cases, and roundabout condition checking hinder one’s understanding of this code, which makes debugging it difficult. Also, since floating point numbers can’t be used as non-type template parameters, this exponentiation “function” will only work for integers, which is a serious limitation. To improve readability and functionality, constant expressions can be used instead:\n     constexpr <\/span> float <\/span> exp(<\/span> float<\/span> x<\/span>,<\/span> int<\/span><\/span> n<\/span>)<\/span>
     {<\/span>
         return <\/span> n <\/span> == 0 ?     1 :<\/span>
                n <\/span> % 2 == 0 ? exp(<\/span>x <\/span> * <\/span> x<\/span> , <\/span> n <\/span> \/ 2) :<\/span>
                             exp(<\/span>x <\/span> * <\/span> x<\/span> , (<\/span>n <\/span> – 1) \/ 2) * <\/span> x<\/span>;<\/span>
     };<\/span>\nBecause we are now using normal C++ expressions, this function is not only much shorter and easier to read, but also capable of handling floating point arguments.<\/p>\n

Known Issues<\/h2>\n

Currently, implicitly-defined constructors aren’t automatically specified as constexpr<\/span> even when they would fulfill all the requirements to be so:\n     struct <\/span>A<\/span>
     {<\/span>
         virtual <\/span>void <\/span>f();<\/span>
     };<\/span> <\/p>\n

     struct <\/span>B <\/span>: <\/span>A<\/span>
     {<\/span>
         constexpr <\/span>B() {}; <\/span>\/\/ error C2134 : ‘A::A’ : call does not result in a constant expression<\/span>
     };<\/span><\/p>\n

To work around this, you need to explicitly define a constexpr<\/span><\/span> constructor for that class:\n     struct <\/span>A<\/span>
     {<\/span>
         virtual <\/span>void <\/span>f();<\/span>
         constexpr <\/span>A() {};<\/span>
     };<\/span><\/p>\n

constexpr<\/span> constructors also can’t yet initialize array data members:\n     struct <\/span>S <\/span>
     {<\/span>
         int <\/span>a[5]; <\/span>\/\/ note: ‘S::a’ was not initialized by the constructor<\/span>
         constexpr <\/span>S() : a() { } <\/span>\/\/ error C2476: ‘constexpr’ constructor does not initialize all members<\/span>
     };<\/span> <\/p>\n

     int<\/span><\/span><\/span> main()<\/span>
     {<\/span>
         constexpr <\/span>S <\/span>b; <\/span>\/\/ error C2127: ‘b’: illegal initialization of ‘constexpr’ entity with a non-constant expression<\/span>
     }<\/span>\nWe plan to fix these bugs, among others, in Visual Studio 2015 RTM or Update 1.<\/p>\n

Next Steps<\/h2>\n

C++14’s “generalized” constant expressions feature relaxes some restrictions with the constructs described above. For example, in C++14, constexpr<\/span><\/span> functions can contain statements, which will allow them to make use of loops and modify local variables. We plan to implement C++14 constant expressions in the near future.<\/span><\/a><\/p>\n

Since we are always looking for ways to improve our compiler, please make heavy use of this feature in your code and keep sending us feedback through Microsoft Connect<\/a> or the Visual Studio feedback tool<\/a>. You can also contact me directly at kaniu@microsoft.com<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"

In Visual Studio 2015 RC, we have implemented C++11’s Constant Expressions, a feature that has been in development since the November 2013 CTP. This article will describe some neat things that you can do with it, the differences in capabilities between this feature’s current and older implementations, and our future plans for it. What Are […]<\/p>\n","protected":false},"author":299,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[137],"class_list":["post-6664","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus","tag-announcements"],"acf":[],"blog_post_summary":"

In Visual Studio 2015 RC, we have implemented C++11’s Constant Expressions, a feature that has been in development since the November 2013 CTP. This article will describe some neat things that you can do with it, the differences in capabilities between this feature’s current and older implementations, and our future plans for it. What Are […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/6664","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/299"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=6664"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/6664\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=6664"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=6664"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=6664"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}