Extensiones de Microsoft para C y C++

Artículo
04/03/2023

Microsoft Visual C++ (MSVC) amplía los estándares del lenguaje C y C++ de varias maneras que se detallan en este artículo.

El compilador de C++ de MSVC tiene como valor predeterminado admitir ISO C++14 con algunas características de ISO C++17 y algunas extensiones de lenguaje específicas de Microsoft. Para obtener más información sobre las características admitidas, vea Conformidad del lenguaje C/C++ de Microsoft por versión de Visual Studio. Puede usar la opción de compilador /std para habilitar la compatibilidad completa con las características del lenguaje ISO C++17 e ISO C++20. Para obtener más información, consulte /std (Especificar la versión estándar del lenguaje).

Cuando se especifica, algunas extensiones del lenguaje C++ de MSVC se pueden deshabilitar mediante el uso de la opción del compilador /Za. En Visual Studio 2017 y versiones posteriores, la opción del compilador /permissive- deshabilita las extensiones del lenguaje C++ específicas de Microsoft. La opción del compilador /permissive- está habilitada implícitamente por las opciones del compilador /std:c++20 y /std:c++latest.

De forma predeterminada, cuando MSVC compila código como C, implementa ANSI C89 con extensiones del lenguaje específicas de Microsoft. Algunas de estas extensiones de MSVC están estandarizadas en ISO C99 y versiones posteriores. La mayoría de las extensiones de C de MSVC se pueden deshabilitar mediante el uso de la opción del compilador /Za, como se detalla más adelante en este artículo. Puede usar la opción del compilador /std para habilitar la compatibilidad con ISO C11 y C17. Para obtener más información, consulte /std (Especificar la versión estándar del lenguaje).

La biblioteca de runtime de C estándar se implementa mediante la biblioteca Universal C runtime (UCRT) en Windows. La UCRT también implementa muchas extensiones de biblioteca POSIX y específicas de Microsoft. La UCRT admite los estándares de biblioteca de runtime C ISO C11 y C17, con ciertas advertencias específicas de la implementación. No admite la biblioteca de runtime C estándar ISO C99 completa. Para obtener más información, consulte compatibilidad en la documentación de la biblioteca Universal C runtime.

Palabras clave

MSVC agrega varias palabras clave específicas de Microsoft a C y C++. En la lista de Palabra clave, las palabras clave que tienen dos guiones bajos iniciales son extensiones de MSVC.

Conversiones

Los compiladores de C y C++ admiten estos tipos de conversiones no estándar:

El compilador de C admite conversiones no estándar para generar valores l. Por ejemplo:
```
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
```
Nota:

Esta extensión solo está disponible en el lenguaje C. Puede utilizar el siguiente formulario estándar de C en el código de C++ para modificar un puntero como si fuera un puntero a un tipo diferente.

El ejemplo anterior podría reescribirse de la forma siguiente para adaptarlo al estándar C.
```
p = ( char * )(( int * )p + 1 );
```

Los compiladores de C y C++ admiten conversiones no estándar de un puntero de función a un puntero de datos. Por ejemplo:

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

Listas de argumentos de longitud variable

Los compiladores de C y C++ admiten un declarador de función que especifica un número de argumentos variable, seguido de una definición de función que proporciona un tipo en su lugar:

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.

Comentarios en una sola línea

El compilador de C acepta comentarios de una sola línea, que se introducen mediante dos caracteres de barra diagonal (//):

// This is a single-line comment.

Los comentarios de una sola línea son una característica de C99. No se ven afectados por /Za y no provocan ningún diagnóstico en ningún nivel.

Ámbito

El compilador de C acepta las siguientes características relacionadas con el ámbito.

Redefiniciones de elementos extern como 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

Uso de redefiniciones de typedef sin efecto dentro del mismo ámbito:

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

Los declaradores de función tienen ámbito de archivo:

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

Uso de las variables de ámbito de bloque que se inicializan mediante expresiones no constantes:

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;
}

Declaraciones y definiciones de datos

El compilador de C admite las siguientes características de declaración y definición de datos.

Constantes de caracteres y cadenas mezcladas en un inicializador:

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

Campos de bit que tienen tipos base distintos de unsigned int o signed int.

Declaradores que no tienen un tipo:

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;
}

Matrices sin tamaño como último campo de estructuras y uniones:

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
};

Estructuras sin nombre (anónimas):

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'

Uniones sin nombre (anónimas):

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'

Funciones de punto flotante intrínsecas

Los compiladores de C++ y C de x86 admiten la generación alineada de las funciones atan, atan2, cos, exp, log, log10, sin, sqrt, y tan cuando se especifica /Oi. Estas intrínsecas no se ajustan al estándar, ya que no establecen la variable errno.

`ISO646.H` no habilitado

Bajo /Ze debe incluir iso646.h si desea usar formularios de texto de los operadores siguientes:

Operador	Formulario de texto
`&&`	`and`
`&=`	`and_eq`
`&`	`bitand`
`\|`	`bitor`
`~`	`compl`
`!`	`not`
`!=`	`not_eq`
`\|\|`	`or`
`\|=`	`or_eq`
`^`	`xor`
`^=`	`xor_eq`

Estos formularios de texto están disponibles como palabras clave de C++ bajo /Za o cuando /permissive- se especifica o se implica.

Consulte también

/Za, /Ze (Deshabilitar extensiones de lenguaje)
Opciones del compilador de MSVC
Sintaxis de línea de comandos del compilador de MSVC