Extensiones de Microsoft para C y C++

Artículo
03/12/2013

Visual C++ extiende las normas ANSI C y ANSI C++ como sigue.

Keywords

Se agregan varias palabras clave.En la lista en Palabras clave de C++, las palabras clave que tienen dos subrayado principales son extensiones de Visual C++.

Definición fuera de clase de miembros integral (o enum) de tipo static y const

Bajo la estándar (/Za), debe crear una definición de la hacia fuera-de- clase para los miembros de datos, como se muestra aquí:

class CMyClass  {
   static const int max = 5;
   int m_array[max];
}
...
const int CMyClass::max;   // out of class definition

Con /Ze, la definición fuera de clase es opcional para los miembros de datos enum o integral de tipo static y const.Sólo los integrales y las enumeraciones que son estáticos y const pueden tener inicializadores en una clase; la expresión que inicializa debe ser una expresión const.

Para evitar errores a una definición de la hacia fuera-de- clase se proporciona en un archivo de encabezado y el archivo de encabezado se incluye en varios archivos de código fuente, utilice selectany.Por ejemplo:

__declspec(selectany) const int CMyClass::max = 5;

Conversiones de tipo

El compilador admite estas clases de conversiones de no ANSI:

Conversiones de no ANSI para generar l- valores.Por ejemplo:
```
char *p;
(( int * ) p )++;
```
[!NOTA]

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

El ejemplo anterior se podría escribir como sigue a cumplir ANSI C.
```
p = ( char * )(( int * )p + 1 );
```
Conversiones de no ANSI de un puntero a función a un puntero de datos.Por ejemplo:
```
int ( * pfunc ) (); 
int *pdata;
pdata = ( int * ) pfunc;
```
Para realizar la misma conversión y también mantener la compatibilidad con ANSI, puede convertir el puntero a función para uintptr_t antes de que lo convierta un puntero de datos:
```
pdata = ( int * ) (uintptr_t) pfunc;
```

Listas de argumentos de longitud variable

El compilador admite un declarador de la función que especifica un número variable de argumentos, seguido por una definición de función que proporcione un tipo en su lugar:

void myfunc( int x, ... );
void myfunc( int x, char * c )
{ }

Comentarios en una línea

El compilador de C admite los comentarios de una línea, que se presentan mediante dos caracteres de barra diagonal (/):

// This is a single-line comment.

Ámbito

El compilador de C admite las características ámbito- relacionadas siguientes.

Redefiniciones de elementos extern como static:
```
extern int clip();
static int clip()
{}
```
Uso de redefiniciones typedef benignas dentro del mismo ámbito:
```
typedef int INT;
typedef int INT;
```

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

void func1()
{
    extern int func2( double );
}
int main( void )
{
    func2( 4 );    //  /Ze passes 4 as type double
}                  //  /Za passes 4 as type int

Uso de las variables de bloque- ámbito que se inicializan mediante expresiones que no es una constante:

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 la declaración y la definición de datos.

Constantes de caracteres y cadenas mezcladas en un inicializador:
```
char arr[5] = {'a', 'b', "cde"};
```
Campos de bit que tienen tipos base distinto de unsigned int o de signed int.
Declarantes que no tienen una clase de almacenamiento o un tipo:
```
x;
int main( void )
{
    x = 1;
}
```
Matrices sin tamaño como último campo en estructuras y uniones:
```
struct zero
{
    char *c;
    int zarray[];
};
```
Estructuras sin nombre (anónimas):
```
struct
{
    int i;
    char *s;
};
```
Uniones sin nombre (anónimas):
```
union
{
    int i;
    float fl;
};
```

Miembros sin nombre:

struct s
{
   unsigned int flag : 1;
   unsigned int : 31;
}

Funciones intrínsecas de punto flotante

El compilador admite la generación en línea Específico de x86 de las funciones atan, atan2, cos, exp, log, log10, sin, sqrt y tanEspecífico de END x86 cuando se especifica /Oi.Para C, la compatibilidad con ANSI se pierde cuando se utilizan estas funciones intrínsecas, puesto que no definen la variable errno.

Pasar un parámetro de puntero no Const a una función que espera una referencia a un parámetro de puntero Const

Esto es una extensión de C++.Este código se compilará con /Ze:

typedef   int   T;

const T  acT = 9;      // A constant of type 'T'
const T* pcT = &acT;   // A pointer to a constant of type 'T'

void func2 ( const T*& rpcT )   // A reference to a pointer to a constant of type 'T'
{
   rpcT = pcT;
}

T*   pT;               // A pointer to a 'T'

void func ()
{
   func2 ( pT );      // Should be an error, but isn't detected
   *pT   = 7;         // Invalidly overwrites the constant 'acT'
}

ISO646.H no habilitado

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

&& (y)
&= (and_eq)
& (bitand)
| (bitor)
~ (compl)
!(not)
!= (not_eq)
|| (or)
= (or_eq)
^ (xor)
^= (xor_eq)

Dirección de const char del tipo de Literal Tener string [], no const char (*) []

El siguiente ejemplo escribirá un char const (*)[4] con la opción /Za y un char const [4] con /Ze.

#include <stdio.h>
#include <typeinfo>

int main()
{
    printf_s("%s\n", typeid(&"abc").name());
}

Vea también

Referencia

/Za, /Ze (Deshabilitar extensiones de lenguaje)

Opciones del compilador

Establecer las opciones del compilador

Compartir a través de