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

Článek
06/09/2015

Jazyk Visual C++ rozšiřuje standardy ANSI C a ANSI C++ následujícím způsobem.

Klíčová slova

Je přidáno několik klíčových slov.V seznamu v tématu Klíčová slova jazyka C++ klíčová slova, která mají dvě úvodní podtržítka jsou rozšíření jazyka Visual C++.

Definice statických konstantních celočíselných (nebo výčtových) členů mimo třídu

V rámci standardu (/Za) je nutné provést definici datových členů mimo třídu, 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 je definice mimo třídu volitelná pro statické, konstantní celočíselné a konstantní výčtové datové členy.Pouze celočíselné a výčtové typy, které jsou statické a konstantní mohou mít inicializátory v třídě. Inicializační výraz musí být konstantní výraz.

Chcete-li zabránit chybám, když je definice mimo třídu provedena v souboru hlaviček a tento soubor hlaviček je obsažen ve více zdrojových souborech, použijte modifikátor selectany.Příklad:

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

Přetypování

Kompilátor jazyka C i C++ podporuje tyto druhy přetypování, které nejsou ve standardu ANSI:

Nestandardní přetypování vracející l-hodnoty.Příklad:
```
char *p;
(( int * ) p )++;
```
[!POZNÁMKA]

Toto rozšíření je k dispozici pouze v jazyce C.V kódu jazyka C++ lze použít následující formy standardu ANSI C ke změně ukazatele, pokud je to ukazatel na jiný typ.

Aby předchozí příklad vyhověl standardu ANSI C, měl by být přepsán následujícím způsobem.
```
p = ( char * )(( int * )p + 1 );
```
Nestandardní přetypování ukazatele na funkci na ukazatele na data.Příklad:
```
int ( * pfunc ) (); 
int *pdata;
pdata = ( int * ) pfunc;
```
Chcete-li provést stejné přetypování a také zachovat kompatibilitu se standardem ANSI, lze ukazatele na funkci přetypovat na typ uintptr_t před tím, než jej přetypujete na ukazatel na data:
```
pdata = ( int * ) (uintptr_t) pfunc;
```

Seznamy argumentů s proměnnou délkou

Kompilátor jazyka C i C++ podporuje deklarátor funkce, který určuje proměnný počet argumentů, následovaný definicí funkce, která místo toho poskytuje typ:

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

Jednořádkové komentáře

Kompilátor jazyka C podporuje jednořádkové poznámky, které lze vytvořit pomocí dvou znaků zpětného lomítka (//):

// This is a single-line comment.

Rozsah

Kompilátor jazyka C podporuje následující funkce vztahující se k rozsahu.

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

Deklarátory funkce mají rozsah 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í proměnných v rozsahu bloku, které jsou inicializovány pomocí nekonstantních výrazů:

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

Deklarace a definice dat

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

Smíšené znakové a řetězcové konstanty v inicializátoru:
```
char arr[5] = {'a', 'b', "cde"};
```
Bitová pole, která mají základní typy jiné než typu unsigned int nebo signed int.
Deklarátory, které nemají typ:
```
x;
int main( void )
{
    x = 1;
}
```
Pole bez velikosti jako poslední pole ve strukturách a sjednoceních:
```
struct zero
{
    char *c;
    int zarray[];
};
```
Nepojmenované struktury (anonymní):
```
struct
{
    int i;
    char *s;
};
```
Nepojmenované sjednocení (anonymní):
```
union
{
    int i;
    float fl;
};
```

Nepojmenované členy:

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

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

Kompilátor jazyka C i C++ podporuje vložené generování, specifické pro architekturu x86 >, funkcí atan, atan2, cos, exp, log, log10, sin, sqrt a tan specifických pro END x86, když je zadán /Oi.Kompilátor jazyka C přijde o shodu se standardem ANSI, pokud jsou tyto vnitřní objekty použity, protože nenastavují proměnnou errno.

Předání nekonstantního ukazatele jako parametru funkci, který očekává odkaz na parametr konstantního ukazatele

Toto je rozšíření jazyka C++.Tento kód se zkompiluje podle /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'
}

Standard ISO646.H není povolen.

Podle /Ze je nutné zahrnout soubor iso646.h, pokud chcete používat textové tvary následujících operátorů:

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

Adresa řetězcového literálu má typ const char [], ne typ const char (*) []

Následující příklad vrátí typ char const (*)[4] podle /Za, ale typ 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 (Zakázat jazyková rozšíření)

Možnosti kompilátoru

Nastavení možností kompilátoru

Sdílet prostřednictvím