Download here. Remember that this is a CTP and isn’t meant for production environments; please install in a test environment with no earlier versions of Visual Studio installed.
Eric Battalio says:
Here are some resources which may be useful as you try out the Visual Studio “14” CTP, released yesterday:
- Downloads: Download the Visual Studio “14” CTP (also available on MSDN subscriber downloads). Alternatively, save some time and use the provided VM in Azure.
- Blogs & Release Notes: Read announcements by Soma & Brian. Check out the team blogs, including Visual Studio, Web Dev (web tooling), Web Dev (ASP.NET vNext), Entity Framework, C#, VB, and C++. See the Visual Studio “14” CTP release notes for a list of new features. Discuss on Facebook & Twitter.
- Known Issues: This release should be installed in a test environment, such as a VM or a clean machine. Do not install on a machine with another version of Visual Studio installed. For other known issues, please see the Visual Studio “14” CTP KB.
- Feedback: Submit bugs through Connect, suggestions on UserVoice and quick thoughts through Send-a-Smile in the Visual Studio IDE.
Eric also posts a summary of the improvements in Visual C++. Here are a few:
- Generalized lambda capture: You can assign the result of evaluating an expression to a variable in the capture clause of a lambda. This allows an instance of a move-only type to be captured by value.
- User-defined literals in the language and standard library: You can append numeric and string literals with meaningful suffixes to give them suitable semantics. The compiler transforms these suffixes into calls to appropriate UDL-operator functions. The <chrono>, <string>, and <complex> headers now provide literal operators for convenience. For example, "1729ms" means std::chrono::milliseconds(1729), "meow"s means std::string("meow"), and 3.14i means std::complex<double>(0.0, 3.14).
- Completed noexcept: You can check whether an expression will throw an exception by using the noexcept operator. For example, noexcept(func()) will return "true" if func was specified as noexcept.
- Inline namespaces: You can specify a nested namespace as "inline" to make its contents accessed from its parent namespace.
- Thread-safe "magic" statics: Static local variables are initialized in a thread-safe way, removing the need for manual synchronization. Be aware that usage of these variables other than initialization is still not protected. Thread safety can be disabled by using /Zc:threadSafeInit- to avoid a dependency on the CRT.
- Unrestricted unions: You can define unions that contain types with non-trivial constructors. Constructors for such unions have to be manually defined.
- Includes November 2013 compiler CTP features: All new C++ 11 and C++ 14 language features that are released in the November 2013 compiler CTP for Visual Studio 2013 are also included in this preview. Go here for all the details.
- Null forward iterators: The Standard Library’s forward iterators (and stronger) now guarantee that value-initialized iterators compare as equal. This makes it possible to pass an empty range without a parent container. Be aware that generally, value-initialized iterators still cannot be compared to iterators from a parent container.
- quoted(): These manipulators let iostreams preserve strings that contain spaces.
- <chrono> fixes: The clocks are rewritten to be conformant and precise.
- Minimal allocator fixes: Several library components (including basic_string and std::function) did not work with user-defined allocators implementing C++11’s minimal allocator interface, instead requiring C++03’s verbose allocator interface. All occurrences of this problem are fixed.
- Debugger visualizers: Natvis debugger visualization files can be added to a Visual C++ project for easy management and source control integration. Natvis files that are added to a project will take evaluation precedence over visualizers outside the project.
Native memory diagnostics:
- You can start a memory diagnostic session (Alt+F2) that monitors the live memory usage of your native application. This supports Windows Desktop.
- You can capture heap snapshots of the running process in memory to see the types and instances for native allocations.
- You can view the difference in memory allocations between two memory snapshots.
- You can dive into the memory contents of a process snapshot by using the debugger for deeper analysis of the heap.
Soma tells us a bit about C# and VB with the .NET Compiler Platform ("Roslyn"):
In Visual Studio "14", the C# and VB compilers and IDE support are fully built on the .NET Compiler Platform ("Roslyn"). This open-source compiler as a service now sits behind dozens of developer experiences in Visual Studio "14", powering build, IntelliSense, refactoring, CodeLens, debugging and many more features developers use every day. In most places the experiences are unchanged, but there have also been many small improvements across the entire development experience as part of the new compiler platform.
And there’s good news on the C++ standards conformance front:
We’ve continued to push forward on the standards conformance of the Visual C++ compiler. The Visual Studio "14" CTP includes support for user-defined literals, noexcept, alignof and alignas, and inheriting constructors from C++11, generalized lambda capture, auto function return type deduction, and generic lambdas from C++14, as well as many more new C++ features.
This continues with the roadmap we laid out last year on the path toward C++11 and C++14 standards compliance. The chart below is an updated view of what we know now, and the features that we’re working on now for future Visual Studio "14" CTPs.
Download and enjoy.