Extensões do Microsoft C e C++

Artigo
08/04/2011

Estas são as extensões do Visual C++ para os padrões ANSI C e C++ do ANSI:

Keywords

A Microsoft estende a linguagem C++ com várias outras palavras-chave. Para obter uma lista completa, consulte C++ Keywords na Referência da linguagem C++. Palavras-chave com dois sublinhados à esquerda são extensões do Microsoft.

Fora da definição de classe estática Integral const (ou enum) membros

Sob o padrão (/Za), você precisa fazer uma definição de fora da classe para membros de dados. For example,

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

Em /Ze, a definição de fora da classe é opcional para membros de dados estático, const enum de integral e const. Somente integrais e enumerações que são estáticos e const podem ter inicializadores dentro de uma classe; a expressão de inicialização deve ser uma expressão de constante.

Para evitar erros quando uma definição de fora da classe é fornecida (quando a definição de fora da classe é fornecida em um arquivo de cabeçalho e o arquivo de cabeçalho é incluído em vários arquivos de origem), você deve usar selectany. For example:

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

Casts

O compilador oferece suporte as conversões de não-ANSI dois seguintes:

Uso de conversões de não-ANSI para produzir valores l:
```
char *p;
(( int * ) p )++;
```
O exemplo anterior poderia ser reescrito para estar de acordo com o padrão ANSI C da seguinte maneira:
```
p = ( char * )(( int * )p + 1 );
```
Projeção não-ANSI de um ponteiro de função para um ponteiro de dados:
```
int ( * pfunc ) (); 
int *pdata;
pdata = ( int * ) pfunc;
```
Para executar a conversão mesma enquanto mantém a compatibilidade do ANSI, você deve converter o ponteiro de função para um int antes de convertê-lo para um ponteiro de dados:
```
pdata = ( int * ) (int) pfunc;
```

Listas de argumentos de comprimento variável

O compilador suporta o uso de um Declarador de função que especifica um número variável de argumentos, seguido por uma definição de função fornece um tipo em vez disso:

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

Comentários de linha única

O compilador c oferece suporte a comentários de linha única, o que são introduzidos com dois diagonal (/ /) caracteres:

// This is a single-line comment.

Scope

O compilador c suporta os seguintes recursos relacionados ao escopo:

Redefinições de itens de extern como estática:
```
extern int clip();
static int clip()
{}
```
Uso de redefinições de benigno typedef no mesmo escopo:
```
typedef int INT;
typedef int INT;
```

Declaradores de função têm o escopo do arquivo:

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 variáveis de escopo de bloco inicializado com expressões nonconstant:

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

Definições e declarações de dados

O compilador c suporta os seguintes recursos de declaração e definição de dados:

Mistos constantes de caractere e a seqüência de caracteres em um inicializador de:
```
char arr[5] = {'a', 'b', "cde"};
```
Bit campos com tipos base diferente de unsigned int ou signed int.
Declaradores sem um tipo ou de uma classe de armazenamento:
```
x;
int main( void )
{
    x = 1;
}
```
Conjuntos de dimensões indefinidos como o último campo em estruturas e uniões:
```
struct zero
{
    char *c;
    int zarray[];
};
```
Sem nome de estruturas (anônimas):
```
struct
{
    int i;
    char *s;
};
```
Sem nome de uniões (anônimos):
```
union
{
    int i;
    float fl;
};
```

Membros sem nome:

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

Funções intrínsecas de ponto flutuante

O compilador oferece suporte a geração de in-line x 86 específicos > da atan, atan2, cos, exp, log, log10, sin, sqrt, e tan funções final x 86 específico quando /Oi é especificado. Para C, conformidade de ANSI é perdida quando esses intrínsecos são usados, porque eles não definiram a errno variável.

Passar um parâmetro de ponteiro de não-Const para uma função que espera uma referência a um parâmetro de ponteiro de Const

Esta é uma extensão do C++. O seguinte código será compilado com /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 não habilitado

Em /Ze, você precisa incluir iso646.h se você quiser usar os formulários de texto dos operadores a seguir:

& & (e)
& = (and_eq)
& (bitand)
| (bitor)
~ (compl)
! (não)
! = (not_eq)
|| (ou)
| = (or_eq)
^ (xor)
^ = (xor_eq)

Endereço da literal de seqüência de caracteres tem tipo const char [], não const char (*)]

O exemplo a seguir produzirá char const (*) [4] em /Za, mas char const [4] em /Ze.

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

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

Consulte também

Referência

/ Za, /Ze (linguagem de desabilitar extensões)

Opções do compilador

Definindo opções do compilador

Partilhar via