Microsoft-Erweiterungen für C und C++

Visual C++ erweitert die ANSI C und ANSI-C++ Standards wie folgt.

Schlüsselwörter

Verschiedene Schlüsselwörter werden hinzugefügt.In der Liste in C++-Schlüsselwörter, sind die Schlüsselwörter, die haben, zwei führende Unterstriche Visual C++-Erweiterungen.

Definition der Member "static", "const integral" und "const enum" außerhalb von Klassen

Unter dem Standard (/Za), müssen Sie eine Aus-vonKlassendefinition für Datenmember ausführen, wie hier gezeigt:

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

Unter /Ze ist die Definition außerhalb von Klassen für static-Datenmember, const integral-Datenmember und const enum-Datenmember optional.Nur Integrale und Enumerationen, die statisch sind und const können Initialisierer in einer Klasse haben; der initialisierende Ausdruck muss ein konstanten Ausdruck sein.

Um Fehler zu vermeiden Aus-vonKlassendefinition wenn eine in einer Headerdatei enthaltene und die Headerdatei in mehreren Quelldateien enthalten ist, verwenden Sie selectany.Beispiel:

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

Typumwandlungen

Der Compiler unterstützt diese Arten von NichtANSI-Umwandlungen:

• Nicht-ANSI-Umwandlungen, von L-Werten zu erzeugen.Beispiel:

  char *p;
  (( int * ) p )++;
  

  Hinweis
  Diese Erweiterung ist nur im Programmiersprache C verfügbar.Sie können das folgende ANSI C-Standardformular in C++-Code verwenden, um einen Zeiger zu ändern, als ob es ein Zeiger auf einen anderen Typ ist.

  Im vorherigen Beispiel kann wie folgt umgeschrieben werden, dass es an den ANSI C-Standard anzupassen.

  p = ( char * )(( int * )p + 1 );
  

• Nicht-ANSI-Umwandlungen eines Funktionszeigers zu einem Typumwandlung.Beispiel:

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

  Um die gleiche Umwandlung auszuführen und der ANSI-Kompatibilität auch beizubehalten, können Sie den Funktionszeiger zu uintptr_t umwandeln bevor Sie es auf einem Typumwandlung umgewandelt:

  pdata = ( int * ) (uintptr_t) pfunc;
  

Argumentlisten variabler Länge

Der Compiler unterstützt einen Funktionsdeklarator, der eine variable Anzahl von Argumenten angibt, gefolgt von einer Funktionsdefinition, die einen Typ stattdessen bereitstellt:

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

Einzeilige Kommentare

Der C-Compiler unterstützt einzeilige Kommentare, die mithilfe von zwei Schrägstrich (/) eingegeben werden:

// This is a single-line comment.

Umfang

Der C-Compiler unterstützt die folgenden Bereich-verknüpften Funktionen.

• Neudefinition von extern-Elementen als static:

  extern int clip();
  static int clip()
  {}
  

• Verwendung von typedef-Neudefinitionen ohne Auswirkung innerhalb desselben Gültigkeitsbereichs:

  typedef int INT;
  typedef int INT;
  

• Funktionsdeklaratoren haben Dateigültigkeitsbereich:

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

• Verwendung von Blockbereichsvariablen, die initialisiert werden, indem nicht konstante Ausdrücke verwendet werden:

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

Datendeklarationen und -definitionen

Der C-Compiler unterstützt die folgenden Datendeklarations- und -Definitionsfunktionen.

• Gemischte Zeichen- und Zeichenfolgekonstanten in einer Initialisierung:

  char arr[5] = {'a', 'b', "cde"};
  

• Bitfelder, die Basistypen anders unsigned int oder signed int haben.

• Deklaratoren, die weder eine Speicherklasse oder einen Typ besitzen:

  x;
  int main( void )
  {
      x = 1;
  }
  

• Arrays ohne Größenangabe als letztes Feld in Strukturen und Unions:

  struct zero
  {
      char *c;
      int zarray[];
  };
  

• Unbenannte (anonyme) Strukturen:

  struct
  {
      int i;
      char *s;
  };
  

• Unbenannte (anonyme) Unions:

  union
  {
      int i;
      float fl;
  };
  

• Unbenannte Member:

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

Systeminterne Gleitkommafunktionen

Der Compiler unterstützt die Inlinegenerierung x86 Specific > der Funktionen atan, atan2, cos, exp, log, log10, sin, sqrt und tanEND x86 Specific, wenn /Oi angegeben ist.Bei C geht die ANSI-Konformität verloren, wenn diese systeminterne Funktionen verwendet werden, weil die errno-Variable von ihnen nicht festgelegt wird.

Übergeben eines nicht konstanten Zeigerparameters an eine Funktion, die einen Verweis auf einen "const"-Zeigerparameter erwartet

Dies ist eine Erweiterung von C++.Dieser Code kompiliert mit /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 nicht aktiviert

Unter /Ze müssen Sie iso646.h einschließen, wenn Sie die Textformen der folgenden Operatoren verwenden möchten:

• && (und)

• &= (and_eq)

• & (bitand)

• | (bitor)

• ~ (compl)

• !(not)

• != (not_eq)

• || (or)

• |= (or_eq)

• ^ (xor)

• ^= (xor_eq)

Adresse des Zeichenfolgenliterals ist vom Typ const char [], nicht const char * () []

Im folgenden Beispiel wird char const (*)[4] bei Verwendung von /Za, bei Verwendung von /Ze jedoch char const [4] ausgegeben.

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

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

Siehe auch

Referenz

/Za, /Ze (Spracherweiterungen deaktivieren)

Compileroptionen

Festlegen von Compileroptionen