Microsoft C++ Language Conformance Table
This topic summarizes the ISO C++03, C++11, C++14, C++17, and C++20 language standards conformance of compiler features and Standard Library features for the Microsoft C++ compiler in Visual Studio 2019 and earlier versions. Each compiler and standard library feature name links to the ISO C++ Standard proposal paper that describes the feature, if one is available at publication time. The Supported column lists the Visual Studio version in which support for the feature first appeared.
For details on conformance improvements and other changes in Visual Studio 2017 or Visual Studio 2019, set the version selector in the upper left of this page, then see C++ conformance improvements in Visual Studio and What's New for Visual C++ in Visual Studio. For conformance changes in earlier versions, see Visual C++ change history and Visual C++ What's New 2003 through 2015. For current news from the C++ team, visit the C++ team blog.
There are no binary breaking changes between Visual Studio 2015, Visual Studio 2017, and Visual Studio 2019.
Standard Library Features
A group of papers listed together indicates that a feature was voted into the Standard, and then one or more papers to improve or expand that feature were also voted in. These features are implemented together.
No means not yet implemented.
Partial means the implementation is incomplete. For more details, see the Notes section.
VS 2010 indicates features that are supported in Visual Studio 2010.
VS 2013 indicates features that are supported in Visual Studio 2013.
VS 2015 indicates features that are supported in Visual Studio 2015 RTW.
VS 2015.2 and VS 2015.3 indicate features that are supported in Visual Studio 2015 Update 2 and Visual Studio 2015 Update 3, respectively.
VS 2017 15.0 indicates features that are supported in Visual Studio 2017 version 15.0 (RTW).
VS 2017 15.3 indicates features that are supported in Visual Studio 2017 version 15.3.
VS 2017 15.5 indicates features that are supported in Visual Studio 2017 version 15.5.
VS 2017 15.7 indicates features that are supported in Visual Studio 2017 version 15.7.
VS 2019 16.0 indicates features that are supported in Visual Studio 2019 version 16.0 (RTW).
VS 2019 16.1 indicates features that are supported in Visual Studio 2019 version 16.1.
A In /std:c++14 mode, dynamic exception specifications remain unimplemented, and
throw() is still treated as a synonym for
__declspec(nothrow). In C++17, dynamic exception specifications were mostly removed by P0003R5, leaving one vestige:
throw() is deprecated and required to behave as a synonym for
noexcept. In /std:c++17 mode, MSVC now conforms to the Standard by giving
throw() the same behavior as
noexcept, i.e. enforcement via termination.
The compiler option /Zc:noexceptTypes requests our old behavior of
__declspec(nothrow). It’s likely that
throw() will be removed in C++20. To help with migrating code in response to these changes in the Standard and our implementation, new compiler warnings for exception specification issues have been added under /std:c++17 and /permissive-.
C The compiler’s support for C99 Preprocessor rules is incomplete in Visual Studio 2017. Variadic macros are supported, but there are many bugs in the preprocessor’s behavior. We are overhauling the preprocessor, and will experimentally ship those changes under the /permissive- mode soon.
D Supported under /std:c++14 with a suppressible warning, C4984.
E This is a completely new implementation, incompatible with the
std::experimental version, necessitated by symlink support, bug fixes, and changes in standard-required behavior. Currently, including <filesystem> provides the new
std::filesystem and the previous
std::experimental::filesystem, and including <experimental/filesystem> provides only the old experimental implementation. The experimental implementation will be REMOVED in the next ABI-breaking release of the libraries.
14 These C++17/20 features are always enabled, even when /std:c++14 (the default) is specified. This is either because the feature was implemented before the introduction of the /std options, or because conditional implementation was undesirably complex.
20 These features are enabled by the /std:c++latest compiler option. When the C++20 implementation is complete, a new /std:c++20 compiler option will be added, under which these features will also be available.
std::byte is enabled by /std:c++17 (or /std:c++latest), but because it can conflict with the Windows SDK headers in some cases, it has a fine-grained opt-out macro. It can be disabled by defining
C11 The Universal CRT implemented the parts of the C11 Standard Library that are required by C++17, with the exception of C99
strftime() E/O alternative conversion specifiers, C11
fopen() exclusive mode, and C11
aligned_alloc(). The latter is unlikely to be implemented, because C11 specified
aligned_alloc() in a way that's incompatible with the Microsoft implementation of
free(), namely, that
free() must be able to handle highly aligned allocations.
rem Features removed when the /std:c++17 (or /std:c++latest) compiler option is specified. These features can be re-enabled to ease the transition to newer language modes by use of these macros:
- VS 2017 15.7: Integer
- VS 2017 15.8: Floating-point
- VS 2017 15.9: Floating-point
to_chars()overloads for shortest decimal.
- VS 2019 16.0: Floating-point
to_chars()overloads for shortest hex and precision hex.
- VS 2019 16.2: Floating-point
to_chars()overloads for precision fixed and precision scientific.
- Not yet implemented: The floating-point
to_chars()overload for precision general.
parallel C++17’s parallel algorithms library is complete. This doesn’t mean every algorithm is parallelized in every case; the most important algorithms have been parallelized and execution policy signatures are provided even where algorithms are not parallelized. Our implementation’s central internal header, yvals_core.h, contains the following "Parallel Algorithms Notes": C++ allows an implementation to implement parallel algorithms as calls to the serial algorithms. This implementation parallelizes several common algorithm calls, but not all.
The following algorithms are parallelized:
The following are not presently parallelized:
- No apparent parallelism performance improvement on target hardware; all algorithms which merely copy or permute elements with no branches are typically memory bandwidth limited:
- Confusion over user parallelism requirements exists; likely in the above category anyway:
- Effective parallelism suspected to be infeasible:
- Not yet evaluated; parallelism may be implemented in a future release and is suspected to be beneficial:
C++ Language Reference
C++ Standard Library
C++ conformance improvements in Visual Studio
What's New for Visual C++ in Visual Studio
Visual C++ change history 2003 through 2015
Visual C++ What's New 2003 through 2015
C++ team blog