Microsoft-tillägg till C och C++

Microsoft C++ (MSVC) utökar språkstandarderna C och C++ på flera sätt, som beskrivs i den här artikeln.

MSVC C++-kompilatorn stöder som standard ISO C++14 med vissa ISO C++17-funktioner och vissa Microsoft-specifika språktillägg. Mer information om funktioner som stöds finns i Microsoft C/C++-språkefterlevnad efter Visual Studio-version. Du kan använda kompileringsalternativet /std för att aktivera fullständigt stöd för språkfunktionerna ISO C++17 och ISO C++20. Mer information finns i /std (Ange språkstandardversion).

Om det anges kan vissa MSVC C++-språktillägg inaktiveras med hjälp av kompilatoralternativet /Za . I Visual Studio 2017 och senare versioner inaktiverar kompileringsalternativet /permissive- Microsoft-specifika C++-språktillägg. Kompilatoralternativet /permissive- aktiveras implicit av kompilatoralternativen /std:c++20 och /std:c++latest .

När MSVC som standard kompilerar kod som C implementerar den ANSI C89 med Microsoft-specifika språktillägg. Vissa av dessa MSVC-tillägg är standardiserade i ISO C99 och senare. De flesta MSVC C-tillägg kan inaktiveras med hjälp av kompilatoralternativet /Za , som beskrivs senare i den här artikeln. Du kan använda kompilatoralternativet /std för att aktivera stöd för ISO C11 och C17. Mer information finns i /std (Ange språkstandardversion).

Standard-C-körningsbiblioteket implementeras av UCRT (Universal C Runtime Library) i Windows. UCRT implementerar också många POSIX- och Microsoft-specifika bibliotekstillägg. UCRT stöder iso C11- och C17 C-körningsbiblioteksstandarderna, med vissa implementeringsspecifika varningar. Det stöder inte det fullständiga ISO C99-standard-C-körningsbiblioteket. Mer information finns i kompatibilitet i dokumentationen för Universal C-körningsbiblioteket.

Nyckelord

MSVC lägger till flera Microsoft-specifika nyckelord till C och C++. I listan i Nyckelord är nyckelorden som har två inledande understreck MSVC-tillägg.

Kastar

Både C++-kompilatorn och C-kompilatorn stöder dessa typer av icke-standard casts:

C-kompilatorn stöder icke-standardgjutningar för att producera l-värden. Till exempel:
```
char *p;
(( int * ) p )++;
// In C with /W4, both by default and under /Ze:
//     warning C4213: nonstandard extension used: cast on l-value
// Under /TP or /Za:
//     error C2105: '++' needs l-value
```
Anmärkning

Det här tillägget är endast tillgängligt på C-språket. Du kan använda följande C-standardformulär i C++-kod för att ändra en pekare som om det vore en pekare till en annan typ.

Föregående exempel kan skrivas om enligt följande för att överensstämma med C-standarden.
```
p = ( char * )(( int * )p + 1 );
```

Både C- och C++-kompilatorerna stöder icke-standardgjutningar av en funktionspekare till en datapekare. Till exempel:

int ( * pfunc ) ();
int *pdata;
pdata = ( int * ) pfunc;
/* No diagnostic at any level, whether compiled with default options or under /Za */

Argumentlistor med variabel längd

Både C- och C++-kompilatorer stöder en funktionsdeklarator som anger ett variabelt antal argument, följt av en funktionsdefinition som tillhandahåller en typ i stället:

void myfunc( int x, ... );
void myfunc( int x, char * c )
{ }
// In C with /W4, either by default or under /Ze:
//     warning C4212: nonstandard extension used: function declaration used ellipsis
// In C with /W4, under /Za:
//     warning C4028: formal parameter 2 different from declaration
// In C++, no diagnostic by default or under /Za.

Kommentarer med en rad

C-kompilatorn stöder enradskommentarer som introduceras med hjälp av två snedstreck (//) tecken:

// This is a single-line comment.

Enradskommentarer är en C99-funktion. De påverkas inte av /Za och orsakar ingen diagnostik på någon nivå.

Omfång

C-kompilatorn stöder följande omfångsrelaterade funktioner.

Omdefinitioner av extern objekt som static:

extern int clip();
static int clip() {}
// In C and C++ with /W4, either by default or under /Ze:
//     warning C4211: nonstandard extension used: redefined extern to static
// In C and C++ under /Za:
//     error C2375: 'clip': redefinition; different linkage

Användning av godartade typedef-omdefinitioner inom samma omfång:

typedef int INT;
typedef int INT; // No diagnostic at any level in C or C++

Funktionsdeklaratorer har filomfång:

void func1()
{
     extern double func2( double );
     // In C at /W4:  warning C4210: nonstandard extension used: function given file scope
}
int main( void )
{
     func2( 4 );    //  /Ze passes 4 as type double
}                  //  /Za passes 4 as type int

Användning av variabler för blockomfattning som initieras med hjälp av icke-konstanta uttryck:

int clip( int );
int bar( int );
int main( void )
{
     int array[2] = { clip( 2 ), bar( 4 ) };
}
int clip( int x )
{
     return x;
}
int bar( int x )
{
     return x;
}

Datadeklarationer och definitioner

C-kompilatorn stöder följande datadeklarations- och definitionsfunktioner.

Blandade tecken- och strängkonstanter i en initiator:

char arr[6] = {'a', 'b', "cde"};
// In C with /W4, either by default or under /Ze:
//     warning C4207: nonstandard extension used: extended initializer form
// Under /Za:
//     error C2078: too many initializers

Bitfält som har andra bastyper än unsigned int eller signed int.

Deklaratorer som inte har någon typ:

x;
// By default or under /Ze, /Za, /std:c11, and /std:c17, when /W4 is specified:
//     warning C4431: missing type specifier - int assumed. Note: C no longer supports default-int
//     warning C4218: nonstandard extension used: must specify at least a storage class or a type
*/
int main( void )
{
     x = 1;
}

Ej anpassade matriser som det sista fältet i strukturer och fackföreningar:

struct zero
{
     char *c;
     int zarray[];
     // In C with /W4, either by default, under /Ze, /std:c11, and /std:c17:
     //     warning C4200: nonstandard extension used: zero-sized array in struct/union
     // Under /Za:
     //     error C2133: 'zarray': unknown size
};

Namnlösa (anonyma) strukturer:

struct
{
     int i;
     char *s;
};
// By default or under /Ze, /std:c11, and /std:c17, when /W4 is specified:
//     warning C4094: untagged 'struct' declared no symbols
// Under /Za:
//     error C2059: syntax error: 'empty declaration'

Icke namngivna (anonyma) fackföreningar:

union
{
     int i;
     float fl;
};
// By default or under /Ze, /std:c11, and /std:c17, when /W4 is specified:
//     warning C4094: untagged 'union' declared no symbols
// Under /Za:
//     error C2059: syntax error: 'empty declaration'

Inbyggda flyttalsfunktioner

Både x86 C++-kompilatorn och C-kompilatorn stöder infogad generering av atanfunktionerna , atan2, cos, exp, log10log, sin, sqrtoch tan när /Oi anges. Dessa inbyggda egenskaper överensstämmer inte med standarden eftersom de inte anger variabeln errno .

`ISO646.H` inte aktiverat

Under /Zemåste du inkludera iso646.h om du vill använda textformulär för följande operatorer:

Operator	Textformulär
`&&`	`and`
`&=`	`and_eq`
`&`	`bitand`
`\|`	`bitor`
`~`	`compl`
`!`	`not`
`!=`	`not_eq`
`\|\|`	`or`
`\|=`	`or_eq`
`^`	`xor`
`^=`	`xor_eq`

Dessa textformulär är tillgängliga som C++-nyckelord under /Za eller när /permissive- är angivet eller underförstått.

Se även

/Za, /Ze (Inaktivera språktillägg)
MSVC-kompilatoralternativ
kommandoradssyntax för MSVC-kompilatorn

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-05