Extensions Microsoft pour C et C++

Article
08/10/2011

La liste suivante répertorie les extensions Visual C++ introduites en plus des normes C ANSI et C++ ANSI :

Mots clés

Microsoft étend le langage C++ avec plusieurs mots clés supplémentaires. Pour obtenir une liste complète, consultez C++ Keywords dans le Guide de référence du langage C++. Les mots clés avec deux traits de soulignement à gauche correspondent à des extensions Microsoft.

Définition hors classe des membres static, const, integral (ou enum)

Sous le standard (/Za), vous devez créer une définition hors classe pour les données membres. Par exemple :

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

Sous /Ze, la définition hors classe est facultative pour les données membres static, const integral et const enum. Seuls les membres integral et enum qui sont de type statique et const peuvent avoir des initialiseurs au sein d'une classe ; l'expression d'initialisation doit être une expression const.

Pour éviter des erreurs quand une définition hors classe est fournie (c'est-à-dire lorsque la définition hors classe est fournie dans un fichier d'en-tête et que celui-ci est inclus dans plusieurs fichiers source), vous devez utiliser selectany. Par exemple :

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

Casts

Le compilateur prend en charge les deux types de casts non-ANSI suivants :

Utilisation de casts non-ANSI pour produire des l-values :
```
char *p;
(( int * ) p )++;
```
L'exemple précédent peut être réécrit pour obtenir une conformité avec la norme C ANSI, de la manière suivante :
```
p = ( char * )(( int * )p + 1 );
```
Casting non-ANSI d'un pointeur fonction vers un pointeur donné :
```
int ( * pfunc ) (); 
int *pdata;
pdata = ( int * ) pfunc;
```
Pour effectuer le même cast tout en conservant la compatibilité ANSI, vous devez opérer un cast du pointeur fonction en type int avant d'effectuer un cast en pointeur donnée :
```
pdata = ( int * ) (int) pfunc;
```

Listes d'arguments de longueur variable

Le compilateur prend en charge l'utilisation d'un déclarateur de fonction qui spécifie un nombre variable d'arguments, suivi d'une définition de fonction qui fournit un type à sa place :

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

Commentaires sur une seule ligne

Le compilateur C prend en charge les commentaires sur une seule ligne, qui commencent par deux barres obliques (//) :

// This is a single-line comment.

Portée

Le compilateur C prend en charge les fonctionnalités suivantes liées à la portée :

Redéfinitions des éléments externes (externe) en tant qu'éléments statiques (static) :
```
extern int clip();
static int clip()
{}
```
Utilisation de redéfinitions typedef bénignes dans la même portée :
```
typedef int INT;
typedef int INT;
```

Déclarateurs de fonction avec une portée de fichier :

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

Utilisation de variables de portée bloc initialisées avec des expressions non constantes :

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

Définitions et déclarations de données

Le compilateur C prend en charge les fonctionnalités de définition et de déclaration de données suivantes :

Combinaison de constantes de types caractère et chaîne dans un initialiseur :
```
char arr[5] = {'a', 'b', "cde"};
```
Champs de bits avec des types de base autres que unsigned int ou signed int.
Déclarateurs sans classe de stockage ni type :
```
x;
int main( void )
{
    x = 1;
}
```
Tableaux non dimensionnés comme dernier champ dans les structures et les unions :
```
struct zero
{
    char *c;
    int zarray[];
};
```
Structures sans nom (anonymes) :
```
struct
{
    int i;
    char *s;
};
```
Unions sans nom (anonymes) :
```
union
{
    int i;
    float fl;
};
```

Membres sans nom :

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

Fonctions intrinsèques en virgule flottante

Le compilateur prend en charge la génération inline Spécifique x86 > des fonctions atan, atan2, cos, exp, log, log10, sin, sqrt et tan FIN xSpécifique x86 lorsque /Oi est spécifié. Pour C, la conformité ANSI n'est plus assurée quand ces fonctions intrinsèques sont utilisées, car elles ne définissent pas la variable errno.

Passage d'un paramètre pointeur non const à une fonction qui attend une référence à un paramètre pointeur const

Il s'agit d'une extension C++. Le code suivant sera compilé avec l'option /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'est pas activé

Sous /Ze, vous devez inclure iso646.h si vous voulez utiliser les opérateurs suivants dans leur format texte :

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

L'adresse du littéral de chaîne est de type const char [] et non const char (*) []

L'exemple suivant émet char const (*)[4] sous /Za, mais char const [4] sous /Ze.

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

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

Voir aussi

Référence

/Za, /Ze (Désactiver les extensions de langage)

Options du compilateur

Définition des options du compilateur

Partager via