Extensions Microsoft pour C et C++

Article
10/12/2023

Microsoft Visual C++ (MSVC) étend les normes du langage C et C++ de plusieurs façons, détaillées dans cet article.

Le compilateur MSVC C++ prend par défaut en charge ISO C++14 avec certaines fonctionnalités ISO C++17 et certaines extensions de langage spécifiques à Microsoft. Pour plus d’informations sur les fonctionnalités prises en charge, consultez la conformité du langage Microsoft C/C++ par la version de Visual Studio. Vous pouvez utiliser l’option du compilateur pour activer la /std prise en charge complète des fonctionnalités de langage ISO C++17 et ISO C++20. Pour plus d’informations, consultez /std (Spécifier la version standard du langage).

Lorsqu’elles sont spécifiées, certaines extensions de langage MSVC C++ peuvent être désactivées à l’aide de l’option du /Za compilateur. Dans Visual Studio 2017 et versions ultérieures, l’option /permissive- du compilateur désactive les extensions de langage C++ spécifiques à Microsoft. L’option /permissive- du compilateur est implicitement activée par les /std:c++20 options du compilateur./std:c++latest

Par défaut, quand MSVC compile du code en tant que C, il implémente ANSI C89 avec des extensions de langage spécifiques à Microsoft. Certaines de ces extensions MSVC sont normalisées dans ISO C99 et versions ultérieures. La plupart des extensions MSVC C peuvent être désactivées à l’aide de l’option /Za du compilateur, comme indiqué plus loin dans cet article. Vous pouvez utiliser l’option du compilateur pour activer la /std prise en charge de ISO C11 et C17. Pour plus d’informations, consultez /std (Spécifier la version standard du langage).

La bibliothèque de runtime C standard est implémentée par la bibliothèque d’exécution C universelle (UCRT) dans Windows. L’UCRT implémente également de nombreuses extensions de bibliothèque spécifiques à POSIX et Microsoft. L’UCRT prend en charge les normes de bibliothèque de runtime ISO C11 et C17, avec certaines mises en garde spécifiques à l’implémentation. Elle ne prend pas en charge la bibliothèque de runtime C standard ISO C99 complète. Pour plus d’informations, consultez la compatibilité dans la documentation de la bibliothèque runtime C universelle.

Mots clés

MSVC ajoute plusieurs mot clé spécifiques à Microsoft à C et C++. Dans la liste des mots clés, les mot clé qui ont deux traits de soulignement principaux sont des extensions MSVC.

Casts

Le compilateur C++ et le compilateur C prennent en charge ces types de casts non standard :

Le compilateur C prend en charge les casts non standard pour produire des valeurs l. Par exemple :
```
char *p;
(( int * ) p )++;
// In C with /W4, both by default and under /Ze:
//     warning C4213: nonstandard extension used: cast on l-value
// Under /TP or /Za:
//     error C2105: '++' needs l-value
```
Remarque

Cette extension est disponible uniquement dans le langage C. Vous pouvez utiliser le formulaire standard C suivant dans le code C++ pour modifier un pointeur comme s’il s’agit d’un pointeur vers un autre type.

L’exemple précédent peut être réécrit comme suit pour être conforme à la norme C.
```
p = ( char * )(( int * )p + 1 );
```

Les compilateurs C et C++ prennent en charge les casts non standard d’un pointeur de fonction vers un pointeur de données. Par exemple :

int ( * pfunc ) ();
int *pdata;
pdata = ( int * ) pfunc;
/* No diagnostic at any level, whether compiled with default options or under /Za */

Listes d’arguments de longueur variable

Les compilateurs C et C++ prennent en charge un déclarateur de fonction qui spécifie un nombre variable d’arguments, suivi d’une définition de fonction qui fournit un type à la place :

void myfunc( int x, ... );
void myfunc( int x, char * c )
{ }
// In C with /W4, either by default or under /Ze:
//     warning C4212: nonstandard extension used: function declaration used ellipsis
// In C with /W4, under /Za:
//     warning C4028: formal parameter 2 different from declaration
// In C++, no diagnostic by default or under /Za.

Commentaires à ligne unique

Le compilateur C prend en charge les commentaire de ligne uniques, qui sont introduites à l’aide de deux caractères de barre oblique (//) :

// This is a single-line comment.

Les commentaire de ligne uniques sont une fonctionnalité C99. Ils ne sont pas affectés par /Za et ne provoquent aucun diagnostic à un niveau quelconque.

Portée

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

Redéfinition des extern éléments en tant que static:

extern int clip();
static int clip() {}
// In C and C++ with /W4, either by default or under /Ze:
//     warning C4211: nonstandard extension used: redefined extern to static
// In C and C++ under /Za:
//     error C2375: 'clip': redefinition; different linkage

Utilisation de redefinitions de typedef sans gravité dans la même étendue :
```
typedef int INT;
typedef int INT; // No diagnostic at any level in C or C++
```

Les déclarateurs de fonction ont une étendue de fichier :

void func1()
{
     extern double func2( double );
     // In C at /W4:  warning C4210: nonstandard extension used: function given file scope
}
int main( void )
{
     func2( 4 );    //  /Ze passes 4 as type double
}                  //  /Za passes 4 as type int

Utilisation de variables d’étendue de bloc qui sont initialisées à l’aide d’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éclarations et définitions de données

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

Caractères mixtes et constantes de chaîne dans un initialiseur :

char arr[6] = {'a', 'b', "cde"};
// In C with /W4, either by default or under /Ze:
//     warning C4207: nonstandard extension used: extended initializer form
// Under /Za:
//     error C2078: too many initializers

Champs de bits qui ont des types de base autres que unsigned int ou signed int.

Déclarateurs qui n'ont pas de type :

x;
// By default or under /Ze, /Za, /std:c11, and /std:c17, when /W4 is specified:
//     warning C4431: missing type specifier - int assumed. Note: C no longer supports default-int
//     warning C4218: nonstandard extension used: must specify at least a storage class or a type
*/
int main( void )
{
     x = 1;
}

Tableaux non normalisés comme dernier champ dans les structures et les unions :

struct zero
{
     char *c;
     int zarray[];
     // In C with /W4, either by default, under /Ze, /std:c11, and /std:c17:
     //     warning C4200: nonstandard extension used: zero-sized array in struct/union
     // Under /Za:
     //     error C2133: 'zarray': unknown size
};

Structures non nommées (anonymes) :

struct
{
     int i;
     char *s;
};
// By default or under /Ze, /std:c11, and /std:c17, when /W4 is specified:
//     warning C4094: untagged 'struct' declared no symbols
// Under /Za:
//     error C2059: syntax error: 'empty declaration'

Unions non nommées (anonymes) :

union
{
     int i;
     float fl;
};
// By default or under /Ze, /std:c11, and /std:c17, when /W4 is specified:
//     warning C4094: untagged 'union' declared no symbols
// Under /Za:
//     error C2059: syntax error: 'empty declaration'

Fonctions à virgule flottante intrinsèques

Le compilateur X86 C++ et le compilateur C prennent en charge la atangénération inline du compilateur , logcosatan2exp, log10, , sinet sqrttan les fonctions quand ils /Oi sont spécifiés. Ces intrinsèques ne sont pas conformes à la norme, car elles ne définissent pas la errno variable.

`ISO646.H` non activé

Sous /Ze, vous devez inclure iso646.h si vous souhaitez utiliser des formulaires texte des opérateurs suivants :

Opérateur	Formulaire de texte
`&&`	`and`
`&=`	`and_eq`
`&`	`bitand`
`\|`	`bitor`
`~`	`compl`
`!`	`not`
`!=`	`not_eq`
`\|\|`	`or`
`\|=`	`or_eq`
`^`	`xor`
`^=`	`xor_eq`

Ces formulaires de texte sont disponibles sous forme de mot clé C++ sous /Za ou quand /permissive- ils sont spécifiés ou implicites.

Voir aussi

/Za, /Ze (Désactiver les extensions de langage)
Options du compilateur MSVC
Syntaxe de ligne de commande du compilateur MSVC