The Microsoft run-time library provides routines for programming for the Microsoft Windows operating system. These routines automate many common programming tasks that are not provided by the C and C languages. Sample programs are included in the individual reference topics for most routines in the library. In This Section. C Run-Time Libraries.
- Microsoft C Runtime Library Download
- Microsoft C++ Runtime Library Error
- Microsoft C Runtime Library X64
This topic discusses the various .lib files that comprise the C run-time libraries as well as their associated compiler options and preprocessor directives.
C Run-Time Libraries (CRT)
The C Run-time Library (CRT) is the part of the C++ Standard Library that incorporates the ISO C99 standard library. The Visual C++ libraries that implement the CRT support native code development, and both mixed native and managed code. All versions of the CRT support multi-threaded development. Most of the libraries support both static linking, to link the library directly into your code, or dynamic linking to let your code use common DLL files.
Starting in Visual Studio 2015, the CRT has been refactored into new binaries. The Universal CRT (UCRT) contains the functions and globals exported by the standard C99 CRT library. The UCRT is now a Windows component, and ships as part of Windows 10. The static library, DLL import library, and header files for the UCRT are now found in the Windows 10 SDK. When you install Visual C++, Visual Studio setup installs the subset of the Windows 10 SDK required to use the UCRT. You can use the UCRT on any version of Windows supported by Visual Studio 2015 and later versions. You can redistribute it using vcredist for supported versions of Windows other than Windows 10. For more information, see Redistributing Visual C++ Files.
The following table lists the libraries that implement the UCRT.
One of the most important tip I can provide to you is that you must keep a steady track of your currency. Once that has finished, open up the game on your device, and the items will be sitting in your account ready to use. Our Unique Cheats & TipsSmurfs Village is a straight forward farming and creating your very own new village game. Smurfs village unlimited smurfberries.
Library | Associated DLL | Characteristics | Option | Preprocessor directives |
---|---|---|---|---|
libucrt.lib | None | Statically links the UCRT into your code. | /MT | _MT |
libucrtd.lib | None | Debug version of the UCRT for static linking. Not redistributable. | /MTd | _DEBUG, _MT |
ucrt.lib | ucrtbase.dll | DLL import library for the UCRT. | /MD | _MT, _DLL |
ucrtd.lib | ucrtbased.dll | DLL import library for the Debug version of the UCRT. Not redistributable. | /MDd | _DEBUG, _MT, _DLL |
The vcruntime library contains Visual C++ CRT implementation-specific code, such as exception handling and debugging support, runtime checks and type information, implementation details and certain extended library functions. This library is specific to the version of the compiler used.
This table lists the libraries that implement the vcruntime library.
Library | Associated DLL | Characteristics | Option | Preprocessor directives |
---|---|---|---|---|
libvcruntime.lib | None | Statically linked into your code. | /MT | _MT |
libvcruntimed.lib | None | Debug version for static linking. Not redistributable. | /MTd | _MT, _DEBUG |
vcruntime.lib | vcruntime<version>.dll | DLL import library for the vcruntime. | /MD | _MT, _DLL |
vcruntimed.lib | vcruntime<version>d.dll | DLL import library for the Debug vcruntime. Not redistributable. | /MDd | _DEBUG, _MT, _DLL |
Note
When the UCRT refactoring occurred, the Concurrency Runtime functions were moved intoconcrt140.dll, which was added to the C++ redistributable package. This DLL is required for C++ parallel containers and algorithms such as
concurrency::parallel_for
. In addition, the C++ Standard Library requires this DLL on Windows XP to support synchronization primitives, because Windows XP does not have condition variables.The code that initializes the CRT is in one of several libraries, based on whether the CRT library is statically or dynamically linked, or native, managed, or mixed code. This code handles CRT startup, internal per-thread data initialization, and termination. It is specific to the version of the compiler used. This library is always statically linked, even when using a dynamically linked UCRT.
This table lists the libraries that implement CRT initialization and termination.
Library | Characteristics | Option | Preprocessor directives |
---|---|---|---|
libcmt.lib | Statically links the native CRT startup into your code. | /MT | _MT |
libcmtd.lib | Statically links the Debug version of the native CRT startup. Not redistributable. | /MTd | _DEBUG, _MT |
msvcrt.lib | Static library for the native CRT startup for use with DLL UCRT and vcruntime. | /MD | _MT, _DLL |
msvcrtd.lib | Static library for the Debug version of the native CRT startup for use with DLL UCRT and vcruntime. Not redistributable. | /MDd | _DEBUG, _MT, _DLL |
msvcmrt.lib | Static library for the mixed native and managed CRT startup for use with DLL UCRT and vcruntime. | /clr | |
msvcmrtd.lib | Static library for the Debug version of the mixed native and managed CRT startup for use with DLL UCRT and vcruntime. Not redistributable. | /clr | |
msvcurt.lib | Deprecated Static library for the pure managed CRT. | /clr:pure | |
msvcurtd.lib | Deprecated Static library for the Debug version of the pure managed CRT. Not redistributable. | /clr:pure |
If you link your program from the command line without a compiler option that specifies a C run-time library, the linker will use the statically linked CRT libraries: libcmt.lib, libvcruntime.lib, and libucrt.lib.
Using the statically linked CRT implies that any state information saved by the C runtime library will be local to that instance of the CRT. For example, if you use strtok, _strtok_l, wcstok, _wcstok_l, _mbstok, _mbstok_l when using a statically linked CRT, the position of the
strtok
parser is unrelated to the strtok
state used in code in the same process (but in a different DLL or EXE) that is linked to another instance of the static CRT. In contrast, the dynamically linked CRT shares state for all code within a process that is dynamically linked to the CRT. This concern does not apply if you use the new more secure versions of these functions; for example, strtok_s
does not have this problem.Because a DLL built by linking to a static CRT will have its own CRT state, it is not recommended to link statically to the CRT in a DLL unless the consequences of this are specifically desired and understood. For example, if you call _set_se_translator in an executable that loads the DLL linked to its own static CRT, any hardware exceptions generated by the code in the DLL will not be caught by the translator, but hardware exceptions generated by code in the main executable will be caught.
If you are using the /clr compiler switch, your code will be linked with a static library, msvcmrt.lib. The static library provides a proxy between your managed code and the native CRT. You cannot use the statically linked CRT ( /MT or /MTd options) with /clr. Use the dynamically-linked libraries (/MD or /MDd) instead. The pure managed CRT libraries are deprecated in Visual Studio 2015 and unsupported in Visual Studio 2017.
For more information on using the CRT with /clr, see Mixed (Native and Managed) Assemblies.
To build a debug version of your application, the _DEBUG flag must be defined and the application must be linked with a debug version of one of these libraries. For more information about using the debug versions of the library files, see CRT Debugging Techniques.
This version of the CRT is not fully conformant with the C99 standard. In particular, the <tgmath.h> header and the CX_LIMITED_RANGE/FP_CONTRACT pragma macros are not supported. Certain elements such as the meaning of parameter specifiers in standard IO functions use legacy interpretations by default. You can use /Zc compiler conformance options and specify linker options to control some aspects of library conformance,
C++ Standard Library
C++ Standard Library | Characteristics | Option | Preprocessor directives |
---|---|---|---|
libcpmt.lib | Multithreaded, static link | /MT | _MT |
msvcprt.lib | Multithreaded, dynamic link (import library for MSVCPversion.dll) | /MD | _MT, _DLL |
libcpmtd.lib | Multithreaded, static link | /MTd | _DEBUG, _MT |
msvcprtd.lib | Multithreaded, dynamic link (import library for MSVCPversionD.DLL) | /MDd | _DEBUG, _MT, _DLL |
When you build a release version of your project, one of the basic C run-time libraries (libcmt.lib, msvcmrt.lib, msvcrt.lib) is linked by default, depending on the compiler option you choose (multithreaded, DLL, /clr). If you include one of the C++ Standard Library header files in your code, a C++ Standard Library will be linked in automatically by Visual C++ at compile time. For example:
For binary compatibility, more than one DLL file may be specified by a single import library. Version updates may introduce dot libraries, separate DLLs that introduce new library functionality. For example, Visual Studio 2017 version 15.6 introduced msvcp140_1.dll to support additional standard library functionality without breaking the ABI supported by msvcp140.dll. The msvcprt.lib import library included in the toolset for Visual Studio 2017 version 15.6 supports both DLLs, and the vcredist for this version installs both DLLs. Once shipped, a dot library has a fixed ABI, and will never have a dependency on a later dot library.
What problems exist if an application uses more than one CRT version?
Every executable image (EXE or DLL) can have its own statically linked CRT, or can dynamically link to a CRT. The version of the CRT statically included in or dynamically loaded by a particular image depends on the version of the tools and libraries it was built with. A single process may load multiple EXE and DLL images, each with its own CRT. Each of those CRTs may use a different allocator, may have different internal structure layouts, and may use different storage arrangements. This means that allocated memory, CRT resources, or classes passed across a DLL boundary can cause problems in memory management, internal static usage, or layout interpretation. For example, if a class is allocated in one DLL but passed to and deleted by another, which CRT deallocator is used? The errors caused can range from the subtle to the immediately fatal, and therefore direct transfer of such resources is strongly discouraged.
You can avoid many of these issues by using Application Binary Interface (ABI) technologies instead, as they are designed to be stable and versionable. Design your DLL export interfaces to pass information by value, or to work on memory that is passed in by the caller rather than allocated locally and returned to the caller. Use marshalling techniques to copy structured data between executable images. Encapsulate resources locally and only allow manipulation through handles or functions you expose to clients.
It's also possible to avoid some of these issues if all of the images in your process use the same dynamically loaded version of the CRT. To ensure that all components use the same DLL version of the CRT, build them by using the /MD option, and use the same compiler toolset and property settings.
Some care is needed if your program passes certain CRT resources (such as file handles, locales and environment variables) across DLL boundaries, even when using the same version of the CRT. For more information on the issues involved and how to resolve them, see Potential Errors Passing CRT Objects Across DLL Boundaries.
See also
-->The Microsoft run-time library provides routines for programming for the Microsoft Windows operating system. These routines automate many common programming tasks that are not provided by the C and C++ languages.
Sample programs are included in the individual reference topics for most routines in the library.
In This Section
C Run-Time Libraries
Discusses the .lib files that comprise the C run-time libraries.
Discusses the .lib files that comprise the C run-time libraries.
Universal C runtime routines by category
Provides links to the run-time library by category.
Provides links to the run-time library by category.
Global Variables and Standard Types
Provides links to the global variables and standard types provided by the run-time library.
Provides links to the global variables and standard types provided by the run-time library.
Global Constants
Provides links to the global constants defined by the run-time library.
Provides links to the global constants defined by the run-time library.
Alphabetical Function Reference
Provides a table of contents entry point into an alphabetical listing of all C run-time library functions.
Provides a table of contents entry point into an alphabetical listing of all C run-time library functions.
Generic-Text Mappings
Provides links to the generic-text mappings defined in Tchar.h.
Provides links to the generic-text mappings defined in Tchar.h.
Microsoft C Runtime Library Download
Language and Country/Region Strings
Describes how to use the
Describes how to use the
setlocale
function to set the language and Country/Region strings.Related Sections
Debug Routines
Provides links to the debug versions of the run-time library routines.
Provides links to the debug versions of the run-time library routines.
Run-Time Error Checking
Provides links to functions that support run-time error checks. Toyota techstream program.
Provides links to functions that support run-time error checks. Toyota techstream program.
Microsoft C++ Runtime Library Error
DLLs and Visual C++ run-time library behavior
Discusses the entry point and startup code used for a DLL.
Discusses the entry point and startup code used for a DLL.
Microsoft C Runtime Library X64
Debugging
Provides links to using the Visual Studio debugger to correct logic errors in your application or stored procedures.
Provides links to using the Visual Studio debugger to correct logic errors in your application or stored procedures.