{"id":7321,"date":"2015-12-02T17:00:00","date_gmt":"2015-12-02T17:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/2015\/12\/02\/partial-support-for-expression-sfinae-in-vs-2015-update-1\/"},"modified":"2019-04-18T09:31:07","modified_gmt":"2019-04-18T09:31:07","slug":"partial-support-for-expression-sfinae-in-vs-2015-update-1","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/partial-support-for-expression-sfinae-in-vs-2015-update-1\/","title":{"rendered":"Partial Support for Expression SFINAE in VS 2015 Update 1"},"content":{"rendered":"

In Visual Studio 2015 Update 1, we added partial support for C++11 core language feature Expression SFINAE.<\/p>\n

What is SFINAE?<\/h2>\n

SFINAE<\/a> is an acronym for ‘Substitution Failure Is Not An Error’. The idea is that when the compiler tries to specialize a function template during overload resolution, it is ok if the specialization fails as long as there are other valid candidates. C++11 introduced features like decltype and constexpr, and it is more common to have expressions during the template argument deduction and substitution process. The C++ standards committee clarified the SFINAE rules for expressions in C++11.<\/p>\n

Why partial implementation of Expression SFINAE?<\/h2>\n

It’s partial for a couple of reasons:<\/p>\n

    \n
  1. We are progressively improving the parser for the Visual C++ compiler with an eye towards complete conformance for the Expressions SFINAE feature. For some insights into this work, see Rejuvenating the Microsoft C\/C++ Compiler<\/a> by Jim Springfield.<\/li>\n
  2. In Visual Studio 2015 RTM, we don’t implement SFINAE rules for expressions and have limited support for Expression SFINAE. Improvements to Expression SFINAE will start with Visual Studio 2015 Update 1 and will incrementally become conformant to the C++11 Standard.<\/li>\n<\/ol>\n

    What did we do?<\/h2>\n

    We are still using our old token stream-based approach and are not yet using a Recursive Descent Parse tree, so there are still some unsupported scenarios<\/a>. For this release, we fixed the following issues:<\/p>\n

    \"\"<\/a><\/p>\n

    Thanks to everyone who provided feedback!<\/p>\n

    Supported Scenarios in Update 1<\/h2>\n

    There are four supported scenarios.<\/p>\n

    Using dependent expression in default argument of template type parameter of function template or type of function parameter:<\/strong><\/p>\n

    #include<\/span><\/a><type_traits><\/span><\/span><\/p>\n

     <\/span><\/span><\/p>\n

    template<\/span><\/span> <<\/span><\/span>typename<\/span><\/span>T<\/span><\/span>><\/span><\/span><\/p>\n

    class<\/span><\/span>A<\/span><\/span><\/p>\n

    {<\/span><\/span><\/p>\n

    public<\/span><\/span>:<\/span><\/span><\/p>\n

       <\/span><\/span><\/span>explicit<\/span><\/span> A(<\/span><\/span>T<\/span><\/span>const<\/span><\/span>&);<\/span><\/span><\/p>\n

       <\/span><\/span><\/span>template<\/span><\/span> <<\/span><\/span>typename<\/span><\/span>U<\/span><\/span>, <\/span><\/span>typename<\/span><\/span>V<\/span><\/span> = std::<\/span><\/span>enable_if_t<\/span><\/span><<\/span><\/span>!std::<\/span><\/span>is_same<\/span><\/span><<\/span><\/span>U<\/span><\/span>, <\/span><\/span>T<\/span><\/span>>::value<\/span><\/span>> ><\/span><\/span><\/p>\n

       <\/span><\/span><\/span>explicit<\/span><\/span> A(<\/span><\/span>U<\/span><\/span>const<\/span><\/span>&);<\/span><\/span><\/p>\n

    };<\/span><\/span><\/p>\n

     <\/span><\/span><\/p>\n

    template<\/span><\/span> <<\/span><\/span>typename<\/span><\/span>T<\/span><\/span>><\/span><\/span><\/p>\n

    class<\/span><\/span>B<\/span><\/span><\/p>\n

    {<\/span><\/span><\/p>\n

    public<\/span><\/span>:<\/span><\/span><\/p>\n

       <\/span><\/span><\/span>enum<\/span><\/span> { M = 1 };<\/span><\/span><\/p>\n

       <\/span><\/span><\/span>template<\/span><\/span> <<\/span><\/span>int<\/span><\/span> I><\/span><\/span><\/p>\n

       <\/span><\/span><\/span>void<\/span><\/span> foo(std::<\/span><\/span>enable_if_t<\/span><\/span><<\/span><\/span>(I == M)<\/span><\/span>>* = <\/span><\/span>nullptr<\/span><\/span>);<\/span><\/span><\/p>\n

       <\/span><\/span><\/span>template<\/span><\/span> <<\/span><\/span>int<\/span><\/span> I><\/span><\/span><\/p>\n

       <\/span><\/span><\/span>void<\/span><\/span> foo(std::<\/span><\/span>enable_if_t<\/span><\/span><<\/span><\/span>(I != M)<\/span><\/span>>* = <\/span><\/span>nullptr<\/span><\/span>);<\/span><\/span><\/p>\n

     <\/span><\/span><\/p>\n

       <\/span><\/span><\/span>template<\/span><\/span> <<\/span><\/span>int<\/span><\/span> I><\/span><\/span><\/p>\n

       <\/span><\/span><\/span>void<\/span><\/span> g() { foo<I + 1>(); }  <\/span><\/span><\/span>\/\/ VS2015 RTM gives error C2668: ‘B<int>::foo’: ambiguous call to overloaded function<\/span><\/span><\/p>\n

    };<\/span><\/span><\/p>\n

     <\/span><\/span><\/p>\n

    void<\/span><\/span> f(<\/span><\/span>B<\/span><\/span><<\/span><\/span>int<\/span><\/span>> <\/span><\/span>b<\/span><\/span>)<\/span><\/span><\/p>\n

    {<\/span><\/span><\/p>\n

       <\/span><\/span><\/span>b<\/span><\/span>.g<0>();<\/span><\/span><\/p>\n

       <\/span><\/span><\/span>A<\/span><\/span><<\/span><\/span>int<\/span><\/span>>(0);<\/span><\/span><\/p>\n

    }<\/p>\n

    Using dependent decltype in the default argument of a template type parameter of a class template:<\/strong><\/p>\n

    #include<\/span><type_traits><\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span> <<\/span>class<\/span>C<\/span>, <\/span>typename<\/span>T<\/span> = <\/span>decltype<\/span>(&<\/span>C<\/span>::m)><\/span><\/p>\n

    struct<\/span>M<\/span><\/p>\n

    {<\/span><\/p>\n

       <\/span><\/span>typedef<\/span>T<\/span>type<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

     <\/span><\/p>\n

    struct<\/span>fail_type<\/span> {};<\/span><\/p>\n

    template<\/span><<\/span>typename<\/span>T<\/span>> <\/span>typename<\/span>M<\/span><<\/span>T<\/span>>::<\/span>type<\/span> test(<\/span>void<\/span> *);<\/span><\/p>\n

    template<\/span><<\/span>typename<\/span>T<\/span>> <\/span>fail_type<\/span> test(…);<\/span><\/p>\n

     <\/span><\/p>\n

    struct<\/span>S1<\/span> { <\/span>int<\/span> m; };<\/span><\/p>\n

    struct<\/span>S2<\/span> { };<\/span><\/p>\n

     <\/span><\/p>\n

    static_assert<\/span>(!std::<\/span>is_same<\/span><<\/span>decltype<\/span>(test<<\/span>S1<\/span>>(<\/span>nullptr<\/span>)), <\/span>fail_type<\/span>>::value, <\/span>“fail”<\/span>); <\/span>\/\/ fail in VS2015 RTM<\/span><\/p>\n

    static_assert<\/span>(std::<\/span>is_same<\/span><<\/span>decltype<\/span>(test<<\/span>S2<\/span>>(<\/span>nullptr<\/span>)), <\/span>fail_type<\/span>>::value, <\/span>“fail”<\/span>);<\/span> <\/span><\/p>\n

    Using dependent decltype in the type of a template non-type argument:<\/strong><\/p>\n

    #include<\/span><type_traits><\/span><\/p>\n

    using<\/span> namespace<\/span> std;<\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span> <<\/span>typename<\/span> T<\/span>, <\/span>typename<\/span> enable_if<\/span><<\/span>is_void<\/span><<\/span>decltype<\/span>(declval<<\/span>T<\/span>>().f()<\/span>)>::value, <\/span>int<\/span>>::<\/span>type<\/span> V = 0><\/span><\/p>\n

    char<\/span> f(<\/span>T<\/span>); <\/span>\/\/ VS2015 RTM can’t compile this declaration<\/span><\/p>\n

    short<\/span> f(…);<\/span><\/p>\n

     <\/span><\/p>\n

    struct <\/span>S1<\/span> { <\/span>void<\/span> f(); };<\/span><\/p>\n

    struct<\/span> S2<\/span> { <\/span>int<\/span> f(); };<\/span><\/p>\n

    struct<\/span> S3<\/span> { };<\/span><\/p>\n

     <\/span><\/p>\n

    static_assert<\/span>(<\/span>sizeof<\/span>(f(<\/span>S1<\/span>{})) == <\/span>sizeof<\/span>(<\/span>char<\/span>), <\/span>“fail”<\/span>);<\/span><\/p>\n

    static_assert<\/span>(<\/span>sizeof<\/span>(f(<\/span>S2<\/span>{})) == <\/span>sizeof<\/span>(<\/span>short<\/span>), <\/span>“fail”<\/span>);<\/span><\/p>\n

    static_assert<\/span>(<\/span>sizeof<\/span>(f(<\/span>S3<\/span>{})) == <\/span>sizeof<\/span>(<\/span>short<\/span>), <\/span>“fail”<\/span>);<\/span> <\/span><\/p>\n

    Using dependent decltype in the template argument of a partial specialization of a class template:<\/strong><\/p>\n

    #include<\/span><type_traits><\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span> <<\/span>class<\/span> T<\/span>, <\/span>class <\/span>V<\/span> = <\/span>void<\/span>> <\/span>struct <\/span>is_complete<\/span> : std::<\/span>false_type<\/span> {};<\/span><\/p>\n

    template<\/span> <<\/span>class<\/span> T<\/span>> <\/span>struct<\/span> is_complete<\/span><<\/span>T<\/span>, <\/span>decltype<\/span>(<\/span>void<\/span>(<\/span>sizeof<\/span>(<\/span>T<\/span>)))<\/span>> : std::<\/span>true_type<\/span> {};<\/span><\/p>\n

     <\/span><\/p>\n

    struct <\/span>S1<\/span> {};<\/span><\/p>\n

    struct <\/span>S2<\/span>;<\/span><\/p>\n

     <\/span><\/p>\n

    static_assert<\/span>(<\/span>is_complete<\/span><<\/span>S1<\/span>>::value, <\/span>“fail”<\/span>); <\/span>\/\/ fail in VS2015 RTM<\/span><\/p>\n

    static_assert<\/span>(!<\/span>is_complete<\/span><<\/span>S2<\/span>>::value, <\/span>“fail”<\/span>);<\/span><\/p>\n

    <\/a>Unsupported Scenarios in Update 1<\/h2>\n

    There are currently 6 unsupported scenarios. Some have workarounds.<\/p>\n

    Declaring two functions with the same signature except for different expressions in the decltype.<\/strong> You will encounter this issue if you try to build the Boost library. Because we capture expressions as a token stream, we are not able to reliably compare different expressions (for example, one problem is that we don’t know what ‘T’ or ‘I’ means). All dependent decltypes are currently considered as the same type.<\/p>\n

    template<\/span><<\/span>typename<\/span> I> <\/span>auto<\/span> foo(I i) -> <\/span>decltype<\/span>(i.a)<\/span> {}<\/span><\/p>\n

    template<\/span><<\/span>typename<\/span> I> <\/span>auto<\/span> foo(I i) -> <\/span>decltype<\/span>(i.b)<\/span> {} <\/span>\/\/ function template has already been defined<\/span><\/p>\n

    Using different decltypes as the template argument of the specializations of the same template.<\/strong> Similar to the issue above, you will encounter this issue if you try to build the Boost library because we are not able to distinguish between different decltypes and treat the specializations as the same. One possible workaround is to add an additional unique template argument.<\/p>\n

    template<\/span><<\/span>typename<\/span>T<\/span>> <\/span>T<\/span> declval(); <\/span><\/p>\n


    <\/span><\/p>\n

    template<\/span><<\/span>typename<\/span>… <\/span>T<\/span>><\/span><\/p>\n

    struct <\/span>void_<\/span> { <\/span>typedef<\/span> void<\/span> type<\/span>; };<\/span><\/p>\n

     <\/p>\n

    template<\/span><<\/span>typename<\/span>, <\/span>typename<\/span> = <\/span>void<\/span>> <\/span>struct<\/span> trait<\/span> {};<\/span> <\/span><\/p>\n

    template<\/span><<\/span>typename<\/span> R<\/span>><\/span><\/p>\n

    struct<\/span> trait<\/span><<\/span>R<\/span>(), <\/span>typename <\/span>void_<\/span><<\/span>decltype<\/span>(declval<<\/span>R<\/span>>()())<\/span>>::<\/span>type<\/span>><\/span><\/p>\n

    {<\/span><\/p>\n

           <\/span><\/span>typedef <\/span>decltype<\/span>(declval<<\/span>R<\/span>>()()) <\/span>type<\/span>;<\/span><\/p>\n

    }<\/span>;<\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span><<\/span>typename <\/span>R<\/span>, <\/span>typename <\/span>T0<\/span>><\/span><\/p>\n

    struct <\/span>trait<\/span><<\/span>R<\/span>(<\/span>T0<\/span>), <\/span>typename<\/span> void_<\/span><<\/span>decltype<\/span>(declval<<\/span>R<\/span>>()(declval<<\/span>T0<\/span>>()))<\/span>>::<\/span>type<\/span>><\/span><\/p>\n

    {<\/span><\/p>\n

           <\/span><\/span>typedef<\/span> decltype<\/span>(declval<<\/span>R<\/span>>()(declval<<\/span>T0<\/span>>())) <\/span>type<\/span>;<\/span><\/p>\n

    }<\/span>;<\/span><\/p>\n

     <\/span><\/p>\n

    struct<\/span>S1<\/span> {<\/span><\/p>\n

           <\/span><\/span>void <\/span>operator()<\/span>() <\/span>const<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

     <\/p>\n

    struct<\/span>S2<\/span> {<\/span><\/p>\n

           <\/span><\/span>void <\/span>operator()<\/span>(<\/span>int<\/span>) <\/span>const<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

     <\/span><\/p>\n

    void<\/span> f()<\/span><\/p>\n

    {<\/span><\/p>\n

           <\/span><\/span>\/\/ In VS2015 RTM, both fail to compile.<\/span><\/p>\n

           <\/span><\/span>\/\/ In VS2015 Update 1, the second still fails to compile.<\/span><\/p>\n

           <\/span><\/span>\/\/ This is because ‘void_<decltype(declval<R>()(declval<T0>()))’<\/span><\/p>\n

           <\/span><\/span>\/\/ is considered the same as ‘void_<decltype(declval<R>()())>’, and the second partial<\/span><\/p>\n

           <\/span><\/span>\/\/ specialization uses the latter to specialize and fail.<\/span><\/p>\n

           <\/span><\/span>typedef <\/span>trait<\/span><<\/span>const<\/span> S1<\/span>()>::<\/span>type<\/span> type<\/span>;<\/span><\/p>\n

           <\/span><\/span>typedef<\/span> trait<\/span><<\/span>const <\/span>S2<\/span>(<\/span>int<\/span>)>::<\/span>type <\/span>type<\/span>;<\/span><\/p>\n

    }<\/span><\/p>\n

    Using dependent constexpr function for SFINAE.<\/strong> Our current infrastructure always parses constexpr immediately whether it is dependent or not. You will encounter this issue if you try to build the range-v3 library.<\/p>\n

     #include<\/span><type_traits><\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span> <<\/span>typename<\/span> T<\/span>><\/span><\/p>\n

    bool<\/span> constexpr<\/span> concept_fn()<\/span><\/p>\n

    {<\/span><\/p>\n

           <\/span><\/span>return<\/span> std::<\/span>is_same<\/span><<\/span>T<\/span>, <\/span>int<\/span>>::value;<\/span><\/p>\n

    }<\/span><\/p>\n

    template<\/span> <<\/span>typename <\/span>T<\/span>><\/span><\/p>\n

    void<\/span> f(std::<\/span>enable_if_t<\/span><<\/span>concept_fn<<\/span>T<\/span>>()<\/span>>* = <\/span>nullptr<\/span>);<\/span><\/p>\n

    template<\/span> <<\/span>typename<\/span>T<\/span>><\/span><\/p>\n

    void<\/span> f(std::<\/span>enable_if_t<\/span><<\/span>!concept_fn<<\/span>T<\/span>>()<\/span>>* = <\/span>nullptr<\/span>);<\/span><\/p>\n

    Using pack expansion inside decltype.<\/strong> This will be fixed in VS2015 Update 2.<\/p>\n

    template<\/span><<\/span>typename<\/span> T<\/span>> <\/span>T<\/span> declval();<\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span><<\/span>typename<\/span> T<\/span>><\/span><\/p>\n

    struct <\/span>void_<\/span> { <\/span>typedef <\/span>void<\/span> type<\/span>; };<\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span><<\/span>typename<\/span>, <\/span>typename<\/span> = <\/span>void<\/span>> <\/span>struct <\/span>trait<\/span> {};<\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span><<\/span>typename <\/span>R<\/span>, <\/span>typename<\/span>… <\/span>Args<\/span>><\/span><\/p>\n

    struct <\/span>trait<\/span><<\/span>R<\/span>(<\/span>Args<\/span>…), <\/span>typename<\/span>void_<\/span><<\/span>decltype<\/span>(declval<<\/span>R<\/span>>()(declval<<\/span>Args<\/span>>()…))<\/span>>::<\/span>type<\/span>><\/span><\/p>\n

    {<\/span><\/p>\n

           <\/span><\/span>typedef<\/span> decltype<\/span>(declval<<\/span>R<\/span>>()(declval<<\/span>Args<\/span>>()…)) <\/span>type<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

     <\/span><\/p>\n

    struct <\/span>S<\/span> {<\/span><\/p>\n

           <\/span><\/span>void <\/span>operator()<\/span>(<\/span>int<\/span>, <\/span>int<\/span>) <\/span>const<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

     <\/span><\/p>\n

    void<\/span> f()<\/span><\/p>\n

    {<\/span><\/p>\n

           <\/span><\/span>\/\/ fail in VS2015 Update 1<\/span><\/p>\n

           <\/span><\/span>typedef <\/span>trait<\/span><<\/span>const<\/span>S<\/span>(<\/span>int<\/span>, <\/span>int<\/span>)>::<\/span>type <\/span>type<\/span>;<\/span><\/p>\n

    }<\/span><\/p>\n

    Dereferencing pointer-to-data-member inside decltype.<\/strong> This will be fixed in VS2015 Update 2.<\/p>\n

    template<\/span> <<\/span>typename<\/span>> <\/span>struct <\/span>AlwaysVoid<\/span> {<\/span><\/p>\n

           <\/span><\/span>typedef<\/span> void<\/span> type<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

     <\/span><\/p>\n

    template<\/span> <<\/span>typename<\/span> Pmd<\/span>, <\/span>typename <\/span>Obj<\/span>, <\/span>typename<\/span> = <\/span>void<\/span>> <\/span>struct<\/span> IsCallableObj<\/span> {<\/span><\/p>\n

           <\/span><\/span>static <\/span>constexpr <\/span>bool<\/span> value = <\/span>false<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

    template<\/span> <<\/span>typename<\/span> Pmd<\/span>, <\/span>typename<\/span> Obj<\/span>> <\/span>struct <\/span>IsCallableObj<\/span><<\/span>Pmd<\/span>, <\/span>Obj<\/span>,<\/span><\/p>\n

           <\/span><\/span>typename<\/span> AlwaysVoid<\/span><<\/span>decltype<\/span>(<\/span>Obj<\/span>{}.*<\/span>Pmd<\/span>{})<\/span>>::<\/span>type<\/span>> {<\/span><\/p>\n

           <\/span><\/span>static<\/span> constexpr<\/span> bool<\/span> value = <\/span>true<\/span>;<\/span><\/p>\n

    };<\/span><\/p>\n

     <\/span><\/p>\n

    struct<\/span> X<\/span> { };<\/span><\/p>\n

    using<\/span> PMD<\/span> = <\/span>int<\/span> X<\/span>::*;<\/span><\/p>\n

    class<\/span> Inaccessible<\/span> : <\/span>private<\/span>X<\/span> { };<\/span><\/p>\n

    struct <\/span>Derived1<\/span> : <\/span>X<\/span> { };<\/span><\/p>\n

    struct <\/span>Derived2<\/span> : <\/span>X<\/span> { };<\/span><\/p>\n

    struct <\/span>Ambiguous<\/span> : <\/span>Derived1<\/span>, <\/span>Derived2<\/span> { };<\/span><\/p>\n

     <\/span><\/p>\n

    static_assert<\/span>(<\/span>IsCallableObj<\/span><<\/span>PMD<\/span>, <\/span>X<\/span>>::value, <\/span>“BOOM: Inaccessible”<\/span>);<\/span><\/p>\n

    \/\/ The following two static_asserts fail in VS2015 Update 1<\/span><\/p>\n

    static_assert<\/span>(!<\/span>IsCallableObj<\/span><<\/span>PMD<\/span>, <\/span>Inaccessible<\/span>>::value, <\/span>“BOOM: Inaccessible”<\/span>);<\/span><\/p>\n

    static_assert<\/span>(!<\/span>IsCallableObj<\/span><<\/span>PMD<\/span>, <\/span>Ambiguous<\/span>>::value, <\/span>“BOOM: Ambiguous”<\/span>);<\/span><\/p>\n

    Using non-dependent decltype in the template argument of a partial specialization of a class template.<\/strong> Our compiler currently can’t tell whether an expression (which is captured as a token stream) is dependent or not, so it uses heuristic which fails to identify the expression used in the bug as non-dependent. For more details, see this issue<\/a> on Connect.<\/p>\n

    Plan moving forward<\/h2>\n

    Most of the limitations are related to our token stream-based approach, so we are moving to a new Recursive Descent Parser-based parse tree to capture expressions. This will let us represent expressions more accurately and help us support more scenarios including Expression SFINAE usage in the Boost libraries.<\/p>\n

    We will also implement the remaining semantic requirements for Expression SFINAE including identifying whether an expression is dependent or not, enabling the comparison of dependent expression and enabling the substitution of dependent expressions.<\/p>\n

    The Visual C++ team appreciates your comments and feedback. Thank you!<\/p>\n

    Xiang Fan
    Visual C++ Team<\/p>\n

     <\/span><\/p>\n

    <\/p>\n

    Normal\n 0<\/p>\n

    false\n false\n false<\/p>\n

    EN-US\n ZH-CN\n X-NONE<\/p>\n

    <\/p>\n

    <\/p>\n","protected":false},"excerpt":{"rendered":"

    In Visual Studio 2015 Update 1, we added partial support for C++11 core language feature Expression SFINAE. What is SFINAE? SFINAE is an acronym for ‘Substitution Failure Is Not An Error’. The idea is that when the compiler tries to specialize a function template during overload resolution, it is ok if the specialization fails as […]<\/p>\n","protected":false},"author":1062,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[137,116,247,248],"class_list":["post-7321","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus","tag-announcements","tag-c11","tag-decltype","tag-expression-sfinae"],"acf":[],"blog_post_summary":"

    In Visual Studio 2015 Update 1, we added partial support for C++11 core language feature Expression SFINAE. What is SFINAE? SFINAE is an acronym for ‘Substitution Failure Is Not An Error’. The idea is that when the compiler tries to specialize a function template during overload resolution, it is ok if the specialization fails as […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/7321","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\/1062"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=7321"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/7321\/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=7321"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=7321"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=7321"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}