Compartilhar via


Extensões do Microsoft C e C++

Visual C++ estende os padrões ANSI C e ANSI C++ como segue.

Palavras-chave

Vários palavra-chave são adicionados.Na lista em Palavras-chave C++, as palavras-chave que têm dois principais são sublinhados extensões do Visual C++.

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

Em**/Za**(o padrão), você deve fazer uma definição de para fora da classe para membros de dados, como mostrado aqui:

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 para fora da classe é opcional para a estático, a integral const, e membros de dados enum const.Somente as inteiros e enumerações que são estáticas e o const podem ter inicializadores em uma classe; inicializando a expressão deve ser uma expressão const.

Para evitar erros quando uma definição de para fora da classe é fornecida em um arquivo de cabeçalho e o arquivo de cabeçalho é incluído em vários arquivos de origem, use selectany.Por exemplo:

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

Conversões

O compilador oferece suporte para esses tipos de conversões não-ansi:

  • Conversões não-ansi para gerar l- valores.Por exemplo:

    char *p;
    (( int * ) p )++;
    
    ObservaçãoObservação

    Esta extensão está disponível em C linguagem - somente.Você pode usar o seguinte formato padrão de código ANSI C em C++ para alterar um ponteiro como se é um ponteiro para um tipo diferente.

    O exemplo anterior pode ser regravado como maneira para estar de acordo com o padrão ANSI C.

    p = ( char * )(( int * )p + 1 );
    
  • Conversões não-ansi de um ponteiro de função a um ponteiro de dados.Por exemplo:

    int ( * pfunc ) (); 
    int *pdata;
    pdata = ( int * ) pfunc;
    

    Para executar a mesma conversão e também manter compatibilidade ANSI, você pode converter o ponteiro de função a uintptr_t antes do converte para um ponteiro de dados:

    pdata = ( int * ) (uintptr_t) pfunc;
    

Listas de argumentos de comprimento variável

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

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

Comentários de linha única

O compilador C suporta os comentários de linha única, que são apresentados usando dois caracteres de barra (/):

// This is a single-line comment.

Escopo

O compilador C oferece suporte aos seguintes recursos escopo- relacionados.

  • Redefinições de itens extern como: static

    extern int clip();
    static int clip()
    {}
    
  • O uso de redefinições benignas de typedef no mesmo defina o escopo:

    typedef int INT;
    typedef int INT;
    
  • Os declarators de função têm 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 bloco- escopo que são inicializados usando 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;
    }
    

Declarações e definições de dados

O compilador C oferece suporte aos seguintes recursos de declaração e de definição de dados.

  • Constantes misturadas de caracteres e da cadeia de caracteres em um inicializador:

    char arr[5] = {'a', 'b', "cde"};
    
  • Campos de bits que têm tipos base diferentes de unsigned int ou de signed int.

  • Declarators que não têm uma classe de armazenamento ou tipo:

    x;
    int main( void )
    {
        x = 1;
    }
    
  • Dimensões indefinidas matrizes como o último campo em estruturas e em uniões:

    struct zero
    {
        char *c;
        int zarray[];
    };
    
  • Estruturas (anônimos) sem nome:

    struct
    {
        int i;
        char *s;
    };
    
  • Uniões (anônimos) sem nome:

    union
    {
        int i;
        float fl;
    };
    
  • Membros sem nome:

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

Funções de ponto flutuante intrínsecas

O compilador oferece suporte a geração embutido x86 Specific > de atan, de atan2, de cos, de exp, de log, de log10, de sin, de sqrt, e de funções END x86 Specific de tan/Oi quando é especificado.C, para compatibilidade ANSI é perdida quando esses intrinsics são usados, porque não definem a variável de errno .

Passando um parâmetro do ponteiro de não const a uma função que espera uma referência a um parâmetro do ponteiro const

Esta é uma extensão C++.Esse código irá compilar 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 ativado

Em /Ze, você precisa incluir iso646.h se você desejar usar formulários de texto operadores dos seguintes:

  • && (e)

  • &= (and_eq)

  • bitand (&)

  • | (bitor)

  • compl (~)

  • !(não)

  • ! = (not_eq)

  • || (ou)

  • |= (or_eq)

  • xor (^)

  • ^= (xor_eq)

O endereço de cadeia de caracteres Literal char tem o tipo de const [], não o caractere const (*) []

O exemplo const de caracteres de saída (*) [] 4 em /Za, mas char const [] /Ze4 em.

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

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

Consulte também

Referência

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

Opções do compilador

Configurando opções de compilador