Rozšíření Microsoft C a C++

Článek
03/12/2013

Visual C++ takto rozšiřuje standardy ANSI C a ANSI C++.

Klíčová slova

Několik klíčových slov jsou přidány.V seznamu v Klíčových slov jazyka C++, klíčová slova, která mají dvě přední podtržítka jsou rozšíření Visual C++.

Z definice třídy static const integrál (nebo enum) členů

Podle standardu (/Za), je nutné provést definici-class datových členů tak, jak je znázorněno zde:

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

Podle /Ze, definice-class je volitelná pro statické a const integrální a const výčet datových členů.Pouze integrály a výčty, které jsou statické a const může mít inicializátory ve třídě; inicializační výraz musí být konstantní výraz.

Chcete-li zabránit chybám při definici-class je k dispozici v záhlaví souboru a soubor hlaviček zahrnut do více zdrojových souborů, použijte selectany.Příklad:

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

Nádech

Kompilátor podporuje tyto druhy nádech jinou než ANSI:

Non-ANSI nádech vyrábět l hodnoty.Příklad:
```
char *p;
(( int * ) p )++;
```
[!POZNÁMKA]

Toto rozšíření je k dispozici v jazyce C pouze.Změnit ukazatel, pokud je ukazatel na jiný typ, můžete použít následující formulář standard ANSI C v kódu jazyka C++.

V předchozím příkladu by mohla být takto přepsána vyhovující ANSI C standard.
```
p = ( char * )(( int * )p + 1 );
```
Non-ANSI nádech ukazatel na ukazatel data.Příklad:
```
int ( * pfunc ) (); 
int *pdata;
pdata = ( int * ) pfunc;
```
K provedení téže tavby a také zachování kompatibility ANSI, můžete obsadit funkce ukazatele uintptr_t před přetypovat na ukazatel data:
```
pdata = ( int * ) (uintptr_t) pfunc;
```

Proměnná délka seznamů argumentů

Kompilátor podporuje deklarátor funkci, která určuje proměnný počet argumentů, následuje definice funkce poskytující typ:

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

Jednořádkové komentáře

Kompilátor C podporuje Jednořádkové komentáře, které jsou zavedeny dvě lomítka (/ /) znaky:

// This is a single-line comment.

Rozsah

Kompilátor C podporuje následující funkce týkající se oboru.

Redefinitions extern položek jako statický:
```
extern int clip();
static int clip()
{}
```
Použití neškodné typedef redefinitions v rámci stejného oboru:
```
typedef int INT;
typedef int INT;
```

Funkce declarators rozsahem souboru:

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

Použití bloku obor proměnné, které jsou inicializovány pomocí nonconstant výrazy:

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

Data deklarace a definice

Kompilátor C podporuje následující data deklarace a definice funkce.

Smíšené konstanty znakem a řetězcem v inicializátor
```
char arr[5] = {'a', 'b', "cde"};
```
Bit pole, které mají základní typy jiné než unsigned int nebo signed int.
Declarators, které nemají třídy úložiště nebo typ:
```
x;
int main( void )
{
    x = 1;
}
```
Podle velikosti netříděno pole jako poslední pole v struktury a sjednocení:
```
struct zero
{
    char *c;
    int zarray[];
};
```
Nepojmenované struktury (anonymní):
```
struct
{
    int i;
    char *s;
};
```
Nepojmenované sdružení (anonymní):
```
union
{
    int i;
    float fl;
};
```

Nepojmenované členy:

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

Vnitřní funkce naimplementované s plovoucí desetinnou čárkou

The compiler supports inline generation x86 Specific > of the atan, atan2, cos, exp, log, log10, sin, sqrt, and tan functions END x86 Specific when /Oi is specified.Pro C, ANSI shody ztracena se používají tyto vnitřní, protože není nastaveno errno proměnné.

Předání parametru Non Const ukazatel funkce, která se očekává, že odkaz na Const parametr ukazatele

To je rozšířením jazyka C++.Tento kód bude zkompilován s /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 není povoleno.

Podle /Ze, je nutné zahrnout iso646.h, chcete-li použít text formuláře následující operátory:

& & (a)
& = (and_eq)
& (bitand)
| (bitor)
~ (Autor sest)
!(ne)
! = (not_eq)
|| (nebo)
| = (or_eq)
^ (xor)
^ = (xor_eq)

Adresa [] const char řetězcový literál má typ, nikoli const char **]

V následujícím příkladu bude výstup char const ** [4] podle /Za, ale char const [4] podle /Ze.

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

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

Viz také

Referenční dokumentace

/ Za, /Ze (jazyk zakázat rozšíření)

Možnosti kompilátoru

Možnosti nastavení kompilátoru

Sdílet prostřednictvím