Announcing the Visual C++ Compiler November 2013 CTP

Announcing the Visual C++ Compiler November 2013 CTP

Rate This
  • Comments 46

Last year in November, we released an out-of-band customer technology preview (CTP) of the Visual C++ compiler. It contained preview versions of C++11 features which we subsequently fully released in Visual Studio 2012. At that time, and at GoingNative 2013 this year, we promised to keep releasing these CTPs to show our progress towards full C++11 and C++14 standards conformance. Today, we are happy to update the map:

Today, we deliver on that promise.

Download the November 2013 CTP of the Visual C++ Compiler now. Breaking changes can be found here.

It contains the following C++11, C++14, and C++/CX features:

  • Implicit move special member function generation (thus also completing =default)
  • Reference qualifiers on member functions (a.k.a. "& and && for *this")
  • Thread-safe function local static initialization (a.k.a. "magic statics")
  • Inheriting constructors
  • alignof/alignas
  • __func__
  • Extended sizeof
  • constexpr (except for member functions)
  • noexcept (unconditional)
  • C++14 decltype(auto)
  • C++14 auto function return type deduction
  • C++14 generic lambdas (with explicit lambda capture list)
  • (Proposed for C++17) Resumable functions and await

Stephan T. Lavavej has created helpful and informative videos about these language features in part 10 of his Core C++ series of videos on Channel 9.

Installation and Usage

After downloading and running the installer, you should be able to use the new compiler in Visual Studio 2013. We recommend that you first create a separate project configuration and modify that configuration to use the new compiler. To do so:

  1. Open the "Build" menu and then select the "Configuration Manager" option.
  2. In the Configuration Manager, duplicate your existing configuration.
  3. Open the project's Property Pages by pressing F7 or right clicking the project in Solution Explorer and selecting "Properties".
  4. In the "General" tab, change "Platform Toolset" from "Visual Studio 2013 (v120)" to "Visual C++ Compiler Nov 2013 CTP (CTP_Nov2013)".
  5. Rebuild your project.

Important Notes

Before downloading, note the following:

  • This is a Customer Technology Preview and does not come with a "Go Live" license.
  • Visual Studio 2013 is a prerequisite for using this compiler. If you don't have Visual Studio 2013 installed, we recommend that you download the free Desktop Express edition here.
  • This package contains only the compiler and does not yet come with an updated standard library.
  • This version of the compiler is only compatible with CRT 12.0.
  • This version of the compiler can only be used as an alternative to the Visual C++ 2013 RTM compiler.
  • While a new Platform Toolset is provided for convenience of integrating the compiler as part of the Visual Studio 2013 build environment, the Visual Studio 2013 IDE, IntelliSense functionality, debugger, static analyzer, and other tools remain essentially unchanged and do not yet provide support for these new language features.
  • For a list of limitations and breaking changes introduced by this CTP compiler, consult the documentation provided on the download site. It will always include the most up-to-date information.

We Want Your Feedback!

One of the main reasons for this release is the gathering of community opinions and bug reports so that we can improve the quality of the compiler. If you find any bugs, and there are certainly many, please submit a report for Visual Studio via Microsoft Connect and use "[Torino]" as a prefix in the bug title. You can also leave comments below and submit suggestions via Visual Studio UserVoice or the integrated Send-a-Smile feature.

We are thankful for your support, and we hope that you have fun in using all these shiny new features in your code. Remember, you can grab the CTP here. Learn more about the features in the CTP from STL on in Core C++ 10 on Channel 9.

  • Any news on Vs2013 for phone Express?

  • Oh my gosh, yes yes yes yes yes.

    At last, generic lambdas are within my power!

    The CTP coming out so soon is simply amazing.

    Keep up the fantastic work, and do it even better if you can :D

  • Hopefully all the work on implicit move has squashed the annoying ICEs I've seen mixing move with brace init.

    Is the Windows 8.1 restriction for __await (mentioned in the "breaking changes") a CTP thing? STL mentioned it sits on ConcRT, which I thought was Vista+.... Not really a huge problem while it's a preview feature, but I would like to use it sometime within the next 10 years :P (Enterprise IT is a... unfun client).

    In any case, it will be neat to play around with this, implicit move especially should save a bunch of stupid boiler-plate!

  • Sadly, C++14 doesn't look like it does enough to make the language more productive to work in or broaden its appeal. Not Microsoft's fault, I realize, and I know I'm supposed to be excited about this, but god, after 2 straight years of nothing but C++ projects, I'm just plain tired of this kind of news. The more the standard evolves the more fatigued I get, and these posts like this just serve to remind me of how much of a mess this language is. [Can't wait to get back to C#. Or maybe it's time to learn Go.]


    "Whenever the C++ language designers had two competing ideas as to how they should solve some problem, they said, 'OK, we’ll do them both'. So the language is too baroque for my taste." -- Donald E Knuth

    "Within C++, there is a much smaller and cleaner language struggling to get out." -- Bjarne Stroustrup

    "C++ has shown that if you slowly bloat up a language over a period of years, people don't seem to mind as much." -- James Hague

    "C++: an octopus made by nailing extra legs onto a dog." -- Steve Taylor

    "I believe C++ instills fear in programmers, fear that the interaction of some details causes unpredictable results. Its unmanageable complexity has spawned more fear-preventing tools than any other language, but the solution should have been to create and use a language that does not overload the whole goddamn human." -- Erik Naggum

  • Simon Buchan> Is the Windows 8.1 restriction for __await (mentioned in the "breaking changes") a CTP thing?

    I checked with Deon (the compiler dev who implemented it), and yes, it's a CTP-only restriction that we're planning to lift in the next RTM.

    sttldev: Adding more features to a language can make it easier to use. Can you name three major C++11/14 features that you think cause more problems than they solve?

  • @sttldev: C++14 is to patch up missing parts of C++11 that should have been there: make_unique<T>(), actually using user-defined literals, etc..; If you mean C++11 doesn't provide enough over C++98 I'm not sure exactly how much you want out of your languages: it is, without exaggeration, the biggest language improvement I've ever seen! However, the next big "feature jump" will be C++17, in particular concepts-lite and modules alone together look to make it an easy enough to pick up language, and there is a lot of work on getting useful libraries (networking! xml! 2d graphics!?) into the standard.

    An interesting set of quotes in order to back your point: the latest quote (by earliest dated reference I could google) was 2007. If you want to complain about C++98, go ahead, it's a terrible language from a design point of view, used because all the alternatives suck at what it's good at: abstraction without cost.

  • Great! And I hope that constexpr will be available soon. It's a big and worthwhile feature.

  • When compiling the following code: (copied from one of bjarne's papers)

    constexpr int isqrt_helper(int sq, int d, int a) { return sq <= a ? isqrt_helper(sq + d, d + 2, a) : d; }

    constexpr int isqrt(int x) { return isqrt_helper(1, 3, x) / 2 - 1; }

    I get this error:

    warning C4592: 'isqrt_helper': 'constexpr' call evaluation failed; function will be called at run-time

    Are constexpr function calls from constexpr functions not supposed to work?

  • C++ suxx many years, living just thanks to "no alternative" environment. But now there is way better language - D! And despite c++ efforts, c++ will always be ugly OOP assembler.

    Save your resources, see to the future! D is the one.

  • Great news, thank you very much!

    Will these features be available with "Go Live" license in one of VIsual Studio 2013 updates?

    Or will we have to wait until Visual Studio 2014?

  • The aggregate initialization in constructor initializer list and with non static member initializers is still missing and not even present on the road map...

    The pre/post c++11 difference is described here, the second note :

    * Until C++11, aggregate initialization could not be used in a constructor initializer list due to syntax restrictions.

    A code like this is c++11 valid and fail the compile with visual 2013 rtm and november 2013 ctp :


    struct A { int member; };

    struct B {

    B() = default;

    B( int val ) : member { val } {} // error C2664: 'A::A(A &&)' : cannot convert argument 1 from 'int' to 'const A &'

    A member = { 1 }; // error C2664: 'A::A(A &&)' : cannot convert argument 1 from 'int' to 'const A &'


    A global { 1 }; // compile ok


    The same code compile as it should with clang :


  • @STL:

    What is the new value of _MSC_VER or _MSC_FULL_VER?

  • Sorry, that was more of a late night gripe session after a rough day of development, and C++ wasn't making my life any easier, so maybe this wasn't the right place to vent. The features in the new standards are great and useful, but the overall outcome is that the language is getting bigger and bigger and its cognitive load is increasing, even with the really simple stuff: How many ways are there to initialize a int? How many ways are there to zero out a struct? Which of these three smart pointers do I use? With each new feature I need to know exactly what is going on behind the scenes to make the best decision.

    So I find myself writing in C++ when I have to, when there's no other choice (legacy code, availability of APIs, etc.), not because I want to. My management has a similar distaste on more pragmatic grounds: They've watched new devs struggle for months before they're good enough to write production code... try explaining std::bind, the rule of three, piecewise_construct, variadic templates, etc. to a kid fresh out of school and watch his eyes glaze over (the names alone scare them). And there's an interesting phenomenon I've seen: as these kids become more skilled in C++, the less they like it. This reaction is the complete opposite from every other language that we work with. People love C# and Python as they learn more. Why do you think this is?

  • m.högdahl: Seems like a bug, I'll ask.

    Alex> Will these features be available with "Go Live" license in one of VIsual Studio 2013 updates?

    As I explained in my video, you should not expect these features to appear in a "Go Live" Update to VS 2013 RTM.

    Nicolas Silvagni: I'll ask if they're tracked by active bugs.

    MFH> What is the new value of _MSC_VER or _MSC_FULL_VER?

    _MSC_VER will be 1800, as we haven't incremented the major version number yet (same thing happened with the Nov 2012 CTP's timing). I'll ask about _MSC_FULL_VER - I've been running my own builds so I haven't installed the final CTP in a VM yet.

    sttldev> How many ways are there to initialize a int?

    C++11 provides uniform initialization so programmers can just use it everywhere. It has subtleties, but they're significantly less obnoxious than old-style initialization.

    > Which of these three smart pointers do I use?

    These correspond to significantly different powers - that's like choosing between vector and map. It's a decision, but not a very hard one.

    > try explaining std::bind

    bind() has been 99% superseded by C++11 lambdas, and 100% by C++14 generic lambdas. It was useful at the time, but we have better and simpler technology now.

    > piecewise_construct

    Almost nobody needs to know about this. I do, as an STL implementer.

    > variadic templates

    The kind of person who needs variadic templates desperately needs and loves them. Programmers who don't need to write templates especially don't need to understand variadic templates - for them, stuff like make_shared<T>(args, args, args) just works.

    > to a kid fresh out of school and watch his eyes glaze over (the names alone scare them).

    How does anybody learn neurosurgery, or complex analysis, or any one of a zillion technical fields?

    > as these kids become more skilled in C++, the less they like it.

    I guess I'm 30 now, but I learned C++ when I was 19, and the more I learned, the more I liked it. I switched from C to C++ after realizing that C's "simplicity" was a weakness, and I loved C++ because I actually understood what it was doing, unlike Java.

  • @MFH: I forget the exact value, but you can get the compiler to spit it out with:

    #pragma message("_MSC_FULL_VER: " _STRINGIZE(_MSC_FULL_VER))

    (stealing _STRINGIZE() from the MS std headers, from memory something like:

    #define _STRINGIZE(x) _STRINGIZEX(x)

    #define _STRINGIZEX(x) #x


Page 1 of 4 (46 items) 1234