Visual C++: Neuerungen von 2003 bis 2015Visual C++ What's New 2003 through 2015

Auf dieser Seite werden alle Neuerungen für sämtliche Versionen von Visual C++ zusammengefasst – angefangen bei Visual Studio 2003 bis hin zu 2015.This page gathers all the "What's New" pages for all versions of Visual C++ from Visual Studio 2015 back to 2003. Diese Informationen werden bereitgestellt, um Sie zu unterstützen, falls Sie ein Upgrade von früheren Versionen von Visual Studio durchführen möchten.This information is provided as a convenience in case it might be useful when upgrading from earlier versions of Visual Studio.

Neuerungen bei C++ in Visual Studio 2015What's New for C++ in Visual Studio 2015

In Visual Studio 2015 und höher können sich fortlaufende Verbesserungen der Konformität des Compilers mit Standards möglicherweise darauf auswirken, wie der Compiler den vorhandenen Quellcode versteht.In Visual Studio 2015 and later, ongoing improvements to compiler conformance can sometimes change how the compiler understands your existing source code. In diesem Fall treten während Ihres Builds ggf. neue oder andere Fehler oder sogar Verhaltensunterschiede im Code auf, für den zuvor Builds erstellt wurden und die Ausführung ordnungsgemäß schien.When this happens, you might encounter new or different errors during your build, or even behavioral differences in code that previously built and seemed to run correctly.

Glücklicherweise haben diese Unterschiede wenig oder keinen Einfluss auf den Großteil Ihres Quellcodes. Sollten Quellcode- oder andere Änderungen zum Ausgleichen dieser Unterschiede erforderlich sein, sind Korrekturen in der Regel klein und einfach.Fortunately, these differences have little or no impact on most of your source code and when source code or other changes are needed to address these differences, fixes are usually small and straight-forward. Wir haben zahlreiche Beispiele für zuvor zulässigen Quellcode, die möglicherweise geändert werden müssen (vorher), und die Updates zur Korrektur (nachher) hinzugefügt.We've included many examples of previously-acceptable source code that might need to be changed (before) and the fixes to correct them (after).

Obwohl diese Unterschiede sich auf Ihren Quellcode oder andere Buildartefakte auswirken können, wirken sie sich nicht auf die Binärkompatibilität zwischen Updates für Visual C++-Versionen aus.Although these differences can affect your source code or other build artifacts, they don't affect binary compatibility between updates to Visual C++ versions. Eine schwerwiegendere Art der Änderung, die bedeutende Änderung, kann die Binärkompatibilität beeinträchtigen. Doch diese Arten von Unterbrechung der Binärkompatibilität treten nur zwischen Hauptversionen von Visual C++ auf.A more-severe kind of change, the breaking change can affect binary compatibility, but these kinds of binary compatibility breaks only occur between major versions of Visual C++. Beispielsweise zwischen Visual C++ 2013 und Visual C++ 2015.For example, between Visual C++ 2013 and Visual C++ 2015. Informationen zu bedeutenden Änderungen, die zwischen Visual C++ 2013 und Visual C++ 2015 vorgenommen wurden, finden Sie unter Änderungsverlauf von Visual C++ von 2003 bis 2015.For information on the breaking changes that occurred between Visual C++ 2013 and Visual C++ 2015, see Visual C++ change history 2003 - 2015.

Verbesserungen der Konformität in Visual Studio 2015Conformance Improvements in Visual Studio 2015

  • /Zc:forScope-Option/Zc:forScope- option

    Die Compileroption /Zc:forScope- ist veraltet und wird in einem der nächsten Releases entfernt.The compiler option /Zc:forScope- is deprecated and will be removed in a future release.

      Command line warning  D9035: option 'Zc:forScope-' has been deprecated and will be removed in a future release
    

    Die Option wurde in der Regel für nicht dem Standard entsprechenden Code verwendet, der Schleifenvariablen gemäß dem Standard nach dem Punkt verwendet, an dem diese den Gültigkeitsbereich verlassen sollten.The option was usually used in order to allow nonstandard code that uses loop variables after the point where, according to the standard, they should have gone out of scope. Dies war nur dann erforderlich, wenn die Kompilierung mit der /Za-Option erfolgte. Ohne die /Za-Option war eine Schleifenvariable nach dem Ende der Schleife immer zulässig.It was only necessary when you are compiling with the /Za option, since without /Za, using a for loop variable after the end of the loop is always allowed. Wenn die Einhaltung von Standards keine Rolle spielt (z.B. wenn der Code nicht auf andere Compiler übertragbar ist), können Sie die /Za-Option deaktivieren (oder die Eigenschaft Spracherweiterungen deaktivieren auf Nein festlegen).If you don't care about standards conformance (for example, if your code isn't meant to portable to other compilers), you could turn off the /Za option (or set the Disable Language Extensions property to No). Wenn Sie übertragbaren Code schreiben möchten, der den Standards entspricht, sollten Sie den Code umschreiben, indem Sie die Deklaration der Variablen an eine Stelle außerhalb der Schleifen verschieben.If you do care about writing portable, standards-compliant code, you should rewrite your code so that it conforms to the standard by moving the declaration of such variables to a point outside the loop.

      // zc_forScope.cpp
      // compile with: /Zc:forScope- /Za
      // C2065 expected
      int main() {
         // Uncomment the following line to resolve.
         // int i;
         for (int i =0; i < 1; i++)
            ;
         i = 20;   // i has already gone out of scope under /Za
      }
    
  • Zg-CompileroptionZg compiler option.

    Die /Zg-Compileroption (Funktionsprototypen generieren) ist nicht mehr verfügbar.The /Zg compiler option (Generate Function Prototypes) is no longer available. Diese Compileroption wurde zuvor als veraltet markiert.This compiler option was previously deprecated.

  • Sie können Komponententests nicht mehr mit C++/CLI über die Befehlszeile mit mstest.exe ausführen.You can no longer run unit tests with C++/CLI from the command-line with mstest.exe. Verwenden Sie stattdessen „vstest.console.exe“.Instead, use vstest.console.exe

  • Schlüsselwort mutablemutable keyword.

    Der mutable Speicherklassenspezifizierer ist an Orten, an denen er zuvor ohne Fehler kompiliert wurde, nicht mehr zulässig.The mutable storage class specifier is no longer allowed in places where previously it compiled without error. Der Compiler generiert nun den Fehler C2071 (Ungültige Speicherklasse).Now, the compiler gives error C2071 (illegal storage class). Gemäß dem Standard kann der mutable-Spezifizierer nur auf Namen von Klassendatenmembern angewendet werden und kann nicht auf als konstant oder statisch deklarierte Namen sowie nicht auf Verweismember angewendet werden.According to the standard, the mutable specifier can be applied only to names of class data members, and cannot be applied to names declared const or static, and cannot be applied to reference members.

    Beachten Sie z. B. folgenden Code:For example, consider the following code:

      struct S {
          mutable int &r;
      };
    

    In früheren Versionen des Microsoft Visual C++-Compilers war dies zulässig, jetzt generiert der Compiler jedoch den folgenden Fehler:Previous versions of the Microsoft C++ compiler accepted this, but now the compiler gives the following error:

      error C2071: 'S::r': illegal storage class
    

    Entfernen Sie einfach das redundante Schlüsselwort, um den Fehler zu beheben mutable .To fix the error, simply remove the redundant mutable keyword.

  • char_16_t und char32_tchar_16_t and char32_t

    Sie können nicht mehr char16_t oder char32_t als Aliase in einer typedef verwenden, da diese Typen nun als integriert behandelt werden.You can no longer use char16_t or char32_t as aliases in a typedef, because these types are now treated as built-in. Es war üblich, dass Benutzer und Bibliotheks Autoren und char16_t char32_t als Aliase von uint16_t uint32_t bzw. definieren.It was common for users and library authors to define char16_t and char32_t as aliases of uint16_t and uint32_t, respectively.

      #include <cstdint>
    
      typedef uint16_t char16_t; //C2628
      typedef uint32_t char32_t; //C2628
    
      int main(int argc, char* argv[])
      {
      uint16_t x = 1; uint32_t y = 2;
      char16_t a = x;
      char32_t b = y;
      return 0;
      }
    

    Um den Code zu aktualisieren, entfernen Sie die typedef Deklarationen und benennen alle anderen Bezeichner um, die mit diesen Namen in Konflikt stehen.To update your code, remove the typedef declarations and rename any other identifiers that collide with these names.

  • Nichttyp-VorlagenparameterNon-type template parameters

    Bestimmter Code mit Nichttyp-Vorlagenparametern wird auf Typkompatibilität korrekt geprüft, wenn Sie explizite Vorlagenargumente bereitstellen.Certain code that involves non-type template parameters is now correctly checked for type compatibility when you provide explicit template arguments. Der folgende Code wurde z. B. ohne Fehler in früheren Versionen von Visual C++ kompiliert.For example, the following code compiled without error in previous versions of Visual C++.

      struct S1
      {
          void f(int);
          void f(int, int);
      };
    
      struct S2
      {
          template <class C, void (C::*Function)(int) const> void f() {}
      };
    
      void f()
      {
          S2 s2;
          s2.f<S1, &S1::f>();
      }
    

    Der aktuelle Compiler generiert ordnungsgemäß einen Fehler, da der Typ des Vorlagenparameters nicht mit dem Vorlagenargument übereinstimmt (der Parameter ist ein Zeiger auf einen konstanten Member, die f-Funktion ist jedoch nicht konstant):The current compiler correctly gives an error, because the template parameter type doesn't match the template argument (the parameter is a pointer to a const member, but the function f is non-const):

      error C2893: Failed to specialize function template 'void S2::f(void)'note: With the following template arguments:note: 'C=S1'note: 'Function=S1::f'
    

    Stellen Sie zum Beheben dieses Fehlers im Code sicher, dass der Typ des verwendeten Vorlagenarguments mit dem deklarierten Typ des Vorlagenparameters übereinstimmt.To address this error in your code, make sure that the type of the template argument you use matches the declared type of the template parameter.

  • __declspec(align)

    Der Compiler lässt __declspec(align) in Funktionen nicht mehr zu.The compiler no longer accepts __declspec(align) on functions. Dies wurde bisher ignoriert, nun wird jedoch ein Compilerfehler generiert.This was always ignored, but now it produces a compiler error.

      error C3323: 'alignas' and '__declspec(align)' are not allowed on function declarations
    

    Entfernen Sie zum Beheben dieses Problems __declspec(align) aus der Funktionsdeklaration.To fix this problem, remove __declspec(align) from the function declaration. Da dies keine Auswirkungen hatte, ändert sich durch das Entfernen nichts.Since it had no effect, removing it does not change anything.

  • AusnahmebehandlungException handling

    Es gibt eine Reihe von Änderungen bei der Ausnahmebehandlung.There are a couple of changes to exception handling. Ausnahmeobjekte müssen kopiert oder verschoben werden können.First, exception objects have to be either copyable or movable. Der folgende Code wird zwar in Visual Studio 2013 kompiliert, aber nicht in Visual Studio 2015:The following code compiled in Visual Studio 2013, but does not compile in Visual Studio 2015:

      struct S {
      public:
          S();
      private:
          S(const S &);
      };
    
      int main()
      {
          throw S(); // error
      }
    

    Das Problem besteht darin, dass der Kopierkonstruktor privat ist. Somit kann das Objekt nicht während des normalen Betriebs der Ausnahmebehandlung kopiert werden.The problem is that the copy constructor is private, so the object cannot be copied as happens in the normal course of handling an exception. Dasselbe gilt, wenn der Kopierkonstruktor deklariert wird explicit .The same applies when the copy constructor is declared explicit.

      struct S {
          S();
          explicit S(const S &);
      };
    
      int main()
      {
          throw S(); // error
      }
    

    Stellen Sie zum Aktualisieren des Codes sicher, dass der Kopierkonstruktor für Ihr Ausnahme Objekt öffentlich und nicht als gekennzeichnet ist explicit .To update your code, make sure that the copy constructor for your exception object is public and not marked explicit.

    Beim Abfangen einer Ausnahme nach Wert muss das Ausnahmeobjekt ebenfalls kopiert werden können.Catching an exception by value also requires the exception object to be copyable. Der folgende Code wird zwar in Visual Studio 2013 kompiliert, aber nicht in Visual Studio 2015:The following code compiled in Visual Studio 2013, but does not compile in Visual Studio 2015:

      struct B {
      public:
          B();
      private:
          B(const B &);
      };
    
      struct D : public B {
      };
    
      int main()
      {
          try
          {
          }
          catch (D d) // error
          {
          }
      }
    

    Sie können dieses Problem beheben, indem Sie den Parametertyp für catch auf einen Verweis ändern.You can fix this issue by changing the parameter type for the catch to a reference.

      catch(D& d)
      {
      }
    
  • Zeichenfolgenliterale gefolgt von MakrosString literals followed by macros

    Der Compiler unterstützt nun benutzerdefinierte Literale.The compiler now supports user defined literals. Folglich werden Zeichenfolgenliterale, auf die Makros ohne dazwischenliegende Leerzeichen folgen, als benutzerdefinierte Literale interpretiert, was zu Fehlern oder unerwarteten Ergebnissen führen kann.As a consequence, string literals followed by macros without any intervening whitespace are interpreted as user-defined literals, which might produce errors or unexpected results. In vorherigen Compilern wurde der beispielsweise der folgende Code erfolgreich kompiliert:For example, in previous compilers the following code compiled successfully:

      #define _x "there"
      char* func() {
          return "hello"_x;
      }
      int main()
      {
          char * p = func();
          return 0;
      }
    

    Der Compiler interpretierte dies als ein Zeichenfolgenliteral „Hello“ gefolgt von einem Makro, das um „there“ erweitert wird, und führte die zwei Zeichenfolgenliterale zu einer verketteten Zeichenfolge zusammen.The compiler interpreted this as a string literal "hello" followed by a macro, which is expanded "there", and then the two string literals were concatenated into one. In Visual Studio 2015 interpretiert der Compiler dies als ein benutzerdefiniertes Literal. Da kein entsprechendes benutzerdefiniertes _x-Literal definiert ist, wird jedoch ein Fehler generiert.In Visual Studio 2015, the compiler interprets this as a user-defined literal, but since there is no matching user-defined literal _x defined, it gives an error.

      error C3688: invalid literal suffix '_x'; literal operator or literal operator template 'operator ""_x' not found
      note: Did you forget a space between the string literal and the prefix of the following string literal?
    
    

    Fügen Sie zur Behebung dieses Problems ein Leerzeichen zwischen das Zeichenfolgenliteral und das Makro ein.To fix this problem, add a space between the string literal and the macro.

  • Angrenzende ZeichenfolgenliteraleAdjacent string literals

    Auf ähnliche Weise wurden angrenzende Zeichenfolgenliterale ohne Leerzeichen aufgrund von zugehörigen Änderungen in der Zeichenfolgenanalyse als eine verkettete Zeichenfolge in den vorherigen Versionen von Visual C++ interpretiert.Similarly to the previous, due to related changes in string parsing, adjacent string literals (either wide or narrow character string literals) without any whitespace were interpreted as a single concatenated string in previous releases of Visaul C++. In Visual Studio 2015 müssen Sie ein Leerzeichen zwischen den beiden Zeichenfolgen hinzufügen.In Visual Studio 2015, you must now add whitespace between the two strings. Der folgende Code muss z. B. geändert werden:For example, the following code must be changed:

      char * str = "abc""def";
    

    Fügen Sie einfach ein Leerzeichen zwischen den beiden Zeichenfolgen hinzu.Simply add a space in between the two strings.

      char * str = "abc" "def";
    
  • Platzierungsoperatoren „new“ und „delete“Placement new and delete

    Der Operator hat eine Änderung vorgenommen, um eine delete Übereinstimmung mit dem c++ 14-Standard zu erzielen.A change has been made to the delete operator in order to bring it into conformance with C++14 standard. Detaillierte Informationen zur Standardänderung finden Sie unter Aufhebung der Zuordnung mit C++-Größeninformationen.Details of the standards change can be found at C++ Sized Deallocation. Die Änderungen fügen eine Form des globalen delete Operators hinzu, der einen size-Parameter annimmt.The changes add a form of the global delete operator that takes a size parameter. Wenn Sie zuvor einen Operator delete mit derselben Signatur verwendet haben (um einem Platzierungs Operator new zu entsprechen), erhalten Sie einen Compilerfehler (nämlich c2956, der an dem Punkt auftritt, an dem die Platzierung New verwendet wird, da dies die Position im Code ist, an der der Compiler versucht, einen entsprechenden übereinstimmenden delete Operator zu identifizieren). Breaking ChangeThe breaking change is that if you were previously using an operator delete with the same signature (to correspond with a placement new operator), you will receive a compiler error (C2956, which occurs at the point where the placement new is used, since that's the position in code where the compiler tries to identify an appropriate matching delete operator).

    Bei der Funktion void operator delete(void *, size_t) hat es sich um einen delete-Platzierungsoperator gehandelt, der der Funktion void * operator new(size_t, size_t) des Platzierungsoperators new in C++11 entspricht.The function void operator delete(void *, size_t) was a placement delete operator corresponding to the placement new function void * operator new(size_t, size_t) in C++11. Bei der Aufhebung der Zuordnung von c++ 14 entspricht diese delete Funktion nun der üblichen Zuordnungs Funktion (globaler delete Operator).With C++14 sized deallocation, this delete function is now a usual deallocation function (global delete operator). Der Standard erfordert, dass das Programm nicht ordnungsgemäß formatiert ist, wenn die Verwendung einer Platzierungs neuen Platzierung eine entsprechende delete Funktion sucht und eine übliche Funktion zum Aufheben der Zuordnung findet.The standard requires that if the use of a placement new looks up a corresponding delete function and finds a usual deallocation function, the program is ill-formed.

    Nehmen Sie beispielsweise an, dass Ihr Code sowohl eine Platzierung New als auch eine Platzierungs Löschungdefiniert:For example, suppose your code defines both a placement new and a placement delete:

      void * operator new(std::size_t, std::size_t);
      void operator delete(void*, std::size_t) noexcept;
    

    Das Problem tritt aufgrund der Entsprechung in den Funktions Signaturen zwischen einem von Ihnen definierten Platzierungs Lösch Operator und dem neuen globalen Größen delete Operator auf.The problem occurs because of the match in function signatures between a placement delete operator you've defined, and the new global sized delete operator. Stellen Sie sich vor, ob Sie einen anderen Typ als size_t für die Platzierung neuer -und- delete Operatoren verwenden können.Consider whether you can use a different type other than size_t for any placement new and delete operators. Beachten Sie, dass der Typ der vom size_t typedef Compiler abhängigen ist, d typedef . h. ein für unsigned int in Visual C++.Note that the type of the size_t typedef is compiler-dependent; it is a typedef for unsigned int in Visual C++. Eine gute Lösung hierfür stellt die Verwendung eines enumerierten Typs wie die des folgenden dar:A good solution is to use an enumerated type such as this:

      enum class my_type : size_t {};
    

    Ändern Sie dann die Definition der Platzierung, new und delete verwenden Sie diesen Typ als zweites Argument anstelle von size_t .Then, change your definition of placement new and delete to use this type as the second argument instead of size_t. Sie müssen auch die Aufrufe von Platzierung New aktualisieren, um den neuen Typ zu übergeben (z. b. mithilfe von static_cast<my_type> , um den ganzzahligen Wert zu konvertieren) und die Definition von und aktualisieren, new delete um Sie wieder in den ganzzahligen Typ umzuwandeln.You'll also need to update the calls to placement new to pass the new type (for example, by using static_cast<my_type> to convert from the integer value) and update the definition of new and delete to cast back to the integer type. Hierfür müssen Sie keinen verwenden enum . ein Klassentyp mit einem size_t Member würde ebenfalls funktionieren.You don't need to use an enum for this; a class type with a size_t member would also work.

    Eine alternative Lösung besteht darin, dass Sie möglicherweise die Platzierung der neuen Platzierung vollständig ausschließen können.An alternative solution is that you might be able to eliminate the placement new altogether. Wenn Ihr Code die Platzierung New verwendet, um einen Speicherpool zu implementieren, bei dem das Platzierungs Argument die Größe des zugeordneten oder gelöschten Objekts ist, kann das Feature zum Aufheben der Speicher Belegung geeignet sein, um den eigenen benutzerdefinierten Speicherpool Code zu ersetzen, und Sie können die Platzierungsfunktionen entfernen und einfach einen eigenen Operator mit zwei Argumenten delete anstelle der Platzierungsfunktionen verwenden.If your code uses placement new to implement a memory pool where the placement argument is the size of the object being allocated or deleted, then sized deallocation feature might be suitable to replace your own custom memory pool code, and you can get rid of the placement functions and just use your own two-argument delete operator instead of the placement functions.

    Wenn Sie Ihren Code nicht sofort aktualisieren möchten, können Sie mit der Compileroption /Zc:sizedDealloc- das alte Verhalten wiederherstellen.If you don't want to update your code immediately, you can revert to the old behavior by using the compiler option /Zc:sizedDealloc-. Wenn Sie diese Option verwenden, sind die delete Funktionen mit zwei Argumenten nicht vorhanden und führen nicht zu einem Konflikt mit dem Platzierungs Lösch Operator.If you use this option, the two-argument delete functions don't exist and won't cause a conflict with your placement delete operator.

  • Union-DatenmemberUnion data members

    Union-Datenmember dürfen über keine Verweistypen verfügen.Data members of unions can no longer have reference types. Der folgende Code kompiliert zwar in Visual Studio 2013 erfolgreich, aber erzeugt in Visual Studio 2015 einen Fehler.The following code compiled successfully in Visual Studio 2013, but produces an error in Visual Studio 2015.

      union U1 {
          const int i;
      };
      union U2 {
         int &i;
      };
      union U3 {
          struct {int &i;};
      };
    

    Der oben genannte Code geniert die folgenden Fehler:The preceding code produces the following errors:

      test.cpp(67): error C2625: 'U2::i': illegal union member; type 'int &' is reference type
      test.cpp(70): error C2625: 'U3::i': illegal union member; type 'int &' is reference type
    

    Ändern Sie zur Behebung dieses Fehlers die Verweistypen in einen Zeiger oder einen Wert.To address this issue, change reference types either to a pointer or a value. Für die Änderung des Typs in einen Zeiger sind Änderungen im Code erforderlich, der das Union-Feld verwendet.Changing the type to a pointer requires changes in the code that uses the union field. Durch die Änderung des Codes in einen Wert werden die in der Union gespeicherten Daten geändert, was Auswirkungen auf andere Felder hat, da Felder in Uniontypen den gleichen Speicher gemeinsam verwenden.Changing the code to a value would change the data stored in the union, which affects other fields since fields in union types share the same memory. Je nach Wertgröße kann dies ggf. auch die Größe der Union ändern.Depending on the size of the value, it might also change the size of the union.

  • Anonyme UnionsAnonymous unions

    weisen nun eine höhere Standardkonformität auf.are now more conformant to the standard. Frühere Versionen des Compilers haben einen expliziten Konstruktor und Destruktor für anonyme Unions generiert.Previous versions of the compiler generated an explicit constructor and destructor for anonymous unions. Diese sind in Visual Studio 2015 nicht mehr vorhanden.These are deleted in Visual Studio 2015.

    struct S {
        S();
    };
    
    union {
        struct {
           S s;
        };
    } u; // C2280
    

    Der oben genannte Code geniert in Visual Studio 2015 den folgenden Fehler:The preceding code generates the following error in Visual Studio 2015:

      error C2280: '<unnamed-type-u>::<unnamed-type-u>(void)': attempting to reference a deleted function
      note: compiler has generated '<unnamed-type-u>::<unnamed-type-u>' here
    

    Geben Sie zur Behebung dieses Fehlers eigene Definitionen des Konstruktors und/oder des Destruktors an.To resolve this issue, provide your own definitions of the constructor and/or destructor.

      struct S {
         // Provide a default constructor by adding an empty function body.
         S() {}
      };
    
      union {
         struct {
            S s;
         };
      } u;
    
  • Unions mit anonymen StrukturenUnions with anonymous structs

    Zur Einhaltung des Standards wurde das Laufzeitverhalten für Member anonymer Strukturen in Unions geändert.In order to conform with the standard, the runtime behavior has changed for members of anonymous structures in unions. Der Konstruktor für anonyme Strukturmember in einer Union wird nicht mehr implizit aufgerufen, wenn eine solche Union erstellt wird.The constructor for anonymous structure members in a union is no longer implicitly called when such a union is created. Der Destruktor für anonyme Strukturmember in einer Union wird nicht mehr implizit aufgerufen, wenn die Union den Gültigkeitsbereich verlässt.Also, the destructor for anonymous structure members in a union is no longer implicitly called when the union goes out of scope. Betrachten Sie den folgenden Code, in dem eine Union U eine anonyme Struktur mit einem Member enthält, der die Struktur S mit einem Destruktor darstellt.Consider the following code, in which a union U contains an anonymous structure that contains a member which is a named structure S that has a destructor.

      #include <stdio.h>
      struct S {
          S() { printf("Creating S\n"); }
          ~S(){ printf("Destroying S\n"); }
      };
      union U {
          struct {
          S s;
      };
          U() {}
          ~U(){}
      };
    
      void f()
      {
          U u;
          // Destructor implicitly called here.
      }
    
      int main()
      {
          f();
    
          char s[1024];
          printf("Press any key.\n");
          gets_s(s);
          return 0;
      }
    

    Der Konstruktor für S wird in Visual Studio 2013 immer dann aufgerufen, wenn die Union erstellt wird, und der Destruktor für S wird immer dann aufgerufen, wenn der Stapel für Funktion f bereinigt wird.In Visual Studio 2013, the constructor for S is called when the union is created, and the destructor for S is called when the stack for function f is cleaned up. In Visual Studio 2015 werden jedoch weder der Konstruktor noch der Destruktor aufgerufen.But in Visual Studio 2015, the constructor and destructor are not called. Der Compiler gibt eine Warnung zu dieser Verhaltensänderung aus.The compiler gives a warning about this behavior change.

      warning C4587: 'U::s': behavior change: constructor is no longer implicitly calledwarning C4588: 'U::s': behavior change: destructor is no longer implicitly called
    

    Benennen Sie zum Wiederherstellen des ursprünglichen Verhaltens die anonyme Struktur.To restore the original behavior, give the anonymous structure a name. Das Laufzeitverhalten von nicht anonymen Strukturen ist von der Compilerversion unabhängig.The runtime behavior of non-anonymous structures is the same, regardless of the compiler version.

      #include <stdio.h>
    
      struct S {
          S() { printf("Creating S.\n"); }
          ~S() { printf("Destroying S\n"); }
      };
      union U {
          struct {
              S s;
          } namedStruct;
          U() {}
          ~U() {}
      };
    
      void f()
      {
          U u;
      }
    
      int main()
      {
          f();
    
          char s[1024];
          printf("Press any key.\n");
          gets_s(s);
          return 0;
      }
    

    Verschieben Sie alternativ den Konstruktor- und Destruktorcode in die neuen Funktionen, und fügen Sie diesen Funktionen aus der Konstruktor- und Destruktorunion Aufrufe hinzu.Alternatively, try moving the constructor and destructor code into new functions, and add calls to these functions from the constructor and destructor for the union.

      #include <stdio.h>
    
      struct S {
          void Create() { printf("Creating S.\n"); }
          void Destroy() { printf("Destroying S\n"); }
      };
      union U {
          struct {
              S s;
          };
          U() { s.Create();  }
          ~U() { s.Destroy(); }
      };
    
      void f()
      {
          U u;
      }
    
      int main()
      {
          f();
    
      char s[1024];
      printf("Press any key.\n");
      gets_s(s);
      return 0;
      }
    
  • VorlagenauflösungTemplate resolution

    Es wurden Änderungen an der Namensauflösung für Vorlagen vorgenommen.Changes have been made to name resolution for templates. Bei Berücksichtigung der Kandidaten für eine Namensauflösung können potenzielle Namen in C++ ggf. eine ungültige Vorlageninstanziierung erzeugen.In C++, when considering candidates for the resolution of a name, it can be the case that one or more names under consideration as potential matches produces an invalid template instantiation. Diese ungültigen Instanziierungen generieren in der Regel keine Comilerfehler – das SFINAE-Prinzip (Ersetzungsfehler sind keine Fehler).These invalid instantiations do not normally cause compiler errors, a principle which is known as SFINAE (Substitution Failure Is Not An Error).

    Wenn der Compiler jetzt von SFINAE zum Instanziieren der Spezialisierung einer Klassenvorlage aufgefordert wird, handelt es sich bei allen während dieses Prozesses aufgetretenen Fehler um Compilerfehler.Now, if SFINAE requires the compiler to instantiate the specialization of a class template, then any errors that occur during this process are compiler errors. In früheren Versionen hat der Compiler diese Fehler ignoriert.In previous versions, the compiler would ignore such errors. Beachten Sie z. B. folgenden Code:For example, consider the following code:

      #include <type_traits>
    
      template<typename T>
      struct S
      {
      S() = default;
      S(const S&);
      S(S&&);
    
      template<typename U, typename = typename std::enable_if<std::is_base_of<T, U>::value>::type>
      S(S<U>&&);
      };
    
      struct D;
    
      void f1()
      {
      S<D> s1;
          S<D> s2(s1);
      }
    
      struct B
      {
      };
    
      struct D : public B
      {
      };
    
      void f2()
      {
      S<D> s1;
          S<D> s2(s1);
      }
    

    Beim Kompilieren mit dem aktuellen Compiler tritt der folgende Fehler auf:If you compile with the current compiler, you get the following error:

      type_traits(1110): error C2139: 'D': an undefined class is not allowed as an argument to compiler intrinsic type trait '__is_base_of'
      ..\t331.cpp(14): note: see declaration of 'D'
      ..\t331.cpp(10): note: see reference to class template instantiation 'std::is_base_of<T,U>' being compiled
              with
              [
                  T=D,
                  U=D
              ]
    

    Dies liegt daran, dass die D-Klasse zum Zeitpunkt des ersten Aufrufs von is_base_of noch nicht definiert war.This is because at the point of the first invocation of the is_base_of the class 'D' has not yet been defined.

    In diesem Fall besteht die Lösung darin, diese Typmerkmale nicht zu verwenden, bis die Klasse definiert wurde.In this case, the fix is not to use such type traits until the class has been defined. Wenn Sie die Definitionen von B und D an den Anfang der Codedatei verschieben, wird der Fehler behoben.If you move the definitions of B and D to the beginning of the code file, the error is resolved. Überprüfen Sie, wenn sich die Definitionen in Headerdateien befinden, die Reihenfolge der Include-Anweisungen für die Headerdateien, um sicherzustellen, dass alle Klassendefinitionen kompiliert werden, bevor die problematischen Vorlagen verwendet werden.If the definitions are in header files, check the order of the include statements for the header files to make sure that any class definitions are compiled before the problematic templates are used.

  • KopierkonstruktorenCopy constructors

    Sowohl in Visual Studio 2013 als auch in Visual Studio 2015 generiert der Compiler einen Kopierkonstruktor für eine Klasse, die über einen benutzerdefinierten Bewegungskonstruktor verfügt, jedoch über keinen benutzerdefinierten Kopierkonstruktor.In both Visual Studio 2013 and Visual Studio 2015, the compiler generates a copy constructor for a class if that class has a user-defined move constructor but no user-defined copy constructor. In Dev14 wird dieser implizit generierte Kopierkonstruktor ebenfalls als „= delete“ gekennzeichnet.In Dev14, this implicitly generated copy constructor is also marked "= delete".

Verbesserungen der Konformität in Visual Studio 2015 Update 1Conformance Improvements in Visual Studio 2015 Update 1

  • Private virtuelle Basisklassen und indirekte VererbungPrivate virtual base classes and indirect inheritance

    In früheren Versionen des Compilers war es abgeleiteten Klassen möglich, Member ihrer indirekt abgeleiteten private virtual Basisklassen aufzurufen.Previous versions of the compiler allowed a derived class to call member functions of its indirectly-derived private virtual base classes. Dieses alte Verhalten war falsch und entsprach nicht dem C++-Standard.This old behavior was incorrect and does not conform to the C++ standard. Der Compiler akzeptiert in dieser Weise erstellten Code nicht mehr und gibt den Compilerfehler C2280 als Ergebnis aus.The compiler no longer accepts code written in this way and issues compiler error C2280 as a result.

      error C2280: 'void *S3::__delDtor(unsigned int)': attempting to reference a deleted function
    

    Beispiel (vorher)Example (before)

      class base
      {
      protected:
          base();
          ~base();
      };
    
      class middle: private virtual base {};class top: public virtual middle {};
    
      void destroy(top *p)
      {
          delete p;  //
      }
    

    Beispiel (nachher)Example (after)

      class base;  // as above
    
      class middle: protected virtual base {};
      class top: public virtual middle {};
    
      void destroy(top *p)
      {
          delete p;
      }
    

    - oder --or-

      class base;  // as above
    
      class middle: private virtual base {};
      class top: public virtual middle, private virtual bottom {};
    
      void destroy(top *p)
      {
          delete p;
      }
    
  • Überladener Operator „new“ und „delete“Overloaded operator new and operator delete

    In früheren Versionen des Compilers konnte ein new-Platzierungsoperator, der kein Member war, und ein delete-Platzierungsoperator, der kein Member war, statisch deklariert werden und in anderen Namespaces als dem globalen deklariert werden.Previous versions of the compiler allowed non-member operator new and non-member operator delete to be declared static, and to be declared in namespaces other than the global namespace. Dieses alte Verhalten hat das Risiko verursacht, dass das Programm nicht die new Implementierung des Operators oder des delete Operators aufruft, die der Programmierer beabsichtigt hat, was zu einem stillen ungültigen Laufzeitverhalten führt.This old behavior created a risk that the program would not call the new or delete operator implementation that the programmer intended, resulting in silent bad runtime behavior. Der Compiler akzeptiert in dieser Weise erstellten Code nicht mehr und gibt den Compilerfehler C2323 als Ergebnis aus.The compiler no longer accepts code written in this way and issues compiler error C2323 instead.

      error C2323: 'operator new': non-member operator new or delete functions may not be declared static or in a namespace other than the global namespace.
    

    Beispiel (vorher)Example (before)

      static inline void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // error C2323
    

    Beispiel (nachher)Example (after)

      void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // removed 'static inline'
    

    Außerdem, auch wenn dazu keine spezifische Diagnose ausgegeben wird, wird ein Inlineoperator „new“ als nicht wohlgeformt angesehen.Additionally, although the compiler doesn't give a specific diagnostic, inline operator new is considered ill-formed.

  • Aufrufen von „operator type()“ (Benutzerdefinierter Wechsel für Nichtklassentypen) Frühere Versionen des Compilers haben den Aufruf von „operator type()“ für Nichtklassentypen zugelassen und den Aufruf still ignoriert.Calling 'operator type()' (user-defined conversion) on non-class types Previous versions of the compiler allowed 'operator type()' to be called on non-class types while silently ignoring it. Durch dieses alte Verhalten entstand die Gefahr der stummen Erzeugung von ungültigem Code, was zu unvorhersehbarem Laufzeitverhalten führt.This old behavior created a risk of silent bad code generation, resulting in unpredictable runtime behavior. Der Compiler akzeptiert in dieser Weise erstellten Code nicht mehr und gibt den Compilerfehler C2228 als Ergebnis aus.The compiler no longer accepts code written in this way and issues compiler error C2228 instead.

      error C2228: left of '.operator type' must have class/struct/union
    

    Beispiel (vorher)Example (before)

      typedef int index_t;
    
      void bounds_check(index_t index);
    
      void login(int column)
      {
          bounds_check(column.operator index_t());  // error C2228
      }
    

    Beispiel (nachher)Example (after)

      typedef int index_t;
    
      void bounds_check(index_t index);
    
      void login(int column)
      {
           bounds_check(column);  // removed cast to 'index_t', 'index_t' is an alias of 'int'
      }
    
  • Redundanter Typname in ausführlichen Typspezifizierern In früheren Versionen des Compilers waren typename in einem ausführlichen Typspezifizierer zulässig. in dieser Weise geschriebener Code ist semantisch falsch.Redundant typename in elaborated type specifiers Previous versions of the compiler allowed typename in an elaborated type specifiers; code written in this way is semantically incorrect. Der Compiler akzeptiert in dieser Weise erstellten Code nicht mehr und gibt den Compilerfehler C3406 als Ergebnis aus.The compiler no longer accepts code written in this way and issues compiler error C3406 instead.

      error C3406: 'typename' cannot be used in an elaborated type specifier
    

    Beispiel (vorher)Example (before)

      template <typename class T>
      class container;
    

    Beispiel (nachher)Example (after)

      template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case
      class container;
    
  • Typableitung von Arrays aus einer Initialisiererliste In früheren Versionen des Compilers wurde die Typableitung von Arrays aus einer Initialisiererliste nicht unterstützt.Type deduction of arrays from an initializer list Previous versions of the compiler did not support type deduction of arrays from an initializer list. Der Compiler unterstützt jetzt diese Form der Typableitung. Das kann zur Folge haben, dass Aufrufe an Funktionsvorlagen mithilfe von Initialisiererlisten jetzt möglicherweise nicht mehr eindeutig sind, oder es wird eine andere Überladung gewählt als in früheren Versionen des Compilers.The compiler now supports this form of type deduction and, as a result, calls to function templates using initializer lists might now be ambiguous or a different overload might be chosen than in previous versions of the compiler. Um diese Probleme zu beheben, muss das Programm jetzt die vom Programmierer beabsichtigte Überladung explizit angeben.To resolve these issues, the program must now explicitly specify the overload that the programmer intended.

    Wenn dieses neue Verhalten dazu führt, dass bei der Überladungsauflösung ein weitere Kandidat als ebenso gut wie der historische Kandidat angesehen wird, ist der Aufruf nicht mehr eindeutig, und der Compiler gibt den Compilerfehler C2668 als Ergebnis aus.When this new behavior causes overload resolution to consider an additional candidate that is equally as good as the historic candidate, the call becomes ambiguous and the compiler issues compiler error C2668 as a result.

      error C2668: 'function' : ambiguous call to overloaded function.
    

    Beispiel 1: Mehrdeutiger Aufruf einer überladenen Funktion (vorher)Example 1: Ambiguous call to overloaded function (before)

      // In previous versions of the compiler, code written in this way would unambiguously call f(int, Args...)
      template <typename... Args>
      void f(int, Args...);  //
    
      template <int N, typename... Args>
      void f(const int (&)[N], Args...);
    
      int main()
      {
          // The compiler now considers this call ambiguous, and issues a compiler error
          f({3});  error C2668: 'f' ambiguous call to overloaded function
      }
    

    Beispiel 1: Mehrdeutiger Aufruf einer überladenen Funktion (nachher)Example 1: ambiguous call to overloaded function (after)

      template <typename... Args>
      void f(int, Args...);  //
    
      template <int N, typename... Args>
      void f(const int (&)[N], Args...);
    
      int main()
      {
          // To call f(int, Args...) when there is just one expression in the initializer list, remove the braces from it.
          f(3);
      }
    

    Wenn dieses neue Verhalten bewirkt, dass ein anderer Kandidat bei der Überladungsauflösung als bessere Übereinstimmung als der historische Kandidat angesehen wird, wird der Aufruf unzweideutig zum neuen Kandidaten aufgelöst, was eine Änderung im Verhalten des Programms bewirkt, das vermutlich von den Absichten des Programmierers abweicht.When this new behavior causes overload resolution to consider an additional candidate that is a better match than the historic candidate, the call resolves unambiguously to the new candidate, causing a change in program behavior that is probably different than the programmer intended.

    Beispiel 2: Änderung an der Überladungsauflösung (vorher)Example 2: change in overload resolution (before)

      // In previous versions of the compiler, code written in this way would unambiguously call f(S, Args...)
      struct S
      {
          int i;
          int j;
      };
    
      template <typename... Args>
      void f(S, Args...);
    
      template <int N, typename... Args>
      void f(const int *&)[N], Args...);
    
      int main()
      {
          // The compiler now resolves this call to f(const int (&)[N], Args...) instead
          f({1, 2});
      }
    

    Beispiel 2: Änderung an der Überladungsauflösung (nachher)Example 2: change in overload resolution (after)

      struct S;  // as before
    
      template <typename... Args>
      void f(S, Args...);
    
      template <int N, typename... Args>
      void f(const int *&)[N], Args...);
    
      int main()
      {
          // To call f(S, Args...), perform an explicit cast to S on the initializer list.
          f(S{1, 2});
      }
    
  • Wiederherstellung von Warnungen der switch-AnweisungRestoration of switch statement warnings

    Von einer früheren Version des Compilers wurden bereits vorhandene Warnungen im Zusammenhang mit- switch Anweisungen entfernt; diese Warnungen wurden jetzt wieder hergestellt.A Previous version of the compiler removed previously-existing warnings related to switch statements; these warnings have now been restored. Der Compiler gibt jetzt die wiederhergestellten Warnungen aus, und Warnungen, die sich auf bestimmte Fälle (einschließlich des Standardfalls) bezogen, werden jetzt in der Zeile ausgegeben, die den Verstoß enthält, statt in der letzten Zeile der switch-Anweisung.The compiler now issues the restored warnings, and warnings related to specific cases (including the default case) are now issued on the line containing the offending case, rather than on the last line of the switch statement. Die Ausgabe dieser Warnungen in anderen Zeilen als bisher kann zur Folge haben, dass Warnungen, die früher mithilfe von #pragma warning(disable:####) unterdrückt wurden, möglicherweise nicht mehr wie beabsichtigt unterdrückt werden.As a result of now issuing those warnings on different lines than in the past, warnings previously suppressed by using #pragma warning(disable:####) may no longer be suppressed as intended. Um diese Warnungen wie beabsichtigt zu unterdrücken, kann es erforderlich sein, die #pragma warning(disable:####) -Anweisung in eine Zeile oberhalb des ersten möglichen Verstoßes zu verschieben.To suppress these warnings as intended, it might be necessary to move the #pragma warning(disable:####) directive to a line above the first potentially-offending case. Die wiederhergestellten Warnungen folgen hier:The following are the restored warnings.

      warning C4060: switch statement contains no 'case' or 'default' labels
    
      warning C4061: enumerator 'bit1' in switch of enum 'flags' is not explicitly handled by a case label
    
      warning C4062: enumerator 'bit1' in switch of enum 'flags' is not handled
    
      warning C4063: case 'bit32' is not a valid value for switch of enum 'flags'
    
      warning C4064: switch of incomplete enum 'flags'
    
      warning C4065: switch statement contains 'default' but no 'case' labels
    
      warning C4808: case 'value' is not a valid value for switch condition of type 'bool'
    
      Warning C4809: switch statement has redundant 'default' label; all possible 'case' labels are given
    

    Beispiel für C4063 (vorher)Example of C4063 (before)

      class settings
      {
      public:
          enum flags
          {
              bit0 = 0x1,
              bit1 = 0x2,
              ...
          };
          ...
      };
    
      int main()
      {
          auto val = settings::bit1;
    
          switch (val)
          {
          case settings::bit0:
              break;
    
          case settings::bit1:
              break;
    
          case settings::bit0 | settings::bit1:  // warning C4063
              break;
          }
      };
    

    Beispiel für C4063 (nachher)Example of C4063 (after)

      class settings {...};  // as above
    
      int main()
      {
          // since C++11, use std::underlying_type to determine the underlying type of an enum
          typedef std::underlying_type<settings::flags>::type flags_t;
    
          auto val = settings::bit1;
    
          switch (static_cast<flags_t>(val))
          {
          case settings::bit0:
              break;
    
          case settings::bit1:
              break;
    
          case settings::bit0 | settings::bit1:  // ok
              break;
          }
      };
    

    Beispiele für die anderen wiederhergestellten Warnungen stehen in deren Dokumentation zur Verfügung.Examples of the other restored warnings are provided in their documentation.

  • #include: Verwendung des Bezeichners '..' für das übergeordnete Verzeichnis im Pfadnamen (betrifft nur /Wall /WX)#include: use of parent-directory specifier '..' in pathname (only affects /Wall /WX)

    Frühere Versionen des Compilers haben die Verwendung des Bezeichners '..'Previous versions of the compiler did not detect the use of the parent-directory specifier '..' für das übergeordnete Verzeichnis im Pfadnamen von #include -Anweisungen nicht erkannt.in the pathname of #include directives. Bei in dieser Weise erstelltem Code wird normalerweise die Absicht verfolgt, Header einzuschließen, die sich außerhalb des Projekts befinden, und dazu werden fälschlicherweise projektrelative Pfade verwendet.Code written in this way is usually intended to include headers that exist outside of the project by incorrectly using project-relative paths. Bei diesem alten Verhalten ergab sich die Gefahr, dass das Programm möglicherweise mit Einschluss einer anderen als der vom Programmierer beabsichtigten Quelldatei compiliert wurde oder dass diese relativen Pfade nicht auf andere Buildumgebungen portiert werden konnten.This old behavior created a risk that the program could be compiled by including a different source file than the programmer intended, or that these relative paths would not be portable to other build environments. Der Compiler erkennt jetzt in dieser Weise erstellten Code und benachrichtigt den Programmierer mit der optionalen Compilerwarnung C4464, sofern diese aktiviert ist.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C4464, if enabled.

      warning C4464: relative include path contains '..'
    

    Beispiel (vorher)Example (before)

      #include "..\headers\C4426.h"  // emits warning C4464
    

    Beispiel (nachher)Example (after)

      #include "C4426.h"  // add absolute path to 'headers\' to your project's include directories
    

    Darüber hinaus empfehlen wir, auch wenn der Compiler dazu keine spezifischen Diagnosemeldungen ausgibt, den Bezeichner ".." für das übergeordnete Verzeichnis beim Angeben der Includeverzeichnisse des Projekts nicht zu verwenden.Additionally, although the compiler does not give a specific diagnostic, we also recommend that the parent-directory specifier ".." should note be used to specify your project's include directories.

  • #pragma optimize() erstreckt sich über das Ende der Headerdatei hinaus (betrifft nur /Wall /WX)#pragma optimize() extends past end of header file (only affects /Wall /WX)

    In früheren Versionen wurden Änderungen an den Optimierungseinstellungen nicht erkannt, die zum Escapen einer in einer Übersetzungseinheit eingeschlossenen Headerddatei dienen.Previous versions of the compiler did not detect changes to optimization flag settings that escape a header file included within a translation unit. Der Compiler erkennt jetzt in dieser Weise erstellten Code und setzt den Programmierer mit der optionalen Compilerwarnung C4426 von der Position des #include-Verstoßes in Kenntnis, sofern diese aktiviert ist.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C4426 at the location of the offending #include, if enabled. Diese Warnung wird nur ausgegeben, wenn die Änderungen im Konflikt mit den Optimierungseinstellungen stehen, die durch die Befehlszeilenargumente für den Compiler festgelegt wurden.This warning is only issued if the changes conflict with the optimization flags set by command-line arguments to the compiler.

      warning C4426: optimization flags changed after including header, may be due to #pragma optimize()
    

    Beispiel (vorher)Example (before)

      // C4426.h
      #pragma optimize("g", off)
      ...
      // C4426.h ends
    
      // C4426.cpp
      #include "C4426.h"  // warning C4426
    

    Beispiel (nachher)Example (after)

      // C4426.h
      #pragma optimize("g", off)
      ...
      #pragma optimize("", on)  // restores optimization flags set via command-line arguments
      // C4426.h ends
    
      // C4426.cpp
      #include "C4426.h"
    
  • Nicht übereinstimmende Festlegung von „#pragma warning(push)“ und #pragma warning(pop) (betrifft nur /Wall /WX)Mismatched #pragma warning(push) and #pragma warning(pop) (only affects /Wall /WX)

    Frühere Versionen des Compilers konnten keine #pragma warning(push)-Statusänderungen erkennen, die in Kombination mit #pragma warning(pop)-Statusänderungen in einer anderen Quelldatei auftraten, was selten beabsichtigt ist.Previous versions of the compiler did not detect #pragma warning(push) state changes being paired with #pragma warning(pop) state changes in a different source file, which is rarely intended. Dieses alte Verhalten brachte die Gefahr mit sich, dass das Programm mit anderen Warnungseinstellungen als den vom Programmierer vorgesehenen kompiliert wurde, was möglicherweise zu einem schlechten Laufzeitverhalten führt.This old behavior created a risk that the program would be compiled with a different set of warnings enabled than the programmer intended, possibly resulting in silent bad runtime behavior. Der Compiler erkennt jetzt auf diese Weise erstellten Code und setzt den Programmierer mit der optionalen Compilerwarnung C5031 von der Position der #pragma warning(pop)-Übereinstimmung in Kenntnis, sofern diese aktiviert ist.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C5031 at the location of the matching #pragma warning(pop), if enabled. Diese Warnung enthält einen Hinweis, der auf den Speicherort der entsprechenden #pragma warning(push)-Warnung verweist.This warning includes a note referencing the location of the corresponding #pragma warning(push).

      warning C5031: #pragma warning(pop): likely mismatch, popping warning state pushed in different file
    

    Beispiel (vorher)Example (before)

      // C5031_part1.h
      #pragma warning(push)
      #pragma warning(disable:####)
      ...
      // C5031_part1.h ends without #pragma warning(pop)
    
      // C5031_part2.h
      ...
      #pragma warning(pop)  // pops a warning state not pushed in this source file
      ...
      // C5031_part1.h ends
    
      // C5031.cpp
      #include "C5031_part1.h" // leaves #pragma warning(push) 'dangling'
      ...
      #include "C5031_part2.h" // matches 'dangling' #pragma warning(push), resulting in warning C5031
      ...
    

    Beispiel (nachher)Example (after)

      // C5031_part1.h
      #pragma warning(push)
      #pragma warning(disable:####)
      ...
      #pragma warning(pop)  // pops the warning state pushed in this source file
      // C5031_part1.h ends without #pragma warning(pop)
    
      // C5031_part2.h
      #pragma warning(push)  // pushes the warning state pushed in this source file
      #pragma warning(disable:####)
      ...
      #pragma warning(pop)
      // C5031_part1.h ends
    
      // C5031.cpp
      #include "C5031_part1.h" // #pragma warning state changes are self-contained and independent of other source files or their #include order.
      ...
      #include "C5031_part2.h"
      ...
    

    Wenngleich ungewöhnlich, wird Code mitunter absichtlich auf diese Weise geschrieben.Though uncommon, code written in this way is sometimes intentional. Auf diese Weise erstellter Code ist empfindlich gegenüber Änderungen an der #include-Reihenfolge. Wir empfehlen, dass Quellcodedateien den Warnungsstatus nach Möglichkeit eigenständig verwalten sollten.Code written in this way is sensitive to changes in #include order; when possible, we recommend that source code files manage warning state in a self-contained way.

  • Nicht zugeordnete „#pragma warning“ (push) (betrifft nur /Wall /WX)Unmatched #pragma warning(push) (only affects /Wall /WX)

    Frühere Versionen des Compilers haben nicht zugeordnete #pragma warning(push) -Statusänderungen am Ende einer Übersetzungseinheit nicht erkannt.Previous versions of the compiler did not detect unmatched #pragma warning(push) state changes at the end of a translation unit. Der Compiler erkennt jetzt auf diese Weise erstellten Code und informiert den Programmierer mit der optionalen Compilerwarnung C5032 über die Position der fehlenden #pragma warning(push)-Übereinstimmung, sofern diese aktiviert ist.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C5032 at the location of the unmatched #pragma warning(push), if enabled. Diese Warnung wird nur ausgegeben, wenn in der Übersetzungseinheit keine Kompilierfehler auftreten.This warning is only issued if there are no compilation errors in the translation unit.

      warning C5032: detected #pragma warning(push) with no corresponding #pragma warning(pop)
    

    Beispiel (vorher)Example (before)

      // C5032.h
      #pragma warning(push)
      #pragma warning(disable:####)
      ...
      // C5032.h ends without #pragma warning(pop)
    
      // C5032.cpp
      #include "C5032.h"
      ...
      // C5032.cpp ends -- the translation unit is completed without #pragma warning(pop), resulting in warning C5032 on line 1 of C5032.h
    

    Beispiel (nachher)Example (after)

      // C5032.h
      #pragma warning(push)
      #pragma warning(disable:####)
      ...
      #pragma warning(pop) // matches #pragma warning (push) on line 1
      // C5032.h ends
    
      // C5032.cpp
      #include "C5032.h"
      ...
      // C5032.cpp ends -- the translation unit is completed without unmatched #pragma warning(push)
    
  • Möglicherweise werden weitere Warnungen als Folge der verbesserten Statusnachverfolgung bei „#pragma warning“ angezeigtAdditional warnings might be issued as a result of improved #pragma warning state tracking

    In früheren Versionen des Compilers wurden Statusänderungen bei #pragma warning nicht hinreichend gut nachverfolgt, um alle beabsichtigten Warnungen auszugeben.Previous versions of the compiler tracked #pragma warning state changes insufficiently well to issue all intended warnings. Durch dieses Verhalten bestand die Gefahr, dass bestimmte Warnungen unter anderen als den vom Programmierer beabsichtigten Umständen effektiv unterdrückt wurden.This behavior created a risk that certain warnings would be effectively suppressed in circumstances different than the programmer intended. Die Nachverfolgung des Status von #pragma warning erfolgt nun auf stabilere Weise – insbesondere im Zusammenhang mit #pragma warning-Statusänderungen in Vorlagen – und gibt optional die neuen Warnungen C5031 und C5032 aus, die den Programmierer bei der Suche nach unbeabsichtigter Verwendung von #pragma warning(push) und #pragma warning(pop) unterstützen sollen.The compiler now tracks #pragma warning state more robustly -- especially related to #pragma warning state changes inside of templates -- and optionally issues new warnings C5031 and C5032 which are intended to help the programmer locate unintended uses of #pragma warning(push) and #pragma warning(pop).

    Als Ergebnis der verbesserten Nachverfolgung des Status von #pragma warning können jetzt Warnungen ausgegeben werden, die früher fälschlicherweise unterdrückt wurden oder mit falsch identifizierten Problemen zusammenhingen.As a result of improved #pragma warning state change tracking, warnings formerly incorrectly suppressed or warnings related to issues formerly misdiagnosed might now be issued.

  • Verbesserte Erkennung von unerreichbarem CodeImproved identification of unreachable code

    Änderungen an der C++-Standardbibliothek und eine im Vergleich mit früheren Versionen des Compilers verbesserte Möglichkeit zur Inlineausführung von Funktionsaufrufen ermöglichen dem Compiler jetzt unter Umständen den Nachweis, dass bestimmter Code unerreichbar ist.C++ Standard Library changes and improved ability to inline function calls over previous versions of the compiler might allow the compiler to prove that certain code is now unreachable. Dieses neue Verhalten kann zu neuen und häufiger ausgegebenen Instanzen von Warnung C4720 führen.This new behavior can result in new and more-frequently issued instances of warning C4720.

      warning C4720: unreachable code
    

    In vielen Fällen wird diese Warnung nur beim Kompilieren mit aktivierten Optimierungen ausgegeben, da bei den Optimierungen mehr Funktionsaufrufe inline erfolgen, redundanter Code eliminiert wird oder auf andere Weise die Möglichkeit geschaffen wird, bestimmten Code als unerreichbar zu erkennen.In many cases, this warning might only be issued when compiling with optimizations enabled, since optimizations may inline more function calls, eliminate redundant code, or otherwise make it possible to determine that certain code is unreachable. Wir haben festgestellt, dass neue Instanzen von Warning C4720 häufig in try/catch- Blöcken aufgetreten sind, insbesondere in Bezug auf die Verwendung von Std:: Find.We have observed that new instances of warning C4720 have frequently occurred in try/catch blocks, especially in relation to use of std::find.

    Beispiel (vorher)Example (before)

      try
      {
          auto iter = std::find(v.begin(), v.end(), 5);
      }
      catch(...)
      {
          do_something();  // ok
      }
    

    Beispiel (nachher)Example (after)

      try
      {
          auto iter = std::find(v.begin(), v.end(), 5);
      }
      catch(...)
      {
          do_something();  // warning C4702: unreachable code
      }
    

Verbesserungen der Konformität in Visual Studio 2015 Update 2Conformance Improvements in Visual Studio 2015 Update 2

  • Zusätzliche Warnungen und Fehler können als Ergebnis der Teilunterstützung für den Ausdruck SFINAE ausgegeben werdenAdditional warnings and errors might be issued as a result of partial support for expression SFINAE

    Frühere Versionen des Compilers haben bestimmte Arten von Ausdrücken innerhalb von Bezeichners nicht analysiert decltype , weil der Ausdruck sfinae nicht unterstützt wird.Previous versions of the compiler did not parse certain kinds of expressions inside decltype specifiers due to lack of support for expression SFINAE. Dieses alte Verhalten war falsch und entsprach nicht dem C++-Standard.This old behavior was incorrect and does not conform to the C++ standard. Der Compiler analysiert diese Ausdrücke jetzt und hat aufgrund kontinuierlicher Konformitätsverbesserungen eine Teilunterstützung für den Ausdruck SFINAE.The compiler now parses these expressions and has partial support for expression SFINAE due to ongoing conformance improvements. Daher gibt der Compiler jetzt Warnungen und Fehler aus, die er in Ausdrücken findet, die von früheren Versionen des Compilers nicht analysiert werden.As a result, the compiler now issues warnings and errors found in expressions that previous versions of the compiler did not parse.

    Wenn dieses neue Verhalten einen- decltype Ausdruck analysiert, der einen Typ enthält, der noch nicht deklariert wurde, gibt der Compiler den Compilerfehler C2039 als Ergebnis aus.When this new behavior parses a decltype expression that includes a type that has not yet been declared, the compiler issues compiler error C2039 as a result.

      error C2039: 'type': is not a member of '`global namespace''
    

    Beispiel 1: Verwendung eines nicht deklarierten Typs (vorher)Example 1: use of an undeclared type (before)

      struct s1
      {
        template <typename T>
        auto f() -> decltype(s2<T>::type::f());  // error C2039
    
        template<typename>
        struct s2 {};
      }
    

    Beispiel 1 (nachher)Example 1 (after)

      struct s1
      {
        template <typename>  // forward declare s2struct s2;
    
        template <typename T>
        auto f() -> decltype(s2<T>::type::f());
    
        template<typename>
        struct s2 {};
      }
    

    Wenn dieses neue Verhalten einen- decltype Ausdruck analysiert, dem eine erforderliche Verwendung des- typename Schlüssel Worts fehlt, um anzugeben, dass ein abhängiger Name ein-Typ ist, gibt der Compiler die Compilerwarnung C4346 in Verbindung mit dem Compilerfehler C2923 aus.When this new behavior parses a decltype expression that is missing a necessary use of the typename keyword to specify that a dependent name is a type, the compiler issues compiler warning C4346 together with compiler error C2923.

      warning C4346: 'S2<T>::Type': dependent name is not a type
    
      error C2923: 's1': 'S2<T>::Type' is not a valid template type argument for parameter 'T'
    

    Beispiel 2: Abhängiger Name ist kein Typ (vorher)Example 2: dependent name is not a type (before)

      template <typename T>
      struct s1
      {
        typedef T type;
      };
    
      template <typename T>
      struct s2
      {
        typedef T type;
      };
    
      template <typename T>
      T declval();
    
      struct s
      {
        template <typename T>
        auto f(T t) -> decltype(t(declval<S1<S2<T>::type>::type>()));  // warning C4346, error C2923
      };
    

    Beispiel 2 (nachher)Example 2 (after)

      template <typename T> struct s1 {...};  // as above
      template <typename T> struct s2 {...};  // as above
    
      template <typename T>
      T declval();
    
      struct s
      {
        template <typename T>
        auto f(T t) -> decltype(t(declval<S1<typename S2<T>::type>::type>()));
      };
    
  • volatile****Member-Variablen verhindern implizit definierte Konstruktoren und Zuweisungs Operatoren Frühere Versionen des Compilers ermöglichten, dass eine Klasse mit Element volatile Variablen standardmäßige Kopier-/bewegungskonstruktoren und standardmäßige Kopier-/verschiebezuweisungsoperatoren automatisch generiert werden.volatile member variables prevent implicitly defined constructors and assignment operators Previous versions of the compiler allowed a class that has volatile member variables to have default copy/move constructors and default copy/move assignment operators automatically generated. Dieses alte Verhalten war falsch und entsprach nicht dem C++-Standard.This old behavior was incorrect and does not conform to the C++ standard. Der Compiler geht bei einer Klasse mit volatilen Membervariablen davon aus, dass sie nicht triviale Konstruktions- und Zuweisungsoperatoren hat. Dies verhindert, dass Standardimplementierungen dieser Operatoren automatisch generiert werden.The compiler now considers a class that has volatile member variables to have non-trivial construction and assignment operators which prevents default implementations of these operators from being automatically generated. Ist eine solche Klasse ein Member einer Union (oder einer anonymen Union innerhalb einer Klasse), werden Kopier-/Verschiebekonstruktoren und Kopier-/Verschiebezuweisungsoperatoren der Union (oder die Klasse, die die anonyme Union enthält) implizit als gelöscht definiert.When such a class is a member of a union (or an anonymous union inside of a class), the copy/move constructors and copy/move assignment operators of the union (or the class containing the unonymous union) will be implicitly defined as deleted. Wird versucht, die Union (oder die Klasse, die die anonyme Union enthält) zu erstellen oder zu kopieren, ohne sie explizit zu definieren, tritt ein Fehler auf, und der Compiler gibt den Compilerfehler C2280 aus.Attempting to construct or copy the union (or class containing the anonymous union) without explicitly defining them is an error and the compiler issues compiler error C2280 as a result.

      error C2280: 'B::B(const B &)': attempting to reference a deleted function
    

    Beispiel (vorher)Example (before)

      struct A
      {
        volatile int i;
        volatile int j;
      };
    
      extern A* pa;
    
      struct B
      {
        union
        {
          A a;
          int i;
        };
      };
    
      B b1 {*pa};
      B b2 (b1);  // error C2280
    

    Beispiel (nachher)Example (after)

      struct A
      {
        int i;int j;
      };
    
      extern volatile A* pa;
    
      A getA()  // returns an A instance copied from contents of pa
      {
        A a;
        a.i = pa->i;
        a.j = pa->j;
        return a;
      }
    
      struct B;  // as above
    
      B b1 {GetA()};
      B b2 (b1);  // error C2280
    
  • Statische Memberfunktionen unterstützen keine cv-QualifiziererStatic member functions do not support cv-qualifiers.

    In früheren Versionen von Visual C++ 2015 ist es zulässig, dass statische Memberfunktionen CV-Qualifizierer haben.Previous versions of Visual C++ 2015 allowed static member functions to have cv-qualifiers. Dieses Verhalten ist durch einen Rückschritt in Visual C++ 2015 und Visual C++ 2015 Update 1 begründet. Visual C++ 2013 und frühere Versionen von Visual C++ weisen Code zurück, der in dieser Weise geschrieben ist.This behavior is due to a regression in Visual C++ 2015 and Visual C++ 2015 Update 1; Visual C++ 2013 and previous versions of Visual C++ reject code written in this way. Das Verhalten von Visual C++ 2015 und Visual C++ 2015 Update 1 ist falsch und entspricht nicht dem C++-Standard.The behavior of Visual C++ 2015 and Visual C++ 2015 Update 1 is incorrect and does not conform to the C++ standard. Visual Studio 2015 Update 2 weist Code, der in dieser Weise geschrieben ist, zurück und gibt stattdessen den Compilerfehler C2511 aus.Visual Studio 2015 Update 2 rejects code written in this way and issues compiler error C2511 instead.

      error C2511: 'void A::func(void) const': overloaded member function not found in 'A'
    

    Beispiel (vorher)Example (before)

      struct A
      {
        static void func();
      };
    
      void A::func() const {}  // C2511
    

    Beispiel (nachher)Example (after)

      struct A
      {
        static void func();
      };
    
      void A::func() {}  // removed const
    
  • Vorwärtsdeklaration einer Enumeration ist in WinRT-Code nicht zulässig (betrifft nur /ZW)Forward declaration of enum is not allowed in WinRT code (affects /ZW only)

    Code, der für die Windows-Runtime (WinRT) kompiliert enum wurde, lässt nicht zu, dass Typen als deklariert werden, ähnlich wie bei der Kompilierung von verwaltetem C++-Code für .NET Framework mit dem /clr Compilerschalter.Code compiled for the Windows Runtime (WinRT) doesn't allow enum types to be forward declared, similarly to when managed C++ code is compiled for the .Net Framework using the /clr compiler switch. Dieses Verhalten stellt sicher, dass die Größe einer Enumeration immer bekannt ist und richtig in das WinRT-Typsystem projiziert werden kann.This behavior is ensures that the size of an enumeration is always known and can be correctly projected to the WinRT type system. Der Compiler lehnt in dieser Weise geschriebenen Code ab und gibt den Compilerfehler C2599 zusammen mit dem Compilerfehler C3197 aus.The compiler rejects code written in this way and issues compiler error C2599 together with compiler error C3197.

      error C2599: 'CustomEnum': the forward declaration of a WinRT enum is not allowed
    
      error C3197: 'public': can only be used in definitions
    

    Beispiel (vorher)Example (before)

      namespace A {
        public enum class CustomEnum: int32;  // forward declaration; error C2599, error C3197
      }
    
      namespace A {
        public enum class CustomEnum: int32
        {
          Value1
        };
      }
    
      public ref class Component sealed
      {
      public:
        CustomEnum f()
        {
          return CustomEnum::Value1;
        }
      };
    

    Beispiel (nachher)Example (after)

                // forward declaration of CustomEnum removed
      namespace A {
        public enum class CustomEnum: int32
        {
          Value1
        };
      }
    
      public ref class Component sealed
      {
      public:
        CustomEnum f()
        {
          return CustomEnum::Value1;
        }
      };
    
  • new- oder delete-Funktionen eines überladenen Nicht-Memberoperators dürfen nicht inline deklariert werden (Level 1 (/W1) standardmäßig aktiviert)Overloaded non-member operator new and operator delete may not be declared inline (Level 1 (/W1) on-by-default)

    Frühere Versionen des Compilers geben keine Warnung aus, wenn nicht Member Operator new und Operator Delete -Funktionen als Inline deklariert werden.Previous versions of the compiler do not issue a warning when non-member operator new and operator delete functions are declared inline. Auf diese Weise geschriebener Code ist nicht ordnungsgemäß formatiert (keine Diagnose erforderlich). Dies kann zu Arbeitsspeicherproblemen führen, die sich aus nicht zusammengehörigen new- und delete-Operatoren ergeben (insbesondere bei Verwendung von Zuordnungsaufhebung mit Größenangabe), die sich nur schwer diagnostizieren lassen.Code written in this way is ill-formed (no diagnostic required) and can cause memory issues resulting from mismatched new and delete operators (especially when used together with sized deallocation) that can be difficult to diagnose. Der Compiler gibt jetzt die Warnung C4595 aus, um Code erkennen zu können, der in dieser Weise geschrieben ist.The compiler now issues compiler warning C4595 to help identify code written in this way.

      warning C4595: 'operator new': non-member operator new or delete functions may not be declared inline
    

    Beispiel (vorher)Example (before)

      inline void* operator new(size_t sz)  // warning C4595
      {
        ...
      }
    

    Beispiel (nachher)Example (after)

      void* operator new(size_t sz)  // removed inline
      {
        ...
      }
    

    Ein Korrigieren von Code, der in dieser Weise geschrieben ist, kann erfordern, dass die Operatordefinitionen aus einer Headerdatei in eine entsprechende Quelldatei verschoben werden.Fixing code that's written in this way might require that the operator definitions be moved out of a header file and into a corresponding source file.

Verbesserungen der Konformität in Visual Studio 2015 Update 3Conformance Improvements in Visual Studio 2015 Update 3

  • std::is_convertable erkennt jetzt Selbstzuweisung (Standardbibliothek) Frühere Versionen des Typmerkmals std::is_convertable haben die Selbstzuweisung eines Klassentyps nicht ordnungsgemäß anerkannt, wenn der Kopierkonstruktor gelöscht wurde oder privat war.std::is_convertable now detects self-assignment (standard library) Previous versions of the std::is_convertable type-trait did not correctly detect self-assignment of a class type when its copy constructor is deleted or private. Nun std::is_convertable<>::value ist ordnungsgemäß auf festgelegt, false Wenn Sie auf einen Klassentyp mit einem gelöschten oder privaten Kopierkonstruktor angewendet wird.Now, std::is_convertable<>::value is correctly set to false when applied to a class type with a deleted or private copy constructor.

    Dieser Änderung ist keine Compilerdiagnose zugeordnet.There is no compiler diagnostic associated with this change.

    BeispielExample

      #include <type_traits>
    
      class X1
      {
      public:
          X1(const X1&) = delete;
      };
    
      class X2
      {
      private:
          X2(const X2&);
      };
    
      static_assert(std::is_convertible<X1&, X1>::value, "BOOM");static_assert(std::is_convertible<X2&, X2>::value, "BOOM");
    

    In früheren Versionen von Visual C++ wurden die statischen Assertionen unten in diesem Beispiel übergeben, da std::is_convertable<>::value fälschlicherweise auf festgelegt wurde true .In previous versions of Visual C++, the static assertions at the bottom of this example pass because std::is_convertable<>::value was incorrectly set to true. Nun std::is_convertable<>::value ist richtig auf festgelegt false , sodass die statischen Assertionen fehlschlagen.Now, std::is_convertable<>::value is correctly set to false, causing the static assertions to fail.

  • Standardmäßig verwendete und gelöschte triviale Kopier- und Verschiebekonstruktoren beachten ZugriffsspezifiziererDefaulted or deleted trivial copy and move constructors respect access specifiers

    In früheren Versionen des Compilers wurden die Zugriffsspezifizierer von als Standard festgelegten und gelöschten trivialen Kopier- und Verschiebekonstruktoren nicht geprüft, ehe ihr Aufrufen erlaubt wurde.Previous versions of the compiler did not check the access specifier of defaulted or deleted trivial copy and move constructors before allowing them to be called. Dieses alte Verhalten war falsch und entsprach nicht dem C++-Standard.This old behavior was incorrect and does not conform to the C++ standard. Durch dieses alte Verhalten entstand in einigen Fällen die Gefahr der stummen Erzeugung von ungültigem Code, was zu unvorhersehbarem Laufzeitverhalten führt.In some cases, this old behavior created a risk of silent bad code generation, resulting in unpredictable runtime behavior. Der Compiler prüft jetzt den Zugriffsspezifizierer von als Standard festgelegten und gelöschten trivialen Kopier- und Verschiebekonstruktoren, um zu bestimmen, ob diese aufgerufen werden können. Falls nicht, gibt der Compiler die Warnung C2248 aus.The compiler now checks the access specifier of defaulted or deleted trivial copy and move constructors to determine whether it can be called, and if not, issues compiler warning C2248 as a result.

      error C2248: 'S::S' cannot access private member declared in class 'S'
    

    Beispiel (vorher)Example (before)

      class S {
      public:
         S() = default;
      private:
          S(const S&) = default;
      };
    
      void f(S);  // pass S by value
    
      int main()
      {
          S s;
          f(s);  // error C2248, can't invoke private copy constructor
      }
    

    Beispiel (nachher)Example (after)

      class S {
      public:
         S() = default;
      private:
          S(const S&) = default;
      };
    
      void f(const S&);  // pass S by reference
    
      int main()
      {
          S s;
          f(s);
      }
    
  • Attributierter ATL-Code veraltet (Level 1 (/W1) standardmäßig EIN)Deprecation of attributed ATL code support (Level 1 (/W1) on-by-default)

    Frühere Versionen des Compilers haben attributierten ATL-Code unterstützt.Previous versions of the compiler supported attributed ATL code. In der nächsten Phase der Aufhebung der Unterstützung von attributiertem ATL-Code, die in Visual C++ 2008 begann, gilt attributierter ATL-Code nun als veraltet.As the next phase of removing support for attributed ATL code that began in Visual C++ 2008, attributed ATL code has been deprecated. Der Compiler gibt jetzt die Warnung C4467 aus, um diese Art von veraltetem Code erkennen zu können.The compiler now issues compiler warning C4467 to help identify this kind of deprecated code.

      warning C4467: Usage of ATL attributes is deprecated
    

    Wenn Sie attributierten ATL-Code bis zur Aufhebung der Unterstützung durch den Compiler weiter nutzen möchten, können Sie diese Warnung deaktivieren, indem Sie das Befehlszeilenargument /Wv:18 oder /wd4467 an den Compiler übergeben oder #pragma warning(disable:4467) Ihrem Quellcode hinzufügen.If you want to continue using attributed ATL code until support is removed from the compiler, you can disable this warning by passing the /Wv:18 or /wd4467 command line arguments to the compiler, or by adding #pragma warning(disable:4467) in your source code.

    Beispiel 1 (vorher)Example 1 (before)

                [uuid("594382D9-44B0-461A-8DE3-E06A3E73C5EB")]
      class A {};
    

    Beispiel 1 (nachher)Example 1 (after)

      __declspec(uuid("594382D9-44B0-461A-8DE3-E06A3E73C5EB")) A {};
    

    Mitunter müssen oder möchten Sie ggf. eine IDL-Datei erstellen, um die Nutzung veralteter ATL-Attribute zu vermeiden (siehe den folgenden Beispielcode).Sometimes you might need or want to create an IDL file to avoid the use deprecated ATL attributes, as in the example code below

    Beispiel 2 (vorher)Example 2 (before)

      [emitidl];
      [module(name="Foo")];
    
      [object, local, uuid("9e66a290-4365-11d2-a997-00c04fa37ddb")]
      __interface ICustom {
          HRESULT Custom([in] long l, [out, retval] long *pLong);
          [local] HRESULT CustomLocal([in] long l, [out, retval] long *pLong);
      };
    
      [coclass, appobject, uuid("9e66a294-4365-11d2-a997-00c04fa37ddb")]
      class CFoo : public ICustom
      {
          // ...
      };
    

    Erstellen Sie zunächst die *idl-Datei. Die generierte Datei vc140.idl kann zum Abrufen einer *.idl-Datei verwendet werden, die die Schnittstellen und Anmerkungen enthält.First, create the *.idl file; the vc140.idl generated file can be used to obtain an *.idl file containing the interfaces and annotations.

    Fügen Sie als Nächstes Ihrem Build einen MIDL-Schritt hinzu, um sicherzustellen, dass die C++-Schnittstellendefinitionen generiert werden.Next, add a MIDL step to your build to make sure that the C++ interface definitions are generated.

    Beispiel 2: IDL (nachher)Example 2 IDL (after)

      import "docobj.idl";
    
      [
          object,local,uuid(9e66a290-4365-11d2-a997-00c04fa37ddb)
      ]
    
      interface ICustom : IUnknown {
          HRESULT  Custom([in] long l, [out,retval] long *pLong);
          [local] HRESULT  CustomLocal([in] long l, [out,retval] long *pLong);
      };
    
      [ version(1.0), uuid(29079a2c-5f3f-3325-99a1-3ec9c40988bb) ]
      library Foo
      {
          importlib("stdole2.tlb");
          importlib("olepro32.dll");
              [
                  version(1.0),
                  appobject,uuid(9e66a294-4365-11d2-a997-00c04fa37ddb)
              ]
    
          coclass CFoo {
              interface ICustom;
          };
      }
    

    Verwenden Sie dann ATL direkt in der Implementierungsdatei (siehe den folgenden Beispielcode).Then, use ATL directly in the implementation file, as in the example code below.

    Beispiel 2: Implementierung (nachher)Example 2 Implementation (after)

      #include <idl.header.h>
      #include <atlbase.h>
    
      class ATL_NO_VTABLE CFooImpl :
          public ICustom,
          public ATL::CComObjectRootEx<CComMultiThreadModel>
      {
      public:
          BEGIN_COM_MAP(CFooImpl)
          COM_INTERFACE_ENTRY(ICustom)
          END_COM_MAP()
      };
    
  • Vorkompilierte Headerdateien (PCH) und nicht übereinstimmende #include-Anweisungen (wirkt sich nur auf /Wall /WX aus)Precompiled header (PCH) files and mismatched #include directives (only affects /Wall /WX)

    Frühere Version des Compilers haben bei Verwendung vorkompilierter Headerdateien (PCH) nicht übereinstimmende #include-Direktiven in Quelldateien zwischen -Yc- und -Yu-Kompilierungen akzeptiert.Previous versions of the compiler accepted mismatched #include directives in source files between -Yc and -Yu compilations when using precompiled header (PCH) files. Auf diese Weise geschriebener Code wird vom Compiler nicht mehr akzeptiert.Code written in this way is no longer accepted by the compiler. Der Compiler gibt nun die Compilerwarnung CC4598 aus, um bei Verwenden von PCH-Dateien nicht übereinstimmende #include-Direktiven zu bestimmen.The compiler now issues compiler warning CC4598 to help identify mismatched #include directives when using PCH files.

      warning C4598: 'b.h': included header file specified for Ycc.h at position 2 does not match Yuc.h at that position
    

    Beispiel (vorher):Example (before):

    X.cpp (-Ycc.h)X.cpp (-Ycc.h)

      #include "a.h"
      #include "b.h"
      #include "c.h"
    

    Z.cpp (-Yuc.h)Z.cpp (-Yuc.h)

      #include "b.h"
      #include "a.h"  // mismatched order relative to X.cpp
      #include "c.h"
    

    Beispiel (nachher)Example (after)

    X.cpp (-Ycc.h)X.cpp (-Ycc.h)

      #include "a.h"
      #include "b.h"
      #include "c.h"
    

    Z.cpp (-Yuc.h)Z.cpp (-Yuc.h)

      #include "a.h"
      #include "b.h" // matched order relative to X.cpp
      #include "c.h"
    
  • Vorkompilierte Headerdateien (PCH) und nicht übereinstimmende include-Anweisungen (wirkt sich nur auf /Wall /WX aus)Precompiled header (PCH) files and mismatched include directories (only affects /Wall /WX)

    Frühere Version des Compilers haben bei Verwendung vorkompilierter Headerdateien (PCH) nicht übereinstimmende Befehlszeilenargumente des Typs „include-Verzeichnis“ (-I) für den Compiler zwischen -Yc- und -Yu-Kompilierungen akzeptiert.Previous versions of the compiler accepted mismatched include directory (-I) command line arguments to the compiler between -Yc and -Yu compilations when using precompiled header (PCH) files. Auf diese Weise geschriebener Code wird vom Compiler nicht mehr akzeptiert.Code written in this way is no longer accepted by the compiler. Der Compiler gibt nun die Compilerwarnung CC4599 aus, um bei Verwenden von PCH-Dateien nicht übereinstimmende Befehlszeilenargumente des Typs „include-Verzeichnis“ (-I) zu bestimmen.The compiler now issues compiler warning CC4599 to help identify mismatched include directory (-I) command line arguments when using PCH files.

      warning C4599: '-I..' : specified for Ycc.h at position 1 does not match Yuc.h at that position
    

    Beispiel (vorher)Example (before)

      cl /c /Wall /Ycc.h -I.. X.cpp
      cl /c /Wall /Yuc.h Z.cpp
    

    Beispiel (nachher)Example (after)

      cl /c /Wall /Ycc.h -I.. X.cpp
      cl /c /Wall /Yuc.h -I.. Z.cpp
    

Neuerungen bei C++ in Visual Studio 2013What's New for C++ in Visual Studio 2013

Verbesserte Unterstützung der ISO-C/C++-StandardsImproved ISO C/C++ Standards Support

CompilerCompiler

Microsoft Visual C++ unterstützt diese ISO C++11-Sprachfeatures:MSVC supports these ISO C++11 language features:

  • Standardvorlagenargumente für Funktionsvorlagen.Default template arguments for function templates.
  • Delegierende KonstruktorenDelegating constructors
  • Explizite Konvertierungsoperatoren.Explicit conversion operators.
  • Initialisierungslisten und einheitliche Initialisierung.Initializer lists and uniform initialization.
  • Unformatierten Zeichenfolgenliterale.Raw string literals.
  • Variadic-Vorlagen.Variadic templates.
  • AliasvorlagenAlias templates.
  • Gelöschte FunktionenDeleted functions.
  • Nicht statische Datenmemberinitialisierer (NSDMIs)Non-static data member initializers (NSDMIs).
  • StandardfunktionenDefaulted functions. **
  • Unterstützte ISO C99-Sprachfunktionen:Supports these ISO C99 language features:
  • _Bool_Bool
  • VerbundliteraleCompound literals.
  • Festgelegte InitialisiererDesignated initializers.
  • Mischen von Deklarationen mit CodeMixing declarations with code.
  • Zeichenfolgenliteralkonvertierung an änderbaren Werten kann durch Verwendung der neuen Compileroption /Zc:strictStrings als unzulässig bezeichnet werden.String literal conversion to modifiable values can be disallowed by using the new compiler option /Zc:strictStrings. In c++ 98 ist die Konvertierung von Zeichenfolgenliteralen in char* (und Breite Zeichen folgen Literale in wchar_t* ) veraltet.In C++98, conversion from string literals to char* (and wide string literals to wchar_t*) was deprecated. In C++11 wurde die Konvertierung vollständig entfernt.In C++11, the conversion was removed entirely. Obwohl der Compiler dem Standard strikt entsprechen könnte, wird stattdessen die Option /Zc:strictStrings bereitgestellt, mit der die Konvertierung gesteuert werden kann.Although the compiler could strictly conform to the standard, instead it provides the /Zc:strictStrings option so that you can control conversion. Standardmäßig ist die Option deaktiviert.By default, the option is off. Beachten Sie, dass bei Verwendung dieser Option im Debugmodus STL nicht kompiliert.Note that when you are using this option in debug mode, the STL will not compile.
  • rvalue/lvalue-Verweisumwandlungen.rvalue/lvalue Reference Casts. Mit rvalu-Verweisen kann C++11 eindeutig zwischen lvalues und rvalues unterscheiden.With rvalue references, C++11 can clearly distinguish between lvalues and rvalues. Zuvor war das mit dem Compiler in bestimmten Umwandlungsszenarios nicht möglich.Previously, the compiler did not provide this in specific casting scenarios. Die neue Compileroption /Zc:rvalueCast wurde hinzugefügt, damit der Compiler mit dem C++ Language Working Paper (siehe Abschnitt 5.4, [expr.cast]/1) kompatibel ist.A new compiler option, /Zc:rvalueCast, has been added to make the compiler conformant with the C++ Language Working Paper(see section 5.4, [expr.cast]/1). Wenn diese Option nicht angegeben wird, entspricht das Standardverhalten dem von Visual Studio 2012.The default behavior when this option is not specified is the same as in Visual Studio 2012.

Hinweis

Für Standardwertfunktionen wird die Verwendung von „=default“ nicht unterstützt, um memberspezifische Bewegungskonstruktoren und Bewegungszuweisungsoperatoren anzufordern.For defaulted functions, using =default to request memberwise move constructors and move assignment operators is not supported.

C99-BibliothekenC99 Libraries

Deklarationen und Implementierungen werden für fehlende Funktionen zu den folgenden Headern hinzugefügt: „math.h“, „ctype.h“, „wctype.h“, „stdio.h“, „stdlib.h“ und „wchar.h“.Declarations and implementations are added for missing functions in these headers: math.h, ctype.h, wctype.h, stdio.h, stdlib.h, and wchar.h. Außerdem wurden die neuen Header „complex.h“, „stdbool.h“, „fenv.h“ und „inttypes.h“ sowie Implementierungen für alle Funktionen hinzugefügt, die darin deklariert werden.Also added are the new headers complex.h, stdbool.h, fenv.h, and inttypes.h, and implementations for all the functions declared in them. Es gibt neue Wrapperheader für C++ („ccomplex“, „cfenv“, „cinttypes“, „ctgmath“) und eine Reihe von weiteren aktualisierten Headern („ccomplex“, „cctype“, „clocale“, „cmath“, „cstdint“, „cstdio“, „cstring“, „cwchar“ und „cwctype“).There are new C++ wrapper headers (ccomplex, cfenv, cinttypes, ctgmath) and a number of others are updated (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar, and cwctype).

Standard Template LibraryStandard Template Library

Unterstützung für explizite Konvertierungsoperatoren, Initialisierungslisten, bewertete Enumerationen und variadic Vorlagen von C++11.Support for the C++11 explicit conversion operators, initializer lists, scoped enums, and variadic templates. Alle Container unterstützen jetzt die differenzierten C++11-Elementanforderungen.All containers now support the C++11 fine-grained element requirements. Unterstützung für diese C++14-Funktionen:Support for these C++14 features:

  • Die transparenten Operatorfunktionselemente less<>, greater<>, plus<>, multiplies<> usw."Transparent operator functors" less<>, greater<>, plus<>, multiplies<>, and so on.
  • make_unique<T>(Args) und make_unique<T[]>(n)make_unique<T>(args...) and make_unique<T[]>(n)
  • Die Nicht-Memberfunktionen cbegin()/cend(), rbegin()/rend() und crbegin()/crend().cbegin()/cend(), rbegin()/rend(), and crbegin()/crend() non-member functions.
  • <atomic> Es wurden zahlreiche Leistungsverbesserungen erhalten.<atomic> received numerous performance enhancements.
  • <type_traits> Es wurden wichtige Stabilisierungs-und Code Fehlerbehebungen erhalten.<type_traits> received major stabilization and code fixes.

Aktuelle ÄnderungenBreaking Changes

Diese verbesserte Unterstützung für ISO-C/C++-Standards erfordert möglicherweise Änderungen am vorhandenen Code, sodass er C++11 entspricht und ordnungsgemäß in Visual C++ in Visual Studio 2013 kompiliert wird.This improved support for ISO C/C++ standards may require changes to existing code so that it conforms to C++11 and compiles correctly in Visual C++ in Visual Studio 2013.

Verbesserungen bei Visual C++-BibliothekenVisual C++ Library Enhancements

  • C++-REST SDK wird hinzugefügt.C++ REST SDK is added. Es verfügt über eine moderne C++-Implementierung von REST-Diensten.It has a modern C++ implementation of REST services.
  • Die C++-AMP-Texturunterstützung wurde verbessert.C++ AMP Texture support is enhanced. Sie umfasst jetzt Unterstützung für Mipmaps und neue Samplingsmodi.It now includes support for mipmaps and new sampling modes.
  • PPL-Aufgaben unterstützen mehrere Planungstechnologien und asynchrones Debuggen.PPL tasks support multiple scheduling technologies and asynchronous debugging. Neue APIs ermöglichen die Erstellung von PPL-Aufgaben für Normalbefunde und Ausnahmebedingungen.New APIs enable the creation of PPL tasks for both normal results and exception conditions.

C++-AnwendungsleistungC++ Application Performance

  • Automatische Vektorisierung erkennt und optimiert jetzt mehrere C++-Muster, damit der Code schneller ausgeführt wird.Auto-Vectorizer now recognizes and optimizes more C++ patterns to make your code run faster.
  • Verbesserungen bei der Codequalität der ARM-Plattform- und Atom-Mikroarchitektur.ARM platform and Atom micro-architecture code quality improvements.
  • Die __vectorcall-Aufrufkonvention wurde hinzugefügt.__vectorcall calling convention is added. Übergeben Sie Vektortypargumente mithilfe der __vectorcall-Aufrufkonvention, um Vektorregister zu verwenden.Pass vector type arguments by using the __vectorcall calling convention to use vector registers.
  • Neue Linkeroptionen.New Linker Options. Die Schalter /Gw (Compiler) und /Gy (Assembler) aktivieren Linkeroptimierungen, um schlankere Binärdateien zu erzeugen.The /Gw (compiler) and /Gy (assembler) switches enable linker optimizations to produce leaner binaries.
  • C++ AMP hat Arbeitsspeicherunterstützung freigegeben, um das Kopieren von Daten zwischen CPU und GPU zu reduzieren oder auszuschließen.C++ AMP shared memory support to reduce or eliminate data copying between CPU and GPU.

Verbesserungen der profilgesteuerten Optimierung (PGO)Profile Guided Optimization (PGO) enhancements

  • Leistungsverbesserungen durch eine Reduzierung der Arbeitsseiten von Apps, die durch die Verwendung von PGO optimiert werden.Performance improvements from a reduction in the working set of apps that are optimized by using PGO.
  • Neue profilgesteuerte Optimierung für die Entwicklung von Windows-Runtime-Apps.New PGO for Windows Runtime app development.

Unterstützung für die Entwicklung von Windows-Runtime-AppsWindows Runtime App Development Support

  • Unterstützung für Wertstrukturtypen, für die ein Boxing durchgeführt wurdeSupport For Boxed Types In Value structs.

    Sie können jetzt Werttypen definieren, indem Sie Felder verwenden, die NULL sein können – z IBox<int>^ . b. im Gegensatz zu int .You can now define value types by using fields that can be null—for example, IBox<int>^ as opposed to int. Dies bedeutet, dass die Felder entweder einen Wert haben können oder gleich sind nullptr .This means that the fields can either have a value, or be equal to nullptr.

  • Umfangreichere AusnahmeinformationenRicher Exception Information.

    C++/CX unterstützt das neue Windows-Fehlermodell, das die Erfassung und die Weitergabe von umfangreichen Ausnahmeinformationen über der Anwendungsbinärdateischnittstelle (ABI) aktiviert. Dies schließt auch Aufruflisten und benutzerdefinierte Meldungs- ein.C++/CX supports the new Windows error model that enables the capture and propagation of rich exception information across the application binary interface (ABI); this includes call stacks and custom message strings.

  • Object::ToString() ist jetzt virtuellObject::ToString() Is Now Virtual.

    Sie können „ToString“ in benutzerdefinierten Windows-Runtime-Referenztypen überschreiben.You can now override ToString in user-defined Windows Runtime ref types.

  • Unterstützung für veraltete APIsSupport For Deprecated APIs.

    Öffentliche Windows-Runtime-APIs können jetzt als veraltet markiert und ihnen kann eine benutzerdefinierte Meldung zugewiesen werden, die als Buildwarnung angezeigt werden und Migrationsanleitungen bereitstellen kann.Public Windows Runtime APIs can now be marked as deprecated and given a custom message that appears as a build warning and can provide migration guidance.

  • Debugger-Verbesserungen.Debugger Improvements.

    Unterstützung für systemeigenes/JavaScript-Interop-Debuggen, Windows Runtime-Ausnahmediagnose und asynchrones Debuggen von Code (Windows Runtime und PPL).Support for native/JavaScript interop debugging, Windows Runtime exception diagnosis, and async code debugging (both Windows Runtime and PPL).

Hinweis

Zusätzlich zu den C++-spezifischen Features und Erweiterungen, die in diesem Abschnitt beschrieben werden, können Sie mithilfe anderer Erweiterungen in Visual Studio bessere Apps für Windows-Runtime schreiben.In addition to the C++-specific features and enhancements that are described in this section, other enhancements in Visual Studio also can help you write better Windows Runtime apps.

Verbesserungen bei DiagnosenDiagnostics Enhancements

  • Debugger-Verbesserungen.Debugger Improvements. Unterstützung für asynchrones Debuggen und „Nur mein Code“-Debuggen.Support for async debugging and Just My Code debugging.
  • Kategorien für die Codeanalyse.Code Analysis Categories. Sie können nun die kategorisierte Ausgabe des Code-Analyzer anzeigen, anhand derer Sie Codefehler finden und beheben können.You can now view categorized output from the Code Analyzer to help you find and fix code defects.
  • XAML-Diagnose.XAML Diagnostics. Sie können nun die UI-Reaktionsfähigkeit sowie Akkuverwendungsprobleme im XAML-Code diagnostizieren.You can now diagnose UI-responsiveness and battery-usage issues in your XAML.
  • Verbesserungen beim Grafik- und GPU-Debugging.Graphics and GPU Debugging Improvements.
  • Remote-Erfassung und -Wiedergabe auf realen Geräten.Remote capture and playback on real devices.
  • Simultanes C++-AMP- und -CPU-Debugging.Simultaneous C++ AMP and CPU debugging.
  • Verbesserte C++-AMP-Laufzeitdiagnose.Improved C++ AMP runtime diagnostics.
  • HLSL-Compute-Shader-Ablaufverfolgungsdebugging.HLSL Compute shader trace debugging.

Verbesserungen bei der 3D-Grafik3-D Graphics Enhancements

  • Unterstützung der Pipeline für Bildinhalte für vorab multipliziertes Alpha-DDS-Format.Image Content Pipeline support for pre-multiplied alpha DDS format.
  • Die Bildbearbeitung verwendet intern vorab multipliziertes Alpha zum Rendern und vermeidet somit das Rendern von Artefakten wie dunklen Halos.Image Editor uses internally pre-multiplied alpha for rendering, and thereby avoids rendering artifacts such as dark halos.
  • Bild- und Modell-Editors.Image and Model Editors. Benutzerdefinierte Filtererstellung wird jetzt im Shader-Designer im Bild- und im Modell-Editor unterstützt.User-defined filter creation is now supported in Shader Designer in Image Editor and Model Editor.

IDE und ProduktivitätIDE and Productivity

Verbesserte Codeformatierung.Improved Code Formatting. Sie können mehr Formatierungseinstellungen auf den C++-Code anwenden.You can apply more formatting settings to your C++ code. Wenn Sie diese Einstellungen verwenden, können Sie die Platzierung neuer Zeilen von geschweiften Klammern und Schlüsselwörtern, Einzügen, Abständen und Zeilenumbrüchen steuern.By using these settings, you can control new-line placement of braces and keywords, indentation, spacing, and line wrapping. Code wird automatisch formatiert, wenn Sie Anweisungen und Blöcke abschließen und wenn Sie Code in eine Datei einfügen.Code is automatically formatted when you complete statements and blocks, and when you paste code into a file.

Klammerabschluss.Brace Completion. C++-Code vervollständigt die Schlusszeichen, die diesen Öffnungszeichen entsprechen, jetzt automatisch:C++ code now auto-completes the closing characters that correspond to these opening characters:

  • { (geschweifte Klammer){ (curly brace)
  • [ (eckige Klammer)[ (square bracket)
  • ( (runde Klammer)( (parentheses)
  • ' (Einfaches Anführungszeichen)' (single quote)
  • " (doppeltes Anführungszeichen)" (double quote)

Zusätzliche C++-Features für die automatische VervollständigungAdditional C++ Auto-completion Features.

  • Fügt Semikolon für Klassentypen hinzu.Adds semicolon for class types.
  • Vervollständigt Klammern für unformatierte Zeichenfolgenliterale.Completes parentheses for raw string literals.
  • Vervollständigt Mehrzeilige Kommentare (/ * * /)Completes multi-line comments (/* */)

Alle Verweise suchen löst jetzt Verweise auf und filtert sie im Hintergrund, nachdem die Liste der Textabgleichungen angezeigt wurde.Find All References now automatically resolves and filters references in the background after it displays the list of textual matches.

Kontextbasierte Memberlistenfilterung.Context-Based Member List Filtering. Member, auf die nicht zugegriffen werden kann, werden aus den IntelliSense-Memberlisten herausgefiltert.Inaccessible members are filtered out of the IntelliSense member lists. Beispielsweise werden private Member nicht in der Memberliste angezeigt, es sei denn, Sie ändern den Code, der den Typ implementiert.For example, private members are not displayed in the member list unless you are modifying the code that implements the type. Wenn die Mitgliederliste geöffnet ist, können Sie STRG + J drücken, um eine Ebene der Filterung zu entfernen (gilt nur für das Fenster aktuelle Elementliste).While the member list is open, you can press Ctrl+J to remove one level of filtering (applies only to the current member list window). Sie können erneut STRG + J drücken, um die Text Filterung zu entfernen und alle Member anzuzeigen.You can press Ctrl+J again to remove the textual filtering and show every member.

Scrollfeature für Parameterhilfe.Parameter Help Scrolling. Die angezeigte Funktionssignatur in der QuickInfo der Parameter Hilfe ändert sich jetzt je nach Anzahl der Parameter, die Sie wirklich eingegeben haben, anstatt nur eine beliebige Signatur anzuzeigen, die nicht auf Grundlage des aktuellen Kontextes aktualisiert wird.The displayed function signature in the parameter-help tooltip now changes based on the number of parameters you've actually typed, rather than just showing an arbitrary signature and not updating it based on the current context. Parameterhilfe funktioniert auch ordnungsgemäß, wenn sie in geschachtelten Funktionen angezeigt wird.Parameter help also functions correctly when it's displayed on nested functions.

Header-/Codedatei umschalten.Toggle Header/Code File. Sie können nun zwischen einem Header und der zugehörigen Codedatei umschalten, indem Sie einen Befehl im Kontextmenü oder eine Tastenkombination verwenden.You can now toggle between a header and its corresponding code file by using a command on the shortcut menu, or a keyboard shortcut.

In der Größe veränderbares C++-ProjekteigenschaftenfensterResizable C++ Project Properties Window

Automatisches Generieren des Ereignishandlercodes in C++/CX und C++/CLI.Auto-generation of Event Handler Code in C++/CX and C++/CLI. Wenn Sie Code eingeben, um einen Ereignishandler in einer C++/CX- oder C++/CLI-Codedatei hinzuzufügen, kann der Editor die Delegatinstanz und die Ereignishandlerdefinition automatisch generieren.When you are typing code to add an event handler in a C++/CX or C++/CLI code file, the editor can automatically generate the delegate instance and event-handler definition. Ein QuickInfo-Fenster wird angezeigt, wenn Ereignishandlercode automatisch generiert werden kann.A tooltip window appears when event-handler code can be auto-generated.

Verbesserung der DPI-Berücksichtigung.DPI Awareness Enhancement. Die DPI-Einstellung für Anwendungsmanifestdateien unterstützt jetzt die Einstellung "Hohe DPI-Werte pro Monitor".The DPI Awareness setting for application manifest files now supports the "Per Monitor High DPI Aware" setting.

Schnellere Konfigurationsumschaltung.Faster Configuration Switching. Für große Anwendungen werden Konfigurationen, insbesondere nachfolgende Umschaltvorgänge, viel schneller ausgeführt.For large applications, switching configurations—especially subsequent switching operations—execute much more quickly.

Effizienz der Buildzeit.Build Time Efficiency. Zahlreiche Optimierungen und Multikernauslastung machen Builds schneller, insbesondere für umfangreiche Projekte.Numerous optimizations and multi-core utilization make builds faster, especially for large projects. Inkrementelle Builds für C++-Anwendungen, die Verweise auf C++ WinMD aufweisen, sind ebenfalls viel schneller.Incremental builds for C++ applications that have references to C++ WinMD are also much faster.

Neuerungen bei C++ in Visual Studio 2012What's New for C++ in Visual Studio 2012

Verbesserte Unterstützung von C++11-StandardsImproved C++11 Standards Support

Standard Template LibraryStandard Template Library

  • Unterstützung für neue STL-Header: <atomic> , <chrono> , <condition_variable> , <filesystem> , <future> , <mutex> , <ratio> und <thread> .Support for new STL headers: <atomic>, <chrono>, <condition_variable>, <filesystem>, <future>, <mutex>, <ratio>, and <thread>.
  • Container sind jetzt kleiner, damit die Speicherauslastung durch die Ressourcen optimiert wird.To optimize memory resource usage, containers are now smaller. Beispielsweise wurde std::vector im Releasemodus x86 mit Standardeinstellungen von 16 Bytes in Visual Studio 2010 auf 12 Bytes in Visual Studio 2012 reduziert, und std::mapwurde von 16 Bytes in Visual Studio 2010 auf 8 Bytes in Visual Studio 2012 reduziert.For example, in x86 release mode with default settings, std::vector has shrunk from 16 bytes in Visual Studio 2010 to 12 bytes in Visual Studio 2012, and std::map has shrunk from 16 bytes in Visual Studio 2010 to 8 bytes in Visual Studio 2012.
  • SCARY-Iteratoren wurden implementiert. Dies wird in C++11-Standard zugelassen, ist aber nicht erforderlich.As permitted but not required by the C++11 Standard, SCARY iterators have been implemented.

Weitere Erweiterungen für C++11Other C++11 Enhancements

  • Bereichsbasierte For-Schleifen.Range-based for loops. Sie können jetzt stabile Schleifen schreiben, die mit Arrays, STL-Containern und Windows-Runtime-Auflistungen in For-Form zusammenarbeiten (for-range-declaration : expression).You can write more robust loops that work with arrays, STL containers, and Windows Runtime collections in the form for ( for-range-declaration : expression ). Dies ist ein Bestandteil der Kernsprachunterstützung.This is part of the Core Language support.

  • Zustandslose Lambdas (Codeblöcke, die mit der leeren Lambdaeinführung [] beginnen und keine lokalen Variablen erfassen) können jetzt implizit in Funktionszeiger konvertiert werden, wie für C++ 11-Standard erforderlich.Stateless lambdas, which are blocks of code that begin with an empty lambda introducer [] and capture no local variables, are now implicitly convertible to function pointers as required by the C++11 Standard.

  • Unterstützung für bereichsbezogene Enumerationen.Scoped enumerations support. Der Enumerationsschlüssel der C++-Enumerationsklasse wird jetzt unterstützt.The C++ enum class enum-key is now supported. Folgender Code stellt dar, wie dieser Enumerationsschlüssel vom vorherigen Enumerationsverhalten abweicht.The following code demonstrates how this enum-key differs from previous enum behavior.

    enum class Element { Hydrogen, Helium, Lithium, Beryllium };
    void func1(Element e);
    func1(Hydrogen); // error C2065: 'Hydrogen' : undeclared identifier
    func1(Element::Helium); // OK
    

Unterstützung für die Entwicklung von Windows-Runtime-AppsWindows Runtime App Development Support

  • Natives XAML-basiertes Benutzeroberflächenmodell.Native XAML-based UI model. Sie können jetzt für Windows Runtime-Apps das neue native XAML-basierte Benutzeroberflächenmodell verwenden.For Windows Runtime apps, you can use the new native XAML-based UI model.
  • Visual C++ Komponenten Erweiterungen.Visual C++ Component Extensions. Diese Erweiterungen vereinfachen die Verarbeitung von Windows-Runtime-Objekten, die ein wichtiger Bestandteil von Windows Runtime-Apps sind.These extensions simplify consumption of Windows Runtime objects, which are a necessary part of Windows Runtime apps. Weitere Informationen finden Sie unter Roadmap for Windows Runtime apps using C++ (Übersicht zur Verwendung von C++ für Windows-Runtime-Apps) und in der Sprachreferenz zu Visual C++ (C++/CX).For more information, see Roadmap for Windows Runtime apps using C++ and Visual C++ language reference (C++/CX)
  • DirectX-Spiele.DirectX games. Sie können spannende Spiele entwickeln, indem Sie die neue DirectX-Unterstützung für Windows-Runtime-Apps verwenden.You can develop engaging games by using the new DirectX support for Windows Runtime apps.
  • XAML/DirectX-Interop.XAML/DirectX interop. Windows-Runtime-Apps, die XAML und DirectX verwenden, arbeiten jetzt auf effiziente Weise zusammen.Windows Runtime apps that use both XAML and DirectX now interoperate efficiently.
  • Komponente für die Windows-Runtime für die DLL-Entwicklung.Windows Runtime Component DLL development. Durch die Komponente für die DLL-Entwicklung wird die Windows-Runtime-Umgebung erweiterbar.Component DLL development makes the Windows Runtime environment extensible.

Compiler und LinkerCompiler and Linker

  • Automatische Vektorisierung.Auto-vectorizer. Der Compiler analysiert Schleifen in Ihrem Code und gibt wenn möglich Anweisungen aus, die die Vektorregister und-anweisungen verwendet, die in allen modernen Prozessoren vorhanden sind.The compiler analyzes loops in your code and, where possible, emits instructions that use the vector registers and instructions that are present in all modern processors. Dadurch werden die Schleifen schneller ausgeführt.This makes the loops run faster. (Die Anweisungen des Prozessors werden als Streaming SIMD Extensions (SSE) bezeichnet.)(The processor instructions are known as SSE, for Streaming SIMD Extensions). Sie müssen diese Optimierung nicht aktivieren oder anfordern, da sie automatisch angewendet wird.You do not have to enable or request this optimization because it is applied automatically.
  • Automatische Parallelisierung.Auto-parallelizer. Der Compiler kann Schleifen in Ihrem Code analysieren und Anweisungen ausgeben, die die Berechnungen auf mehrere Kerne und Prozessoren ausweiten.The compiler can analyze loops in your code and emit instructions that spread the calculations across multiple cores or processors. Dadurch können die Schleifen schneller ausgeführt werden.This can make the loops run faster. Sie müssen diese Optimierung anfordern, da sie nicht standardmäßig aktiviert ist.You must request this optimization because it is not enabled by default. Häufig ist es hilfreich, #pragma loop(hint_parallel(N)) vor den Schleifen in Ihren Code einzufügen, die parallel verlaufen sollen.In many cases, it helps to include a #pragma loop(hint_parallel(N)) in your code immediately before the loops that you want parallelized.
  • Die automatische Vektorisierung und die automatische Parallelisierung können zusammenarbeiten, sodass Berechnungen auf mehrere Kerne ausgeweitet werden können und der Code auf jedem Kern seine jeweiligen Vektorregister verwendet.The auto-vectorizer and auto-parallelizer can work together so that calculations are spread across multiple cores and the code on each core uses its vector registers.

Neuerungen in Visual Studio 2012 Update 1New in Visual Studio 2012 Update 1

Verwenden Sie Windows XP als Ziel, wenn Sie C++-Code erstellen.Target Windows XP when you build your C++ code. Sie können den Microsoft Visual C++-Compiler und die Microsoft Visual C++-Bibliotheken verwenden, um Windows XP und Windows Server 2003 als Ziel zu verwenden.You can use the Microsoft C++ compiler and libraries to target Windows XP and Windows Server 2003.

Unterstützung der parallelen ProgrammierungParallel Programming Support

C++ Accelerated Massive Parallelism (AMP)C++ Accelerated Massive Parallelism (AMP)

C++ AMP beschleunigt die Ausführung von C++-Code, indem die Vorteile datenparalleler Hardware genutzt werden, beispielsweise ein Grafikprozessor (Graphics Processing Unit, GPU) auf einer separaten Grafikkarte.C++ AMP accelerates the execution of your C++ code by taking advantage of the data-parallel hardware that's ordinarily present as a GPU on a discrete graphics card. Das C++ AMP-Programmiermodell umfasst mehrdimensionale Arrays, Indizierung, Arbeitsspeicherübertragung, Kacheln und eine Bibliothek mathematischer Funktionen.The C++ AMP programming model includes multidimensional arrays, indexing, memory transfer, tiling, and a mathematical function library. Mithilfe von C++ AMP-Spracherweiterungen und Compilerbeschränkungen können Sie steuern, wie Daten von der CPU auf die GPU bzw. wieder zurück verschoben werden.By using C++ AMP language extensions and compiler restrictions, you can control how data is moved from the CPU to the GPU and back.

Suche.Debugging. Das Debuggen von Apps, die C++ AMP verwenden, um die GPU als Ziel zu verwenden, entspricht dem Debugvorgang für andere C++-Apps.The debugging experience for apps that use C++ AMP to target the GPU is just like debugging for other C++ apps. Dies umfasst die neuen Funktionen zum parallelen Debuggen, die zuvor genannt wurden.This includes the new parallel debugging additions that were mentioned earlier.

Liert.Profiling. Die Profilerstellungen für GPI-Aktivitäten, die auf C++ AMP und anderen Direct3D-basierten Programmierungsmodellen aufbauen, wird jetzt unterstützt.There is now profiling support for GPU activity that's based on C++ AMP and other Direct3D-based programming models.

Allgemeine Verbesserungen des parallelen ProgrammierensGeneral Parallel Programming Enhancements

Entwickler können sich nicht mehr darauf verlassen, dass die Taktfrequenzen einzelner Kerne immer weiter erhöht werden, denn die Hardware wird derzeit eher auf die Arbeit mit mehreren Kernen und Architekturen ausgerichtet.With hardware moving to multi-core and many-core architectures, developers can no longer rely on ever-increasing clock speeds from single-cores. Mithilfe der Unterstützung der parallelen Programmierung in Concurrency Time können Entwickler diese neuen Architekturen nutzen.The parallel programming support in the Concurrency Runtime enables developers to take advantage of these new architectures. In Visual Studio 2010 wurden neben Funktionen, die die Parallelität nutzen, indem sie optimierte Datenflusspipelines erstellen, auch leistungsstarke C++-Parallelisierungen wie die Parallel Patterns Library eingeführt.In Visual Studio 2010, powerful C++ parallelization libraries such as the Parallel Patterns Library were introduced, together with features to take advantage of concurrency by expressing sophisticated dataflow pipelines. In Visual Studio 2012 wurden diese Bibliotheken erweitert, um die Leistung zu verbessern, die Kontrolle zu erhöhen und eine bessere Unterstützung für die wichtigsten Parallelmuster für die Entwickler bereitzustellen.In Visual Studio 2012, these libraries have been extended to provide better performance, more control, and richer support for the parallel patterns that developers need most. Folgendes ist jetzt in dem Angebot enthalten:The breadth of the offering now includes:

  • Ein umfassendes aufgabenbasiertes Programmierungsmodell, das Asynchronität und Fortsetzungen unterstützt.A rich task-based programming model that supports asynchrony and continuations.
  • Parallele Algorithmen, die fork/join-Parallelität unterstützen („parallel_for“, „parallel_for“ mit Affinität, „parallel_for_each“, „parallel_sort“, „parallel_reduce“, „parallel_transform“).Parallel Algorithms, which support fork-join parallelism (parallel_for, parallel_for with affinity, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
  • Parallelitätssichere Container, die threadsichere Versionen von std-Datenstrukturen wie „priority_queue“, „queue“, „vector“ und „map“ bereitstellen.Concurrency-safe containers, which provide thread-safe versions of std data structures such as priority_queue, queue, vector, and map.
  • Die Bibliothek des asynchronen Agents, die Entwickler nutzen können, um Datenflusspipelines zu erstellen, die automatisch in parallele Einheiten zerlegt werden.The Asynchronous Agents Library, which developers can use to express dataflow pipelines that naturally decompose into concurrent units.
  • Ein anpassbarer Scheduler und Ressourcen-Manager zur Vereinfachung der problemlosen Zusammensetzung der Muster in dieser Liste.A customizable scheduler and resource manager to facilitate the smooth composition of the patterns in this list.
Allgemeine Verbesserungen des parallelen DebuggensGeneral Parallel Debugging Enhancements

Zusätzlich zum Fenster parallele Aufgaben und parallele Stapel bietet Visual Studio 2012 ein neues Fenster für parallele Überwachung , sodass Sie die Werte eines Ausdrucks für alle Threads und Prozesse überprüfen und das Sortieren und Filtern für das Ergebnis durchführen können.In addition to the Parallel Tasks window and Parallel Stacks window, Visual Studio 2012 offers a new Parallel Watch window so that you can examine the values of an expression across all threads and processes, and perform sorting and filtering on the result. Sie können jetzt außerdem Ihre eigenen visuellen Elemente verwenden, um das Fenster zu erweitern und die Vorteile der neuen Unterstützung von mehreren Prozessen toolfensterübergreifend nutzen.You can also use your own visualizers to extend the window, and you can take advantage of the new multi-process support across all tool windows.

IDEIDE

Unterstützung von Visual Studio-Vorlagen.Visual Studio Templates support. Sie können jetzt die Technologie der Visual Studio-Vorlagen verwenden, um C++-Projekte und Elementvorlagen zu erstellen.You can now use the Visual Studio Templates technology to author C++ project and item templates.

Asynchrones Laden von Projektmappen.Asynchronous Solution Load. Projekte werden jetzt auf asynchrone Weise geladen, d.h. die wichtigsten Bestandteile der Projektmappe zuerst, sodass Sie schneller mit der Arbeit beginnen können.Projects are now loaded asynchronously—the key parts of the solution first—so that you can start working faster.

Automatisierte Bereitstellung für das Remotedebuggen.Automated deployment for remote debugging. Die Bereitstellung von Dateien für das Remotedebuggen in Visual C++ wurde vereinfacht.Deployment of files for remote debugging in Visual C++ has been simplified. Die Option Bereitstellen im Kontextmenü des Projekts kopiert die Dateien, die in den Eigenschaften für die Debugkonfiguration angegeben sind, automatisch auf den Remotecomputer.The Deploy option on the project context menu automatically copies to the remote computer the files that are specified in the debugging configuration properties. Es ist nicht mehr erforderlich, die Dateien manuell auf den Remotecomputer zu kopieren.Copying files manually to the remote computer is no longer required.

IntelliSense für C++/CLI.C++/CLI IntelliSense. IntelliSense wird für C++/CLI nun vollständig unterstützt.C++/CLI now has full IntelliSense support. IntelliSense-Features wie QuickInfo, die Parameterhilfe, Listenmembers und die automatische Vervollständigung funktionieren jetzt für C++/CLI.IntelliSense features such as Quick Info, Parameter Help, List Members, and Auto Completion now work for C++/CLI. Zudem funktionieren die anderen in diesem Dokument aufgeführten IntelliSense- und IDE-Erweiterungen ebenfalls für C++/CLI.In addition, the other IntelliSense and IDE enhancements listed in this document also work for C++/CLI.

Umfangreichere IntelliSense-QuickInfos.Richer IntelliSense Tooltips. Die IntelliSense-QuickInfo für C++ zeigt jetzt XML-Dokumentationskommentare mit Informationen zum Stil an.C++ IntelliSense Quick Info tooltips now show richer XML documentation comments style information. Wenn Sie eine API für eine Bibliothek verwenden, die über XML-Dokumentationskommentare verfügt, z.B. C++ AMP, zeigt die InteliSense-QuickInfo neben der Deklaration auch weitere Informationen an.If you are using an API from a library—for example, C++ AMP—that has XML documentation comments, then the IntelliSense tooltip shows more information than just the declaration. Wenn Ihr Code außerdem XML-Dokumentationskommentare enthält, zeigt die IntelliSense-QuickInfo umfangreichere Informationen an.Also, if your code has the XML documentation comments, IntelliSense tooltips will show the richer information.

C++-Codekonstrukte.C++ Code Constructs. Für Codekonstrukte wie u.a. „switch“, „if-else“ oder „for loop“ ist Skelettcode in der Dropdownliste der Listenmembers verfügbar.Skeleton code is available for switch, if-else, for loop, and other basic code constructs, in the List Members drop-down list. Wählen Sie aus der Liste ein Codefragment aus, das Sie in Ihren Code einfügen, und fügen Sie dann die erforderliche Logik ein.Select a piece of code from the list to insert it into your code and then fill in the required logic. Sie können auch Ihre eigenen Codefragmente erstellen, um sie im Editor zu verwenden.You can also create your own custom pieces of code for use in the editor.

Verbesserungen bei „Member auflisten“.List Members Enhancements. Die Dropdownliste mit den Listenmembers wird automatisch angezeigt, wenn Sie Code in den Code-Editor eingeben.The List Members drop-down list appears automatically as you type code into the code editor. Ergebnisse werden gefiltert, sodass beim Tippen nur relevante Members angezeigt werden.Results are filtered, so that only relevant members are displayed as you type. Sie können im Dialogfeld Optionen unter Text-Editor > C/C++ > Erweitert steuern, welche Filterlogik von der Memberliste verwendet werden soll.You can control the kind of filtering logic that's used by the Member List—in the Options dialog box under Text Editor > C/C++ > Advanced.

Semantische Farbgebung.Semantic Colorization. Für Typen, Aufzählungen, Makros sowie andere C++-Tokens ist jetzt standardmäßig die Farbgebung aktiviert.Types, enumerations, macros, and other C++ tokens now have colorization by default.

Verweismarkierung.Reference Highlighting. Wenn Sie ein Symbol auswählen, werden jetzt alle Instanzen des Symbols in der aktuellen Datei angezeigt.Selecting a symbol now highlights all instances of the symbol in the current file. Drücken Sie STRG + UMSCHALTTaste + nachoben oder STRG + UMSCHALTnach + unten , um zwischen den hervorgehobenen verweisen zu wechseln.Press Ctrl+Shift+Up Arrow or Ctrl+Shift+Down Arrow to move among the highlighted references. Sie können diese Funktion im Dialogfeld Optionen unter Text-Editor > C/C++ > Erweitert deaktivieren.You can turn this feature off in the Options dialog box, under Text Editor > C/C++ > Advanced.

Anwendungslebenszyklus-VerwaltungstoolsApplication Lifecycle Management Tools

Statische CodeanalyseStatic Code Analysis

Die statische Analyse für C++ wurde aktualisiert, damit umfangreichere Informationen zu Fehlerkontexten, mehr Analyseregeln sowie bessere Analyseergebnisse bereitgestellt werden.Static analysis for C++ has been updated to provide richer error context information, more analysis rules, and better analysis results. Im neuen Fenster „Codeanalyse“ können Sie Meldungen nach Schlüsselwort, Projekt und Schweregrad filtern.In the new Code Analysis window, you can filter messages by keyword, project, and severity. Beim Auswählen einer Meldung in diesem Fenster wird die entsprechende Zeile, in der die Meldung ausgelöst wurde, im Quellcode-Editor hervorgehoben.When you select a message in the window, the line in the code where the message was triggered is highlighted in the code editor. Für bestimmte C++-Warnungen führt die Meldung Quellzeilen auf, die den Ausführungspfad zu der Warnung anzeigen. Entscheidungspunkte und die Gründe,warum dieser bestimmte Pfad ausgewählt wurde, werden hervorgehoben.For certain C++ warnings, the message lists source lines that show the execution path that leads to the warning; decision points and the reasons for taking that specific path are highlighted. Die Codeanalyse ist in allen Editionen von Visual Studio 2012 enthalten.Code analysis is included in most editions of Visual Studio 2012. In den Editionen Professional, Premium und Ultimate sind alle Regeln enthalten.In the Professional, Premium, and Ultimate editions, all rules are included. In den Express-Editionen für Windows 8 und Windows Phone sind nur die wichtigsten Warnungen enthalten.In the Express editions for Windows 8 and Windows Phone, just the most critical warnings are included. Die Codeanalyse ist nicht in der Express-Edition für Web enthalten.Code analysis is not included in the Express edition for Web. Im Folgenden werden einige andere Erweiterungen der Codeanalyse aufgeführt:Here are some other code analysis enhancements:

  • Mithilfe neuer Parallelitätswarnungen können Sie Fehler mit der Parallelität vermeiden, indem Sie darauf achten, dass Sie die richtigen Sperrdisziplinen in C/C++-Multithreadprogrammen verwenden.New concurrency warnings help you avoid concurrency bugs by making sure that you are using the correct locking disciplines in multithreaded C/C++ programs. Der Analyzer erkennt verschiedene mögliche Racebedingungen, Sperrreihenfolgenumstellungen, Aufrufer-/Aufgerufener-Sperrenvertragsverletzungen, nicht übereinstimmende Synchronisierungsvorgänge sowie weitere Fehler bei der Parallelität.The analyzer detects potential race conditions, lock order inversions, caller/callee locking contract violations, mismatched synchronization operations, and other concurrency bugs.
  • Sie können die C++-Regeln angeben, die Sie auf Ausführungen der Codeanalyse anwenden möchten, indem Sie Regelsätze verwenden.You can specify the C++ rules that you want to apply to code analysis runs by using rule sets.
  • Sie können im Codeanalysefenster ein Pragma in den Quellcode einfügen, das eine ausgewählte Warnung unterdrückt.In the Code Analysis window, you can insert into the source code a pragma that suppresses a selected warning.
  • Sie können die Genauigkeit und Vollständigkeit der statischen Codeanalyse verbessern, indem Sie die neue Version der Quellcodeanmerkungssprache von Microsoft (Microsoft Source-Code Annotation Language, SAL) verwenden, um zu beschreiben, wie eine Funktion ihre jeweiligen Parameter verwendet, welche Annahmen sie zu diesen Parametern trifft und welche Garantien sie gewährleistet, wenn sie abgeschlossen wird.You can enhance the accuracy and completeness of static code analysis by using the new version of the Microsoft source-code annotation language (SAL) to describe how a function uses its parameters, the assumptions that it makes about them, and the guarantees that it makes when it finishes.
  • Unterstützung von 64-Bit-C++-Projekten.Support for 64bit C++ projects.

Aktualisiertes KomponententestframeworkUpdated Unit Test Framework

Verwenden Sie das neue Komponententestframework für C++ in Visual Studio, um Komponententests für C++ zu schreiben.Use the new C++ unit test framework in Visual Studio to write C++ unit tests. Fügen Sie ein neues Komponententestprojekt zu Ihrer bereits vorhandenen C++-Projektmappe hinzu, indem Sie in der Kategorie „Visual C++“ im Dialogfeld „Neues Projekt“ die Vorlage für das C++-Komponententestprojekt suchen.Add a new unit test project to your existing C++ solution by locating the C++ Unit Test Project template under the Visual C++ category in the New Project dialog box. Beginnen Sie damit, Ihre Komponententests in der Datei „Unittest1.cpp“ in den generierten Rumpfcode „TEST_METHOD“ zu schreiben.Start writing your unit tests in the generated TEST_METHOD code stub in the Unittest1.cpp file. Erstellen Sie die Projektmappe, nachdem Sie den Testcode geschrieben haben.When the test code is written, build the solution. Öffnen Sie zum Ausführen der Tests das Fenster Komponententest-Explorer, indem Sie erst auf Ansicht > Weitere Fenster > Komponentest-Explorer und anschließend im Kontextmenü für die gewünschte Testsituation auf Ausgewählten Test ausführen klicken.When you want to run the tests, open a Unit Test Explorer window by choosing View > Other Windows > Unit Test Explorer, and then, on the shortcut menu for the test case you want, choose Run selected test. Nach Abschluss des Testlaufs können Sie in demselben Fenster die Testergebnisse und zusätzliche Überwachungsinformationen abrufen.After the test run finishes, you can view test results and additional stack trace information in the same window.

Architektur der AbhängigkeitsdiagrammeArchitecture Dependency Graphs

Damit Sie Ihren Code besser verstehen können, können Sie jetzt Abhängigkeitsdiagramme für die Binärdatei, die Klasse und den Namespace generieren und Dateien in eine Projektmappe einfügen.To understand your code better, you can now generate dependency graphs for the binary, class, namespace, and include files in a solution. Wählen Sie in der Menüleiste Architektur > Abhängigkeits Diagramm generierenund dann für Projekt Mappe oder für Includedatei aus, um ein Abhängigkeits Diagramm zu generieren.On the menu bar, choose Architecture > Generate Dependency Graph, and then For Solution or For Include File to generate a dependency graph. Wenn die Generierung des Diagramms beendet ist, können Sie es durchsuchen, indem Sie die einzelnen Knoten erweitern, die Abhängigkeitsbeziehungen durch Verschieben zwischen Knoten ermitteln und Quellcode durchsuchen, indem Sie im Kontextmenü für einen Knoten Inhalt anzeigen auswählen.When the graph generation is complete, you can explore it by expanding each node, learn dependency relationships by moving between nodes, and browse source code by choosing View Content on the shortcut menu for a node. Wenn Sie ein Abhängigkeits Diagramm für Includedateien generieren möchten, wählen Sie im Kontextmenü für eine * cpp-Quell Code Datei oder * . h-Header Datei Diagramm der Includedateien generieren aus.To generate a dependency graph for include files, on the shortcut menu for a *.cpp source code file or *.h header file, choose Generate Graph of Include Files.

Architektur-ExplorerArchitecture Explorer

Wenn Sie den Architektur-Explorer verwenden, können Sie das Objekt in Ihrer C++-Projektmappe, in ihren Projekten oder in ihren Dateien durchsuchen.By using the Architecture Explorer, you can explore the assets in your C++ solution, projects, or files. Wählen Sie in der Menüleiste Architektur > Windows- > Architektur-Exploreraus.On the menu bar, choose Architecture > Windows > Architecture Explorer. Sie können einen Knoten auswählen, an dem Sie interessiert sind, z. b. Klassenansicht.You can select a node you are interested in, for example, Class View. Bei diesem Beispiel wird die rechte Seite des Toolfensters mit einer Liste von Namespaces erweitert.In this case, the right side of the tool window is expanded with a list of namespaces. Wenn Sie einen Namespace auswählen, wird in einer neuen Spalte eine Liste von Klassen, Strukturen und Aufzählungen in diesem Namespace angezeigt.If you select a namespace, a new column shows a list of the classes, structs, and enums in this namespace. Sie können die Objekte weiter durchsuchen oder zurück zur linken Spalte wechseln, um eine weitere Abfrage zu starten.You can continue to explore these assets, or go back to the column on the far left to start another query. Weitere Informationen finden Sie unter Suchen von Code im Architektur-Explorer.See Find Code with Architecture Explorer.

Code CoverageCode Coverage

Die Code Coverage wurde aktualisiert, um Binärdateien zur Runtime dynamisch zu instrumentieren.Code coverage has been updated to dynamically instrument binaries at runtime. Dadurch wird der Mehraufwand für die Konfiguration reduziert und die Leistung verbessert.This lowers the configuration overhead and provides better performance. Außerdem können Sie Daten zur Code Coverage aus Komponententests für C++-Apps erfassen.You can also collect code-coverage data from unit tests for C++ apps. Wenn Sie C++-Komponententests erstellt haben, können Sie den Komponenten Test-Explorer verwenden, um Tests in der Projekt Mappe zu ermitteln.When you have created C++ unit tests, you can use Unit Test Explorer to discover tests in your solution. Um die Komponententests auszuführen und Code Coverage Daten für diese zu erfassen, wählen Sie im Komponenten Test-Explorer Code Coverage analysierenaus.To run the unit tests and collect code coverage data for them, in Unit Test Explorer, choose Analyze Code Coverage. Sie können sich die Ergebnisse der Code Coverage im Fenster Code Coverage-Ergebnisse ansehen, indem Sie in der Menüleiste auf Test > Fenster > Code Coverage-Ergebnisse klicken.You can examine the code coverage results in the Code Coverage Results window—on the menu bar, choose Test > Windows > Code Coverage Results.

Neuerungen bei C++ in Visual Studio 2010What's New for C++ in Visual Studio 2010

C++-Compiler und -LinkerC++ Compiler and Linker

Auto-Schlüsselwort.auto Keyword. Das auto Schlüsselwort hat einen neuen Zweck.The auto keyword has a new purpose. Verwenden Sie die Standardbedeutung des- auto Schlüssel Worts, um eine Variable zu deklarieren, deren Typ aus dem Initialisierungs Ausdruck in der Deklaration der Variablen abgeleitet wird.Use the default meaning of the auto keyword to declare a variable whose type is deduced from the initialization expression in the declaration of the variable. Die- /Zc:auto Compileroption ruft entweder die neue oder die vorherige Bedeutung des auto Schlüssel Worts auf.The /Zc:auto compiler option invokes either the new or the previous meaning of the auto keyword.

Typspezifizierer decltype.decltype Type Specifier. Der decltype Typspezifizierer gibt den Typ eines angegebenen Ausdrucks zurück.The decltype type specifier returns the type of a specified expression. Verwenden decltype Sie den Typspezifizierer in Kombination mit dem- auto Schlüsselwort, um einen Typ zu deklarieren, der entweder komplex oder nur dem Compiler bekannt ist.Use the decltype type specifier in combination with the auto keyword to declare a type that is either complex or known only to the compiler. Verwenden Sie z.B. diese Kombination, um eine Vorlagenfunktion zu deklarieren, deren Rückgabetyp von den Typen seiner Vorlagenargumente abhängt.For example, use the combination to declare a template function whose return type depends on the types of its template arguments. Stattdessen können Sie auch eine Vorlagenfunktion deklarieren, die einen Aufruf einer anderen Funktion aufruft und anschließend den Rückgabetyp der aufgerufenen Funktion zurückgibt.Or, declare a template function that calls another function, and then returns the return type of the called function.

Lambda-Ausdrücke.Lambda Expressions. Die Lambdafunktionen verfügen über einen Funktionstext, aber nicht über einen Namen.Lambda functions have a function body but no name. Sie vereinen in sich die besten Eigenschaften von Funktionszeigern und Funktionsobjekten.Lambda functions combine the best characteristics of function pointers and function objects. Verwenden Sie eine Lambda-Funktion eigenständig als Vorlagen Funktionsparameter anstelle eines Funktions Objekts, oder verwenden auto Sie das Schlüsselwort, um eine Variable zu deklarieren, deren Typ ein Lambda ist.Use a lambda function by itself, as a template function parameter instead of a function object, or together with the auto keyword to declare a variable whose type is a lambda.

R-Wert-Verweis.Rvalue Reference. Der R-Wert-Verweisdeklarator (&&) deklariert einen Verweis auf einen R-Wert.The rvalue reference declarator (&&) declares a reference to an rvalue. Mit dem R-Wert-Verweis können Sie zusätzliche Semantik und die perfekte Weiterleitung nutzen, um effizientere Konstruktoren, Funktionen und Vorlagen in Code zu schreiben.An rvalue reference lets you use move semantics and perfect forwarding to write more efficient constructors, functions, and templates.

static_assert-Deklaration.static_assert Declaration. Eine- static_assert Deklaration testet eine Software-Assertion zur Kompilierzeit, im Gegensatz zu anderen Durchsetzungsmechanismen, die zur Laufzeit testen.A static_assert declaration tests a software assertion at compile time, unlike other assertion mechanisms that test at run time. Schlägt die Assertion fehl, kann auch die Kompilierung nicht erfolgreich abgeschlossen werden. Das System gibt dann eine Fehlermeldung aus.If the assertion fails, the compilation fails and a specified error message is issued.

Die Schlüsselwörter „nullptr“ und „__nullptr“.nullptr and __nullptr Keywords. Mit MSVC können Sie das nullptr Schlüsselwort mit nativem Code oder mit verwaltetem Code verwenden.MSVC lets you use the nullptr keyword with native code or with managed code. Das nullptr Schlüsselwort gibt an, dass ein Objekt Handle, ein innerer Zeiger oder ein System eigener Zeigertyp nicht auf ein Objekt verweist.The nullptr keyword indicates that an object handle, interior pointer, or native pointer type does not point to an object. Der Compiler interpretiert nullptr als verwalteten Code, wenn Sie die /clr -Compileroption verwenden, und systemeigenen Code, wenn Sie die-Option nicht verwenden /clr .The compiler interprets nullptr to be managed code when you use the /clr compiler option, and native code when you do not use the /clr option. Das Microsoft-spezifische __nullptr -Schlüsselwort hat dieselbe Bedeutung wie nullptr , es gilt jedoch nur für nativen Code.The Microsoft-specific __nullptr keyword has the same meaning as nullptr, but it applies to native code only. Wenn Sie systemeigenen C/C++-Code mit der- /clr Compileroption kompilieren, kann der Compiler nicht bestimmen, ob das nullptr Schlüsselwort ein System eigener oder ein verwalteter Begriff ist.If you compile native C/C++ code by using the /clr compiler option, the compiler cannot determine whether the nullptr keyword is a native or a managed term. Verwenden Sie das nullptr-Schlüsselwort, um den verwalteten Begriff anzugeben, und __nullptr , um den systemeigenen Begriff anzugeben, um die Absicht für den Compiler klar zu machen.To make your intention clear to the compiler, use the nullptr keyword to specify the managed term, and __nullptr to specify the native term.

/Zc:trigraphs Compileroption./Zc:trigraphs Compiler Option. Standardmäßig ist die Unterstützung von Trigraphen deaktiviert.By default, support for trigraphs is disabled. Verwenden Sie die- /Zc:trigraphs Compileroption zum Aktivieren der Unterstützung von UnterstützungUse the /Zc:trigraphs compiler option to enable trigraphs support. Ein Trigraph besteht aus zwei aufeinander folgenden Fragezeichen (??) gefolgt von einem eindeutigen dritten Zeichen.A trigraph consists of two consecutive question marks (??) followed by a unique third character. Der Compiler ersetzt einen Trigraphen durch ein entsprechendes Interpunktionszeichen.The compiler replaces a trigraph with the corresponding punctuation character. Der Compiler ersetzt z.B. den Trigraphen ??= durch das Nummernzeichen #.For example, the compiler replaces the ??= trigraph with the # (number sign) character. Verwenden Sie Trigraphen in C-Quelldateien, die einen Zeichensatz aufweisen, der einige Interpunktionszeichen nicht enthält.Use trigraphs in C source files that use a character set that does not contain certain punctuation characters.

Neue Option „Profilgesteuerte Optimierung“.New Profile-Guided Optimization Option. Bei PogoSafeMode handelt es sich um eine neue Option zur profilgesteuerten Optimierung, über die Sie angeben können, ob der abgesicherte oder der schnelle Modus bei der Optimierung der Anwendung verwendet werden soll.PogoSafeMode is a new profile-guided optimization option that lets you specify whether to use safe mode or fast mode when you optimize your application. Der abgesicherte Modus ist zwar threadsicher, aber langsamer als der schnelle Modus.Safe mode is thread-safe, but it is slower than fast mode. Der schnelle Modus stellt das Standardverhalten dar.Fast mode is the default behavior.

Neue Common Language Runtime-Option /clr:nostdlib.New Common Language Runtime (CLR) Option /clr:nostdlib. Für /clr wurde eine neue Option hinzugefügt (Common Language Runtime-Kompilierung).A new option is added for /clr (Common Language Runtime Compilation). Wenn verschiedene Versionen derselben Bibliotheken enthalten sind, wird ein Compilerfehler zurückgegeben.If different versions of the same libraries are included, a compile error is issued. Mithilfe der neuen Option können Sie die CLR-Standardbibliotheken ausschließen, damit Ihr Programm eine festgelegte Version verwenden kann.The new option lets you exclude the default CLR libraries so that your program can use a specified version.

Die neue pragma-Anweisung „detect_mismatch“New pragma directive detect_mismatch. Mithilfe der pragma-Anweisung „detect_mismatch“ können Sie Ihren Dateien eine Markierung hinzufügen, die mit anderen Markierungen mit demselben Namen verglichen wird.The pragma directive detect_mismatch lets you put a tag in your files that is compared to other tags that have the same name. Wenn es mehrere Werte für denselben Namen gibt, wird vom Linker ein Fehler zurückgegeben.If there are multiple values for the same name, the linker issues an error.

Intrinsische XOP-Funktionen, intrinsische FMA4-Funktionen und intrinsische LWP-Funktionen.XOP Intrinsics, FMA4 Intrinsics, and LWP Intrinsics. Neue intrinsische Funktionen wurden hinzugefügt, um Prozessortechnologien für intrinsische XOP-Funktionen (für Visual Studio 2010 SP1 hinzugefügt), intrinsische FMA4-Funktionen (für Visual Studio 2010 SP1 hinzugefügt) und intrinsische LWP-Funktionen (für Visual Studio 2010 SP1 hinzugefügt) zu unterstützen.New intrinsic functions have been added to support the XOP Intrinsics Added for Visual Studio 2010 SP1, FMA4 Intrinsics Added for Visual Studio 2010 SP1, and LWP Intrinsics Added for Visual Studio 2010 SP1 processor technologies. Verwenden Sie „__cpuid“ und „__cpuidex“, um zu bestimmen, welche Prozessortechnologien auf den einzelnen Computern unterstützt werden.Use __cpuid, __cpuidex to determine which processor technologies are supported on a particular computer.

C++-Projekte in Visual Studio und das BuildsystemVisual Studio C++ projects and the Build System

MSBuild.MSBuild. Visual C++-Projektmappen und -Projekte werden jetzt mithilfe von „MSBuild.exe“ erstellt. Diese Datei ersetzt die Datei „VCBuild.exe“.Visual C++ solutions and projects are now built by using MSBuild.exe, which replaces VCBuild.exe. Bei MSBuild handelt es sich um das flexible, erweiterbare, XML-basierte Buildtool, das auch von den anderen Visual Studio-Sprachen und -Projekttypen verwendet wird.MSBuild is the same flexible, extensible, XML-based build tool that is used by the other Visual Studio languages and project types. Aufgrund dieser Änderung verwenden C++-Projektdateien in Visual Studio jetzt das XML-Dateiformat und haben die Erweiterung „vcxproj“.Because of this change, Visual Studio C++ project files now use an XML file format and have the .vcxproj file name extension. C++-Projektdateien in Visual Studio aus früheren Versionen von Visual Studio werden automatisch in das neue Dateiformat konvertiert.Visual Studio C++ project files from earlier versions of Visual Studio are automatically converted to the new file format.

VC++-Verzeichnisse.VC++ Directories. Die Einstellung „VC++-Verzeichnisse“ befindet sich jetzt an zwei verschiedenen Orten.The VC++ directories setting is now located in two places. Verwenden Sie die Projekteigenschaftenseiten, um Werte projektbasiert für VC++-Verzeichnisse festzulegen.Use project property pages to set per-project values for VC++ directories. Verwenden Sie den Eigenschaften-Manager und ein Eigenschaftenblatt, um globale Werte für jede Konfiguration von VC++-Verzeichnissen festzulegen.Use the Property Manager and a property sheet to set global, per-configuration values for VC++ directories.

Abhängigkeiten zwischen Projekten.Project-to-Project Dependencies. In früheren Releases wurden definierte Abhängigkeiten von Projekten in der Projektmappendatei gespeichert.In earlier releases, defined dependencies between projects were stored in the solution file. Wenn diese Projektmappen in das neue Projektdateiformat konvertiert werden, werden Abhängigkeiten in Verweise zwischen Projekten konvertiert.When these solutions are converted to the new project file format, dependencies are converted to project-to-project references. Diese Änderung kann Anwendungen beeinflussen, da sich Konzepte von Projektmappenabhängigkeiten und Abhängigkeiten zwischen Projekten voneinander unterscheiden.This change can affect applications because the concepts of solution dependencies and project-to-project references are different.

Makros und Umgebungsvariablen.Macros and Environment Variables. Das neue Makro „_ITERATOR_DEBUG_LEVEL“ ruft die Unterstützung des Debuggens für Iteratoren auf.The new _ITERATOR_DEBUG_LEVEL macro invokes debugging support for iterators. Verwenden Sie dieses Makro anstelle der älteren Makros „_SECURE_SCL“ und „_HAS_ITERATOR_DEBUGGING“.Use this macro instead of the older _SECURE_SCL and _HAS_ITERATOR_DEBUGGING macros.

Visual C++-BibliothekenVisual C++ Libraries

Concurrency Runtime-Bibliotheken.Concurrency Runtime Libraries. Das Framework „Concurrency Runtime“ unterstützt Anwendungen und Komponenten, die gleichzeitig ausgeführt werden. Außerdem handelt es sich dabei um das Framework, das zum Programmieren von gleichzeitigen Anwendungen in Visual C++ verwendet wird.The Concurrency Runtime framework supports applications and components that run simultaneously, and is the framework for programming concurrent applications in Visual C++. Die Parallel Patterns Library (PPL) bietet zur Unterstützung der Programmierung von parallelen Anwendungen allgemeine Container und Algorithmen zum Ausführen der differenzierten Parallelität.To support concurrent-application programming, the Parallel Patterns Library (PPL) provides general-purpose containers and algorithms for performing fine-grained parallelism. Die Bibliothek der asynchronen Agents ist ein akteurbasiertes Programmiermodell und stellt Schnittstellen zum Übergeben von Meldungen für simple Datenfluss- und Pipelineaufgaben bereit.The Asynchronous Agents Library provides an actor-based programming model and message passing interfaces for coarse-grained dataflow and pipelining tasks.

C++-Standardbibliothek.Standard C++ Library. In der folgenden Liste werden viele der Änderungen beschrieben, die an der C++-Standardbibliothek vorgenommen wurden.The following list describes many of the changes that have been made to the Standard C++ Library.

  • Die neue C++-Sprachfunktion des R-Wert-Verweises wurde verwendet, um Move-Semantiken und die perfekte Weiterleitung für zahlreiche Funktionen in der Standardvorlagenbibliothek zu implementieren.The new rvalue reference C++ language feature has been used to implement move semantics and perfect forwarding for many functions in the Standard Template Library. Mithilfe der Move-Semantiken und der perfekten Weiterleitung wird die Leistung der Vorgänge enorm verbessert, in denen Variablen oder Parameter zugeordnet oder zugewiesen werden.Move semantics and perfect forwarding greatly improve the performance of operations that allocate or assign variables or parameters.
  • Außerdem werden Rvalue-Verweise verwendet, um die neue unique_ptr-Klasse zu implementieren. Diese Klasse ist im Vergleich zur auto_ptr-Klasse ein sichererer intelligenter Zeigertyp.Rvalue references are also used to implement the new unique_ptr class, which is a safer smart pointer type than the auto_ptr class. Die unique_ptr-Klasse ist zwar verschiebbar, kann jedoch nicht kopiert werden. Sie implementiert eine strenge Besitzsemantik ohne Auswirkungen auf die Sicherheit und funktioniert gut mit Containern zusammen, die rvalue-Verweise beachten.The unique_ptr class is movable but not copyable, implements strict ownership semantics without affecting safety, and works well with containers that are aware of rvalue references. Die auto_ptr-Klasse ist veraltet.The auto_ptr class is deprecated.
  • 15 neue Funktionen, z. b find_if_not copy_if ., und is_sorted , wurden dem-Header hinzugefügt <algorithm> .Fifteen new functions, for example, find_if_not, copy_if, and is_sorted, have been added to the <algorithm> header.
  • In der <memory> Kopfzeile ist die neue make_shared-Funktion eine bequeme, robuste und effiziente Möglichkeit, einen freigegebenen Zeiger auf ein Objekt zu erstellen, wenn das Objekt erstellt wird.In the <memory> header, the new make_shared function is a convenient, robust, and efficient way to make a shared pointer to an object at the same time the object is constructed.
  • Durch den-Header werden einzeln verknüpfte Listen unterstützt <forward_list> .Singly linked lists are supported by the <forward_list> header.
  • Die neuen Memberfunktionen cbegin, cend, crbegin und crend stellen einen const_iterator-Objekt bereit, das sich im Container vorwärts und rückwärts bewegt.The new cbegin, cend, crbegin, and crend member functions provide a const_iterator that moves forward or backward through a container.
  • Der <system_error> -Header und verwandte Vorlagen unterstützen die Verarbeitung von Systemfehlern auf niedriger Ebene.The <system_error> header and related templates support the processing of low-level system errors. Member der exception_ptr-Klasse können verwendet werden, um Ausnahmen zwischen den Threads zu transportieren.Members of the exception_ptr class can be used to transport exceptions between threads.
  • Der- <codecvt> Header unterstützt das umrechnen verschiedener Codierungen von Unicode-Zeichen in andere Codierungen.The <codecvt> header supports converting various encodings of Unicode characters to other encodings.
  • Der- <allocators> Header definiert mehrere Vorlagen, die dabei helfen, Speicherblöcke für Knoten basierte Container zuzuordnen und freizugeben.The <allocators> header defines several templates that help allocate and free memory blocks for node-based containers.
  • Der-Header enthält zahlreiche Updates <random> .There are numerous updates to the <random> header.

Microsoft Foundation Class-BibliothekenMicrosoft Foundation Class (MFC) Library

Windows 7-Features.Windows 7 Features. MFC unterstützt zahlreiche Features für Windows 7, z.B. die Menüband-Benutzeroberfläche, die Taskleiste, Sprunglisten, Miniaturansichten mit Registerkarten, Miniaturansichten, die Statusanzeige, Symbolüberlagerung und die Suchindizierung.MFC supports many Windows 7 features, for example, the Ribbon user interface (UI), the Taskbar, jump lists, tabbed thumbnails, thumbnail previews, the progress bar, icon overlay, and search indexing. Da MFC automatisch einige Funktionen für Windows 7 unterstützt, müssen Sie Ihre bereits vorhandene Anwendung nicht mehr verändern.Because MFC automatically supports many Windows 7 features, you may not have to modify your existing application. Verwenden Sie zur Unterstützung von anderen Features in neuen Anwendungen den MFS-Anwendungsassistenten, um die gewünschte Funktionalität anzugeben.To support other features in new applications, use the MFC Application Wizard to specify the functionality you want to use.

Multitouchunterstützung.Multi-touch Awareness. MFC unterstützt Anwendungen mit Multitouch-Benutzeroberflächen, also z.B. Anwendungen, die für das Betriebssystem Microsoft Surface geschrieben wurden.MFC supports applications that have a multi-touch user interface, for example, applications that are written for the Microsoft Surface operating system. Eine Multitouch-Anwendung kann Windows Touch-Nachrichten und Bewegungsnachrichten verarbeiten, die eine Kombination aus verschiedenen Touch-Nachrichten darstellen.A multi-touch application can handle Windows touch messages and gesture messages, which are combinations of touch messages. Registrieren Sie Ihre Anwendung für Touch- und Bewegungsereignisse. Dann leitet Ihr Betriebssystem Multitouch-Ereignisse an Ihre Ereignishandler weiter.Just register your application for touch and gesture events and the operating system will route multi-touch events to your event handlers.

Berücksichtigung hoher DPI-Werte.High-DPI Awareness. Standardmäßig unterstützen MFC-Anwendungen jetzt High-DPI.By default, MFC applications are now High-DPI-aware. Wenn eine Anwendung High-DPI (Dots per Inch = Punkte pro Zoll) unterstützt, kann das Betriebssystem Fenster, Text und andere Benutzeroberflächenelemente für die aktuelle Bildschirmauflösung skalieren.If an application is High-DPI (high dots per inch) aware, the operating system can scale windows, text, and other UI elements to the current screen resolution. Das bedeutet, dass bei einem skalierten Bild die Chance größer ist, dass es richtig ausgerichtet und weder beschnitten noch verpixelt dargestellt wird.This means that a scaled image is more likely to be correctly laid out, and not clipped or pixelated.

Neustart-Manager.Restart Manager. Der Neustart-Manager speichert Dokumente automatisch ab und startet die Anwendung neu, falls diese unerwartet geschlossen oder neu gestartet wird.The restart manager automatically saves documents and restarts your application if it unexpectedly closes or restarts. Sie können den Neustart-Manager beispielsweise verwenden, um die Anwendung erneut zu starten, nachdem sie durch ein automatisches Update geschlossen wurde.For example, you can use the restart manager to start your application after it is closed by an automatic update. Weitere Informationen zum Konfigurieren der Anwendung für die Verwendung des Neustart-Managers finden Sie unter Gewusst wie: Hinzufügen der Unterstützungfür den Neustart-Manager.For more information about how to configure your application to use the restart manager, see How to: Add Restart Manager Support.

CTaskDialog.CTaskDialog. Die CTaskDialog-Klasse kann anstelle des Standardmeldungsfelds AfxMessageBox verwendet werden.The CTaskDialog class can be used instead of the standard AfxMessageBox message box. Die CTaskDialog-Klasse erfasst und mehr Informationen als das Standardmeldungsfeld und zeigt diese an.The CTaskDialog class displays and gathers more information than the standard message box does.

SafeInt-BibliothekSafeInt Library

Die neue SafeInt-Bibliothek führt sichere arithmetische Operationen aus, die den Ganzzahlüberlauf berücksichtigen.The new SafeInt Library performs safe arithmetic operations that account for integer overflow. Diese Bibliothek vergleicht außerdem verschiedene Arten von ganzen Zahlen.This library also compares different kinds of integers.

Neue Active Template Library-MakrosNew Active Template Library (ATL) macros

Der Active Template Library (ATL) wurden neue Makros hinzugefügt, um die Funkionen von „PROP_ENTRY_TYPE“ und „PROP_ENTRY_TYPE_EX“ zu erweitern.New macros have been added to ATL to expand the functionality of PROP_ENTRY_TYPE and PROP_ENTRY_TYPE_EX. Mithilfe von „PROP_ENTRY_INTERFACE“ und „PROP_ENTRY_INTERFACE_EX“ können Sie eine Liste von gültigen CLSIDs hinzufügen.PROP_ENTRY_INTERFACE and PROP_ENTRY_INTERFACE_EX let you add a list of valid CLSIDs. Mithilfe von „PROP_ENTRY_INTERFACE_CALLBACK“ und „PROP_ENTRY_INTERFACE_CALLBACK_EX“ können Sie eine Rückruffunktion angeben, um zu ermitteln, ob eine CLSID gültig ist.PROP_ENTRY_INTERFACE_CALLBACK and PROP_ENTRY_INTERFACE_CALLBACK_EX let you specify a callback function to determine whether a CLSID is valid.

/analyze-Warnungen/analyze Warnings

Die meisten /analyze Warnungen (Enterprise-Code Analyse) wurden aus den C-Laufzeitbibliotheken (CRT), MFC-und ATL-Bibliotheken entfernt.Most /analyze (Enterprise Code Analysis) warnings have been removed from the C Run-Time (CRT), MFC, and ATL libraries.

Animation und D2D-UnterstützungAnimation and D2D support

MFC unterstützt jetzt die Animation und Direct2D-Grafiken.MFC now supports animation and Direct2D graphics. Die MFC-Bibliothek verfügt über einige neue MFC-Klassen und -Funktionen, um diese Funktion zu unterstützen.The MFC library has several new MFC classes and functions to support this functionality. Es gibt außerdem zwei neue exemplarische Vorgehensweisen, in denen dargestellt wird, wie Sie einem Projekt ein D2D-Objekt und ein Animationsobjekt hinzufügen.There are also two new walkthroughs to show how to add a D2D object and an animation object to a project. Exemplarische Vorgehensweise: Hinzufügen eines D2D-Objekts zu einem MFC-Projekt und Exemplarische Vorgehensweise: Hinzufügen von Animationen zu einem MFC-Projekt.These walkthroughs are Walkthrough: Adding a D2D Object to an MFC Project and Walkthrough: Adding Animation to an MFC Project.

IDEIDE

Verbesserung von IntelliSenseImproved IntelliSense. IntelliSense für Visual C++ wurde vollständig umgestaltet und ist jetzt schneller, genauer und kann größere Projekte verarbeiten.IntelliSense for Visual C++ has been completely redesigned to be faster, more accurate, and able to handle larger projects. Damit diese Verbesserungen erzielt werden können, unterscheidet die IDE zwischen der Weise, auf die ein Entwickler Quellcode abruft und verändert, und der, auf die die IDE Quellcode und Projekteinstellungen verwendet, um eine Projektmappe zu erstellen.To achieve this improvement, the IDE makes a distinction between how a developer views and modifies source code, and how the IDE uses source code and project settings to build a solution. Aufgrund dieser Trennung von Aufgaben werden das Durchsuchen von Features wie Klassenansicht und das neue Dialogfeld " Navigieren zu " von einem System behandelt, das auf einer neuen SQL Server Desktop-Datenbankdatei (. sdf) basiert, die die alte Datei No compile Browse (. NCB) ersetzt.Because of this separation of duties, browsing features such as Class View and the new Navigate To dialog box are handled by a system that is based on a new SQL Server desktop database (.sdf) file that replaces the old no compile browse (.ncb) file. IntelliSense-Features wie QuickInfo, automatische Vervollständigung und die Parameterhilfe analysieren Übersetzungseinheiten nur falls erforderlich.IntelliSense features such as Quick Information, Auto Completion, and Parameter Help parse translation units only when required. Hybridfunktionen wie das neue Fenster Aufrufhierarchie verwenden eine Kombination aus Suchfunktionen und IntelliSense-Features.Hybrid features such as the new Call Hierarchy window use a combination of the browse and IntelliSense features. Da IntelliSense nur die Informationen verarbeitet, die zum jeweiligen Zeitpunkt erforderlich sind, ist die IDE reaktionsfähiger.Because IntelliSense processes only the information that you require at the moment, the IDE is more responsive. Außerdem werden IDE-Ansichten und -Fenster genauer dargestellt, da die Informationen aktueller sind.Also, because information is more up to date, IDE views and windows are more accurate. Zudem können größere Projekte verarbeitet werden, da die IDE-Infrastruktur besser organisiert, leistungsfähiger und skalierbarer ist.Finally, because the IDE infrastructure is better organized, more capable, and more scalable, it can handle larger projects.

Verbesserte IntelliSense-Fehlererkennung.Improved IntelliSense Errors. Die IDE kann besser Fehler ermitteln, die einen Verlust von IntelliSense zur Folge hätten, und zeigt rote Wellenlinien unter diesen Fehlern an.The IDE better detects errors that could cause a loss of IntelliSense and displays red wavy underlines under them. Außerdem sendet die IDE IntelliSense-Fehler an das Fenster Fehlerliste.In addition, the IDE reports IntelliSense errors to the Error List Window. Um den Code anzuzeigen, der das Problem verursacht, doppelklicken Sie auf den Fehler im Fenster Fehlerliste.To display the code that is causing the problem, double-click the error in the Error List Window.

Feature zur automatischen Vervollständigung für #include-Anweisungen.#include Auto-Complete Feature. Die IDE unterstützt die automatische Vervollständigung für das Schlüsselwort #include.The IDE supports auto-completion for the #include keyword. Wenn Sie #include eingeben, erstellt die IDE ein Dropdown-Listenfeld mit gültigen Headerdateien.When you type #include, the IDE creates a drop-down list box of valid header files. Wenn Sie dann den Dateinamen eingeben, filtert die IDE die Liste anhand Ihres Eintrags.If you continue by typing a file name, the IDE filters the list based on your entry. Sie können jederzeit die Datei aus der Liste auswählen, die Sie hinzufügen möchten.At any point, you can select from the list the file you want to include. Dadurch können Sie Dateien schnell hinzufügen, ohne den genauen Dateinamen kennen zu müssen.This lets you quickly include files without knowing the exact file name.

Navigieren Sie zu.Navigate To. Über das Dialogfeld Navigieren zu können Sie alle Symbole und Dateien in Ihrem Projekt suchen, die einer bestimmten Zeichenfolge entsprechen.The Navigate To dialog box lets you search for all symbols and files in your project that match a specified string. Es wird nach Suchergebnissen gesucht, während Sie zusätzliche Zeichen in Ihre Suchzeichenfolge eingeben.Search results are immediately revised as you type additional characters in your search string. Im Feedbackfeld Ergebnisse sehen Sie die Anzahl der gefundenen Elemente. Darüber können Sie entscheiden, ob Sie Ihre Suche einschränken möchten.The Results feedback field tells you the number of items found and helps you decide whether to constrain your search. Mithilfe der Felder Art/Bereich, Speicherortund Vorschau Feedback können Sie Elemente mit ähnlichen Namen unterscheiden.The Kind/Scope, Location, and Preview feedback fields help you disambiguate items that have similar names. Ebenso können Sie diese Funktion erweitern, sodass andere Programmiersprachen unterstützt werden.In addition, you can extend this feature to support other programming languages.

Paralleles Debuggen und Profilerstellung.Parallel Debugging and Profiling. Der Visual Studio-Debugger beachtet die Concurrency Runtime und unterstützt Sie bei der Behandlung von Problemen mit der Parallelverarbeitung von Anwendungen.The Visual Studio debugger is aware of the Concurrency Runtime and helps you troubleshoot parallel processing applications. Sie können das neue Concurrency-Profilerstellungstool verwenden, um das allgemeine Verhalten Ihrer Anwendung zu visualisieren.You can use the new concurrency profiler tool to visualize the overall behavior of your application. Außerdem können Sie neue Toolfenster verwenden, um den Status der Aufgaben und deren Aufruflisten zu visualisieren.Also, you can use new tool windows to visualize the state of tasks and their call stacks.

Menüband-Designer.Ribbon Designer. Bei dem Menüband-Designer handelt es sich um einen grafischen Editor, über den Sie eine MFC-Menübandbenutzeroberfläche erstellen und bearbeiten können.The Ribbon Designer is a graphical editor that lets you create and modify an MFC ribbon UI. Die endgültige Menüband-Benutzeroberfläche wird von einer XML-basierten Ressourcendatei dargestellt (.mfcribbon-ms).The final ribbon UI is represented by an XML-based resource file (.mfcribbon-ms). Für vorhandene Anwendungen können Sie die aktuelle Multifunktionsleisten-Benutzeroberfläche erfassen, indem Sie vorübergehend einige Codezeilen hinzufügen und dann den Menüband-Designeraufrufen.For existing applications, you can capture your current ribbon UI by temporarily adding a few lines of code and then invoking the Ribbon Designer. Nach der Erstellung der Ressourcendatei für das Menüband können Sie Ihren handgeschriebenen Code für die Menüband-Benutzeroberfläche durch einige Anweisungen ersetzen, die die Menübandressource laden.After the ribbon resource file is created, you can replace your handwritten ribbon UI code with a few statements that load the ribbon resource.

Aufrufhierarchie.Call Hierarchy. Im Fenster Aufrufhierarchie können Sie zu allen Funktionen navigieren, die von einer bestimmten Funktion aufgerufen werden, oder zu allen Funktionen, die eine bestimmte Funktion aufrufen.The Call Hierarchy window lets you navigate to all functions that are called by a particular function, or to all functions that call a particular function.

ToolsTools

MFC-Klassen-Assistent.MFC Class Wizard. Mit Visual C++ 2010 wird das praktische Tool „MFC-Klassenassistent“ wieder eingeführt.Visual C++ 2010 brings back the well-regarded MFC Class Wizard tool. Der MFC-Klassenassistent stellt eine praktische Möglichkeit dar, um einem Projekt Klassen, Meldungen und Variablen hinzuzufügen, ohne Quelldateien manuell verändern zu müssen.The MFC Class Wizard is a convenient way to add classes, messages, and variables to a project without having to manually modify sets of source files.

ATL-Steuerelement-Assistent.ATL Control Wizard. Der ATL-Steuerelement-Assistent füllt das Feld ProgID nicht mehr automatisch auf.The ATL Control Wizard no longer automatically populates the ProgID field. Wenn ein ATL-Steuerelement keine ProgID besitzt, können andere Tools möglicherweise nicht damit arbeiten.If an ATL control does not have a ProgID, other tools may not work with it. Beispielsweise verlangt das Dialogfeld Insert Active Control (Aktives Steuerelement einfügen), dass Steuerelemente eine ProgID aufweisen.One example of a tool that requires controls to have a ProgID is the Insert Active Control dialog box. Weitere Informationen zum Dialogfeld finden Sie unter Einfügen von ActiveX-Steuerelementen.For more information about the dialog box, see Insert ActiveX controls.

Referenz zum Microsoft Macro AssemblerMicrosoft Macro Assembler Reference

Neben dem Datentyp „YMMWORD“ werden die 256-Bit-Multimediaoperanden unterstützt, die in den Anweisungen zu den Intel Advanced Vector Extensions (AVX) enthalten sind.The addition of the YMMWORD data type supports the 256-bit multimedia operands that are included in the Intel Advanced Vector Extensions (AVX) instructions.

Neuerungen bei C++ in Visual Studio 2008What's New for C++ in Visual Studio 2008

Integrierte Entwicklungsumgebung (IDE) von Visual C++Visual C++ Integrated Development Environment (IDE)

  • Dialogfelder, die in ATL-, MFC- und Win32-Anwendungen erstellt werden, sind jetzt mit den Stilrichtlinien für Windows Vista konform.Dialog boxes that are created in ATL, MFC, and Win32 applications now comply with the Windows Vista style guidelines. Wenn Sie mithilfe von Visual Studio 2008 ein neues Projekt erstellen, sind alle Dialogfelder, die Sie in Ihre Anwendung einfügen, konform mit den Stilrichtlinien für Windows Vista.When you create a new project by using Visual Studio 2008, all dialog boxes that you insert into your application will comply with the Windows Vista style guideline. Wenn Sie ein Projekt erneut kompilieren wollen, das Sie mit einer früheren Version von Visual Studio erstellt haben, werden alle bereits vorhandenen Dialogfelder genauso dargestellt wie in früheren Versionen.If you recompile a project that you created with an earlier version of Visual Studio, any existing dialog boxes will maintain the same look that they previously had. Weitere Informationen zum Einfügen von Dialogfeldern in Ihre Anwendungen finden Sie unter Dialog-Editor.For more information about how to insert dialog boxes into your application, see Dialog Editor.

  • Der ATL-Projekt-Assistent verfügt jetzt über eine Option zum Registrieren von Komponenten für alle Benutzer.The ATL Project wizard now has an option to register components for all users. Ab Visual Studio 2008 werden die COM-Komponenten und Typbibliotheken, die vom ATL-Projekt -Assistenten erstellt werden, im Knoten "HKEY_CURRENT_USER" der Registrierung registriert, es sei denn, Sie wählen die Option " Komponente für alle Benutzer registrieren" aus.Beginning with Visual Studio 2008, the COM components and type libraries that are created by the ATL Project wizard are registered in the HKEY_CURRENT_USER node of the registry unless you select Register component for all users.

  • Der **ATL-Projekt-Assistent **stellt keine Option mehr bereit, um attributierte ATL-Projekte zu erstellen.The ATL Project wizard no longer provides an option to create attributed ATL projects. Ab Visual Studio 2008 bietet der ATL-Projekt-Assistent keine Option mehr zum Ändern des attributierten Status eines neuen Projekts.Beginning with Visual Studio 2008, the ATL Project wizard does not have an option to change the attributed status of a new project. Alle ATL-Projekte, die der Assistent neu erstellt, sind jetzt nicht mehr attributiert.All new ATL projects that the wizard creates are now unattributed.

  • Das Schreiben in die Registrierung kann umgeleitet werden.Writing to the registry can be redirected. Ab der Einführung von Windows Vista musste ein Programm im Modus mit erhöhten Rechten ausgeführt werden, damit in bestimmte Bereiche der Registrierung geschrieben werden konnte.With the introduction of Windows Vista, writing to certain areas of the registry requires a program to run in elevated mode. Visual Studio sollte nicht permanent im Modus mit erhöhten Rechten ausgeführt werden.It is not desirable to always run Visual Studio in elevated mode. Über die Umleitung pro Benutzer werden Registrierungsschreibvorgänge automatisch ohne Änderungen der Programmierung von „HKEY_CLASSES_ROOT“ an „HKEY_CURRENT_USER“ weitergeleitet.Per-user redirection automatically redirects registry writes from HKEY_CLASSES_ROOT to HKEY_CURRENT_USER without any programming changes.

  • Der Klassen-Designer verfügt jetzt über die eingeschränkte Unterstützung für nativen C++-Code.The Class Designer now has limited support for native C++ code. In früheren Versionen von Visual Studio funktionierte der Klassen-Designer nur mit Visual c# und Visual Basic.In earlier versions of Visual Studio, the Class Designer worked only with Visual C# and Visual Basic. C++-Benutzer können jetzt zwar den Klassen-Designer verwenden, jedoch nur im schreibgeschützten Modus.C++ users can now use the Class Designer, but only in read-only mode. Weitere Informationen zum Verwenden der Klassen-Designer mit C++ finden Sie unter Arbeiten mit Visual C++ Code in Klassen-Designer.For more information about how to use the Class Designer with C++, see Working with Visual C++ Code in Class Designer.

  • Im Projektassistenten ist keine Option mehr enthalten, mit der Sie ein SQL Server-Projekt in C++ erstellen können.The project wizard no longer has an option to create a C++ SQL Server project. Ab Visual Studio 2008 bietet der Assistent für neue Projekte keine Option zum Erstellen eines C++ SQL Server-Projekts.Beginning with Visual Studio 2008, the new project wizard does not have an option to create a C++ SQL Server project. SQL Server-Projekte, die mit einer früheren Version von Visual Studio erstellt wurde, werden dennoch kompiliert und funktionieren ordnungsgemäß.SQL Server projects created by using an earlier version of Visual Studio will still compile and work correctly.

Visual C++-BibliothekenVisual C++ Libraries

AllgemeinGeneral

  • Anwendungen können an bestimmte Versionen von C++-Bibliotheken gebunden sein.Applications can be bound to specific versions of the Visual C++ libraries. In einigen Fällen sind Anwendungen von Updates abhängig, die für die Visual C++-Bibliotheken nach einem Release veröffentlicht wurden.Sometimes an application depends on updates that were made to the Visual C++ libraries after a release. Dann kann ein unerwartetes Verhalten auftreten, wenn eine Anwendung auf einem Computer ausgeführt wird, auf dem frühere Versionen der Bibliotheken gespeichert sind.In this case, running the application on a computer that has earlier versions of the libraries can cause unexpected behavior. Sie können jetzt Anwendungen an eine bestimmte Bibliotheksversion bilden, sodass diese nicht auf Computern ausgeführt wird, auf denen frühere Versionen der Bibliotheken gespeichert sind.You can now bind an application to a specific version of the libraries so that it will not run on a computer that has an earlier version of the libraries.

STL/CLR-BibliothekSTL/CLR Library

  • Visual C++ enthält jetzt die STL/CLR-Bibliothek.Visual C++ now includes the STL/CLR Library. Die STL/CLR-Bibliothek ist ein Paket der Standard Template Library (STL), einer Teilmenge der C++-Standardbibliothek, die mit C++ und der Common Language Runtime (CLR) von .NET Framework eingesetzt werden kann.The STL/CLR Library is a packaging of the Standard Template Library (STL), a subset of the Standard C++ Library, for use with C++ and the .NET Framework common language runtime (CLR). Mit STL/CLR können Sie jetzt alle Container, Iteratoren und Algorithmen der STL in einer verwalteten Umgebung verwenden.With STL/CLR, you can now use all the containers, iterators, and algorithms of STL in a managed environment.

MFC-BibliothekMFC Library

  • Unter Windows Vista werden allgemeine Steuerelemente unterstützt.Windows Vista supports Common Controls. Mehr als 150 Methoden in 18 neuen oder vorhandenen Klassen wurden hinzugefügt, um Features unter Windows Vista hinzuzufügen oder die Features in aktuellen MFC-Klassen zu verbessern.Over 150 methods in 18 new or existing classes have been added to support features in Windows Vista, or to improve functionality in current MFC classes.
  • Mithilfe der neuen CNetAddressCtrl-Klasse können Sie IPv4- und IPv6-Adressen oder DNS-Namen eingeben und überprüfen.The new CNetAddressCtrl class enables you to input and validate IPv4 and IPv6 addresses or DNS names.
  • Mithilfe der neuen CPagerCtrl-Klasse wird die Verwendung des Windows-Pagersteuerelements vereinfacht.The new CPagerCtrl class simplifies use of the Windows pager control.
  • Mithilfe der neuen CSplitButton-Klasse wird die Verwendung des SplitButton-Steuerelements vereinfacht, über das Sie eine Standardaktion oder eine optionale Option auswählen.The new CSplitButton class simplifies the use of the Windows splitbutton control to select a default or optional action.

C++-UnterstützungsbibliothekC++ Support Library

  • Mit C++ werden Marshallingbibliotheken eingeführt.C++ introduces the marshaling library. Die Marshallingbibliothek bietet eine einfache und optimierte Möglichkeit, Daten zwischen nativen und verwalteten Umgebungen zu marshallen.The marshaling library provides an easy and optimized way to marshal data between native and managed environments. Die Bibliothek stellt eine Alternative zu komplexeren und weniger effizienten Ansätzen wie PInvoke dar.The library is an alternative to more complex and less efficient approaches such as Using PInvoke. Weitere Informationen finden Sie unter Übersicht über das Marshalling in C++.See Overview of Marshaling in C++ for more information.

ATL-ServerATL Server

  • ATL-Server wird als freigegebenes Quellprojekt veröffentlicht.ATL Server is released as a shared source project.
  • Ein großer Bestandteil der Codebasis von ATL-Server wurde als freigegebenes Quellcodeprojekt auf CodePlex veröffentlicht und wird nicht als Teil von Visual Studio 2008 installiert.Most of the ATL Server code base has been released as a shared source project on CodePlex and is not installed as part of Visual Studio 2008. Mehrere Dateien, die mit ATL-Server verknüpft sind, gehören nicht mehr zu Visual Studio.Several files associated with ATL Server are no longer part of Visual Studio. Die Liste der entfernten Dateien finden Sie unter entfernte ATL-Server Dateien.For the list of removed files, see Removed ATL Server Files.
  • Die Klassen zur Datencodierung und -decodierung „atlenc.h“ und die Hilfsfunktionen und -klassen in „atlutil.h“ und „atlpath.h“ sind jetzt Bestandteil der ATL-Bibliothek.Data encoding and decoding classes from atlenc.h and utility functions and classes from atlutil.h and atlpath.h are now part of the ATL library.
  • Microsoft unterstützt weiterhin ATL-Server-Versionen, die in älteren Releases von Visual Studio enthalten sind, solange diese Visual Studio-Versionen unterstützt werden.Microsoft will continue to support versions of ATL Server that are included in earlier releases of Visual Studio as long as those versions of Visual Studio are supported. CodePlex entwickelt weiterhin ATL-Server-Code als Communityprojekt.CodePlex will continue development of the ATL Server code as a community project. Microsoft unterstützt keine CodePlex-Version von ATL-Server mehr.Microsoft does not support a CodePlex version of ATL Server.

Visual C++-Compiler und -LinkerVisual C++ Compiler and Linker

CompileränderungenCompiler Changes

  • Der Compiler unterstützt verwaltete inkrementelle Builds.The compiler supports managed incremental builds. Wenn Sie diese Option angeben, kompiliert der Compiler keinen Code erneut, wenn eine Referenzassembly verändert wird.When you specify this option, the compiler will not recompile code when a referenced assembly changes. Stattdessen wird ein inkrementeller Build durchgeführt.Instead it will perform an incremental build. Dateien werden nur erneut kompiliert, wenn Änderungen Auswirkungen auf den abhängigen Code haben.Files are recompiled only if the changes affect the dependent code.
  • Attribute, die im Zusammenhang mit dem ATL-Server stehen, werden nicht mehr unterstützt.Attributes related to ATL Server are no longer supported. Der Compiler unterstützt einige Attribute nicht mehr, die direkt mit dem ATL-Server im Zusammenhang stehen.The compiler no longer supports several attributes that were directly related to ATL Server. Weitere Informationen zu einer vollständigen Liste der entfernten Attribute finden Sie unter „Breaking Changes (Fehler verursachende Änderungen)“.For a complete list of the removed attributes, see Breaking Changes.
  • Der Compiler unterstützt die Mikroarchitektur „Intel Core“.The compiler supports Intel Core microarchitecture. Der Compiler optimiert die Mikroarchitektur „Intel Core“ bei der Codegenerierung.The compiler contains tuning for the Intel Core microarchitecture during code generation. Standardmäßig ist diese Optimierung aktiviert und kann nicht deaktiviert werden, da sie Pentium 4 und andere Prozessoren unterstützt.By default, this tuning is on and cannot be disabled as it also helps Pentium 4 and other processors.
  • Intrinsische Funktionen unterstützen neue AMD- und Intel-Prozessoren.Intrinsics support newer AMD and Intel processors. Einige neue intrinsische Anweisungen unterstützen ein höheres Maß an Funktionalität in aktuelleren AMD- und Intel-Prozessoren.Several new intrinsic instructions support the greater functionality in more recent AMD and Intel processors. Weitere Informationen zu den neuen systeminternen Funktionen finden Sie unter Ergänzende Streaming SIMD Extensions 3-Anweisungen, Streaming SIMD Extensions 4-Anweisungen, systeminterne Funktionen für SSE4A und erweiterte Bitmanipulation, systeminterne AES-Funktionen, _mm_clmulepi64_si128und __rdtscp.For more information about the new intrinsics, see Supplemental Streaming SIMD Extensions 3 Instructions, Streaming SIMD Extensions 4 Instructions, SSE4A and Advanced Bit Manipulation Intrinsics, AES Intrinsics, _mm_clmulepi64_si128, and __rdtscp.
  • Die __cpuid-Funktion wurde aktualisiert.The __cpuid function is updated. Die Funktionen __cpuid und __cpuidex unterstützen jetzt einige neue Features der letzten Überarbeitungen von AMD- und Intel-Prozessoren.The __cpuid, __cpuidex functions now support several new features from the latest revisions of AMD and Intel processors. Das intrinsische Funktion __cpuidex ist neu und erfasst weitere Informationen von neueren Prozessoren.The __cpuidex intrinsic is new and gathers more information from recent processors.
  • Die Compileroption /MP reduzierte die Gesamtdauer des Buildvorgangs.The /MP compiler option reduces total build time. Die Option /MP kann die Gesamtzeit deutlich reduzieren, damit mehrere Quelldateien kompiliert werden können, indem mehrere Prozesse erstellt werden, in denen Dateien gleichzeitig kompiliert werden.The /MP option can significantly reduce the total time to compile several source files by creating several processes that compile the files simultaneously. Diese Option ist besonders auf Computern nützlich, die das Hyperthreading, mehrere Prozessoren oder mehrere Kerne unterstützen.This option is especially useful on computers that support hyperthreading, multiple processors, or multiple cores.
  • Die /Wp64 Compileroption und das- __w64 Schlüsselwort sind veraltet.The /Wp64 compiler option and __w64 keyword are deprecated. Die /Wp64 Compileroption und das- __w64 Schlüsselwort, die 64-Bit-Portabilitäts Probleme erkennen, sind veraltet und werden in einer zukünftigen Version des Compilers entfernt.The /Wp64 compiler option and __w64 keyword, which detect 64-bit portability issues, are deprecated and will be removed in a future version of the compiler. Verwenden Sie anstelle dieser Compileroption und des Schlüsselworts einen Microsoft Visual C++-Compiler, der eine 64-Bit-Plattform als Ziel verwendet.Instead of this compiler option and keyword, use a MSVC that targets a 64-bit platform.
  • /Qfast_transcendentals generiert Inlinecode für transzendentale Funktionen./Qfast_transcendentals generates inline code for transcendental functions.
  • /Qimprecise_fwaits entfernt die internen fwait-Befehle, um Blöcke zu testen, wenn Sie die Compileroption /fp:except verwenden./Qimprecise_fwaits removes the fwait commands internal to try blocks when you use the /fp:except compiler option.

Änderungen am LinkerLinker Changes

  • Informationen zur Benutzerkontensteuerung sind jetzt über den Visual C++-Linker („link.exe“) in Manifestdateien für ausführbare Dateien eingebettet.User Account Control information is now embedded into manifest files for executables by the Visual C++ linker (link.exe). Dieses Feature ist standardmäßig aktiviert.This feature is enabled by default. Weitere Informationen zum Deaktivieren dieser Funktion oder zum Ändern des Standardverhaltens finden Sie unter /MANIFESTUAC (Einbetten von UAC-Informationen in Manifeste).For more information about how to disable this feature, or how to modify the default behavior, see /MANIFESTUAC (Embeds UAC information in manifest).
  • Der Linker verfügt jetzt über die Option /DYNAMICBASE zur Aktivierung der Windows Vista-Funktion „Address Space Layout Randomization“ (Zufällige Anordnung des Layouts des Adressraums).The linker now has the /DYNAMICBASE option to enable the Address Space Layout Randomization feature of Windows Vista. Diese Option ändert den Header einer ausführbaren Datei, um anzugeben, ob für die Anwendung nach dem Zufallsprinzip zur Ladezeit ein Rebase ausgeführt werden soll.This option modifies the header of an executable to indicate whether the application should be randomly rebased at load time.

Neuerungen bei C++ in Visual Studio 2005What's New for C++ in Visual Studio 2005

Die folgenden Features wurden in Visual C++ 2005 Service Pack 1 neu hinzugefügt:The following features were new in Visual C++ 2005 Service Pack 1:

Intrinsische Funktionen für x86 und x64Intrinsics for x86 and x64

  • __halt__halt
  • __lidt__lidt
  • __nop__nop
  • __readcr8__readcr8
  • __sidt__sidt
  • __svm_clgi__svm_clgi
  • __svm_invlpga__svm_invlpga
  • __svm_skinit__svm_skinit
  • __svm_stgi__svm_stgi
  • __svm_vmload__svm_vmload
  • __svm_vmrun__svm_vmrun
  • __svm_vmsave__svm_vmsave
  • __ud2__ud2
  • __vmx_off__vmx_off
  • __vmx_vmptrst__vmx_vmptrst
  • __writecr8__writecr8

Intrinsische Funktionen ausschließlich für x64Intrinsics for x64 Only

  • __vmx_on__vmx_on
  • __vmx_vmclear__vmx_vmclear
  • __vmx_vmlaunch__vmx_vmlaunch
  • __vmx_vmptrld__vmx_vmptrld
  • __vmx_vmread__vmx_vmread
  • __vmx_vmresume__vmx_vmresume
  • __vmx_vmwrite__vmx_vmwrite

Neue SprachschlüsselwörterNew Language Keywords

__sptr, __uptr__sptr, __uptr

Neue CompilerfeaturesNew Compiler Features

In diesem Release sind bedeutende Änderungen des Compilers enthalten.The compiler has breaking changes in this release.

  • Native 64-Bit-Compiler und Cross-Compiler.`64-bit native and cross-compilers.
  • Die /analyze-Compileroption (Enterprise-Codeanalyse) wurde hinzugefügt./analyze (Enterprise Code Analysis) compiler option has been added.
  • Die /bigobj-Compileroption wurde hinzugefügt./bigobj compiler option has been added.
  • /clr:pure, /clr:safe und /clr:oldSyntax wurden hinzugefügt./clr:pure, /clr:safe, and /clr:oldSyntax have been added. (Dies wurde später in Visual Studio 2015 als veraltet markiert und in Visual Studio 2017 entfernt.)(Later deprecated in Visual Studio 2015 and removed in Visual Studio 2017.)
  • Veraltete Compileroptionen: Viele Compileroptionen wurden in diesem Release als veraltet gekennzeichnet. Weitere Informationen finden Sie unter Deprecated Compiler Options (Veraltete Compileroptionen).Deprecated compiler options: many compiler options have been deprecated in this release; see Deprecated Compiler Options for more information.
  • Das doppelte Thunking in /clr-Code wurde reduziert. Weitere Informationen finden Sie unter Doppeltes Thunking (C++).Double thunking in /clr code is reduced; see Double Thunking (C++) for more information.
  • /EH (Ausnahmebehandlungsmodell) oder /EHs können nicht mehr verwendet werden, um eine Ausnahme zu erfassen, die mit einer anderen Funktion als mit „Throw“ ausgelöst wird. Verwenden Sie stattdessen /EHa./EH (Exception Handling Model) or /EHs can no longer be used to catch an exception that is raised with something other than a throw; use /EHa.
  • Die /errorReport-Compileroption (Interne Compilerfehler melden) wurde hinzugefügt./errorReport (Report Internal Compiler Errors) compiler option has been added.
  • Die /favor-Compileroption (Optimierung für 64) wurde hinzugefügt./favor (Optimize for 64) compiler option has been added.
  • Die Compileroptionen /FA und /Fa (Listendatei) wurden hinzugefügt./FA, /Fa (Listing File) compiler option has been added.
  • Die /FC-Compileroption (Vollständiger Pfad der Quellcodedatei in Diagnose) wurde hinzugefügt./FC (Full Path of Source Code File in Diagnostics) compiler option has been added.
  • Die /fp-Compileroption (Festlegen des Gleitkommaverhaltens) wurde hinzugefügt./fp (Specify Floating-Point Behavior) compiler option has been added.
  • Die /G-Compileroption (Optionen zum Optimieren für Prozessoren) wurde hinzugefügt./G (Optimize for Processor) Options compiler option has been added.
  • Die /G-Compileroption (Optionen zum Optimieren für Prozessoren) wurde hinzugefügt./G (Optimize for Processor) Options compiler option has been added.
  • Die Compileroptionen /G3, /G4, /G5, /G6, /G7, und /GB wurden entfernt./G3, /G4, /G5, /G6, /G7, and /GB compiler options have been removed. Der Compiler verwendet eine Füllmethode, die versucht, die beste Ausgabedatei für alle Architekturen zu erstellen.The compiler now uses a "blended model" that attempts to create the best output file for all architectures.
  • /Gf wurde entfernt./Gf has been removed. Verwenden Sie stattdessen /GF (Doppelte Zeichenfolgen beseitigen).Use /GF (Eliminate Duplicate Strings) instead.
  • /GL (Optimierung des gesamten Programms) ist jetzt mit /CLRHEADER kompatibel./GL (Whole Program Optimization) is now compatible with /CLRHEADER.
  • /GR ist jetzt standardmäßig aktiviert./GR is now on by default.
  • /GS (Puffer-Sicherheitsüberprüfung) stellt jetzt einen Sicherheitsschutz für anfällige Zeigerparameter dar./GS (Buffer Security Check) now provides security protection for vulnerable pointer parameters. /GS ist jetzt standardmäßig aktiviert./GS is now on by default. /GS funktioniert jetzt auch für Funktionen, die für MSIL mit /clr (Common Language Runtime-Kompilierung) kompiliert werden./GS now also works on functions compiled to MSIL with /clr (Common Language Runtime Compilation).
  • Die /homeparams-Compilerfunktion (Registerparameter in den Stapel kopieren) wurde hinzugefügt./homeparams (Copy Register Parameters to Stack) compiler option has been added.
  • Die /hotpatch-Compilerfunktion (Hotpatchfähiges Image erstellen) wurde hinzugefügt./hotpatch (Create Hotpatchable Image) compiler option has been added.
  • Die Heuristik der Inline Funktion wurde aktualisiert. inline Weitere Informationen finden Sie unter, __inline __forceinline und inline_depth .Inline function heuristics have been updated; see inline, __inline, __forceinline and inline_depth for more information
  • Viele neue intrinsische Funktionen wurden hinzugefügt, und viele zuvor nicht dokumentierte intrinsische Funktionen werden jetzt dokumentiert.Many new intrinsic functions have been added, and many previously undocumented intrinsics are now documented.
  • Standardmäßig löst jeder fehlgeschlagene Aufruf von „New“ (Neu) eine Ausnahme aus.By default, any call to new that fails will throw an exception.
  • Die Compileroptionen /ML und /MLd wurden entfernt./ML and /MLd compiler options have been removed. Visual C++ unterstützt nicht mehr die statisch verknüpfte Singlethread-CRT-Bibliothek.Visual C++ no longer supports single-threaded, statically linked CRT library support.
  • Mit dem Compiler wird die Optimierung von benannten Rückgabewerten implementiert, die aktiviert wird, wenn Sie mit /O1, /O2 (Größe minimieren, Geschwindigkeit maximieren), /Og (globale Optimierung) und /Ox (Komplette Optimierung) kompiliert werden.The compiler implemented the Named Return Value Optimization, which is enabled when you compile with /O1, /O2 (Minimize Size, Maximize Speed), /Og (Global Optimizations), and /Ox (Full Optimization).
  • Die /Oa-Compileroption wurde entfernt und wird stillschweigend ignoriert. Verwenden Sie die Modifizierer noalias oder restrict__declspec, um anzugeben, wie der Compiler beim Aliasing vorgeht./Oa compiler option has been removed but will be silently ignored; use the noalias or restrict__declspec modifiers to specify how the compiler does aliasing.
  • Die /Op-Compileroption wurde entfernt./Op compiler option had been removed. Verwenden Sie stattdessen /fp (Gleitkommaverhalten festlegen).Use /fp (Specify Floating-Point Behavior) instead.
  • „OpenMP“ wird jetzt von Visual C++ unterstützt.OpenMP is now supported by Visual C++.
  • Die /openmp-Compileroption (Aktivieren der OpenMP 2.0-Unterstützung) wurde hinzugefügt./openmp (Enable OpenMP 2.0 Support) compiler option has been added.
  • Die /Ow-Compileroption wurde entfernt und wird stillschweigend ignoriert./Ow compiler option has been removed but will be silently ignored. Verwenden Sie die Modifizierer noalias oder restrict__declspec, um festzulegen, wie der Compiler beim Aliasing vorgehen soll.Use the noalias or restrict__declspec modifiers to specify how the compiler does aliasing.

Profilgesteuerte Optimierungen (PGO)Profile-Guided Optimizations

  • /QI0f wurde entfernt./QI0f has been removed.
  • /QIfdiv wurde entfernt./QIfdiv has been removed.
  • Die /QIPF_B-Compileroption (Errata für B-CPU-Stepping) wurde hinzugefügt./QIPF_B (Errata for B CPU Stepping) compiler option has been added.
  • Die /QIPF_C-Compileroption (Errata für C-CPU-Stepping) wurde hinzugefügt./QIPF_C (Errata for C CPU Stepping) compiler option has been added.
  • Die /QIPF_fr32-Compileroption (Obere 96 Gleitkommaregister nicht verwenden) wurde hinzugefügt./QIPF_fr32 (Do Not Use Upper 96 Floating Point Registers) compiler option has been added.
  • Die /QIPF_noPIC-Compileroption (Erzeugen von positionsabhängigem Code) wurde hinzugefügt./QIPF_noPIC (Generate Position Dependent Code) compiler option has been added.
  • Die /QIPF_restrict_plabels-Compileroption (Annahme, dass keine Funktionen während der Laufzeit erstellt werden) wurde hinzugefügt./QIPF_restrict_plabels (Assume No Functions Created at Run Time) compiler option has been added.

Unicode-Unterstützung im Compiler und LinkerUnicode Support in the Compiler and Linker

  • Mithilfe von /vd (Konstruktionsverschiebungen deaktivieren) können Sie jetzt den dynamic_cast-Operator beim Erstellen eines Objekts hinzufügen (/vd2)./vd (Disable Construction Displacements) now allows you to use dynamic_cast Operator on an object being constructed (/vd2)
  • Die /YX-Compileroption wurde entfernt./YX compiler option has been removed. Verwenden Sie stattdessen /Yc (Vorkompilierte Headerdatei erstellen) oder /Yu (Vorkompilierte Headerdatei verwenden).Use /Yc (Create Precompiled Header File) or /Yu (Use Precompiled Header File) instead. Wenn Sie /YX aus Ihren Buildkonfigurationen entfernen und nicht ersetzen, können dadurch die Buildvorgänge beschleunigt werden.If you remove /YX from your build configurations and replace it with nothing, it can result in faster builds.
  • /Zc:forScope ist jetzt standardmäßig aktiviert./Zc:forScope is now on by default.
  • /Zc:wchar_t ist jetzt standardmäßig aktiviert./Zc:wchar_t is now on by default.
  • Die /Zd-Compileroption wurde entfernt./Zd compiler option has been removed. Debugginginformationen für ausschließlich Zeilennummern werden nicht mehr unterstützt.Line-number only debugging information is no longer supported. Verwenden Sie stattdessen /Zi. Weitere Informationen finden Sie unter /Z7, /Zi, /ZI (Debuginformationsformat).Use /Zi instead (see /Z7, /Zi, /ZI (Debug Information Format) for more information).
  • /Zg ist jetzt nur noch für C-Quellcodedateien und nicht für C++-Quellcodedateien verfügbar./Zg is now only valid on C source code files, and not on C++ source code files.
  • Die /Zx-Compileroption (Optimierten Itaniumcode debuggen) wurde hinzugefügt./Zx (Debug Optimized Itanium Code) compiler option has been added.

Neue SprachfeaturesNew Language Features

  • Das attribute-Attribut ist jetzt als veraltet markiert.The attributeattribute is now deprecated.
  • Der appdomain__declspec-Modifizierer wurde hinzugefügt.appdomain__declspec modifier has been added.
  • Die __clrcall-Aufrufkonvention wurde hinzugefügt.__clrcall calling convention has been added.
  • Mithilfe des veralteten (C++) declspec-Modifizierers können Sie jetzt eine Zeichenfolge angeben, die zur Kompilierzeit angezeigt wird, wenn ein Benutzer auf eine veraltete Klasse oder Funktion zugreifen will.deprecated (C++) declspec modifier now allows you to specify a string that will be displayed at compile time, when a user tries to access a deprecated class or function.
  • dynamic_cast Der Operator weist wichtige Änderungen auf.dynamic_cast Operator has breaking changes.
  • Mithilfe von nativen Enumerationen können Sie jetzt den zugrunde liegenden Typ angeben.Native enums now allow you to specify the underlying type.
  • Der jitintrinsicdeclspec-Modifizierer wurde hinzugefügt.jitintrinsicdeclspec modifier has been added.
  • Der noaliasdeclspec-Modifizierer wurde hinzugefügt.noaliasdeclspec modifier has been added.
  • Der process__declspec-Modifizierer wurde hinzugefügt.process__declspec modifier has been added.
  • abstract, override und sealed können für die native Kompilierung verwendet werden.abstract, override, and sealed are valid for native compilations.
  • __restrict Das Schlüsselwort wurde hinzugefügt.__restrict keyword has been added.
  • Der restrictdeclspec-Modifizierer wurde hinzugefügt.restrictdeclspec modifier has been added.
  • __thiscall ist jetzt ein Schlüsselwort.__thiscall is now a keyword.
  • __unaligned Das Schlüsselwort ist jetzt dokumentiert.__unaligned keyword is now documented.
  • volatile (C++) hat in Bezug auf Optimierungen ein aktualisiertes Verhalten.volatile (C++) has updated behavior with respect to optimizations.

Neue PräprozessorfeaturesNew Preprocessor Features

  • Das vordefinierte __CLR_VER-Makro wurde hinzugefügt.__CLR_VER predefined macro added.
  • Das comment-Pragma (C/C++) akzeptiert jetzt /MANIFESTDEPENDENCY als Linkerkommentar.The comment (C/C++) pragma now accepts /MANIFESTDEPENDENCY as a linker comment. Die exestr-Kommentarfunktion wurde als veraltet markiert.The exestr option to comment is now deprecated.
  • Das embedded_idl-Attribut (#import-Anweisung) verwendet jetzt einen optionalen Parameter.embedded_idl attribute (The #import Directive) now takes an optional parameter.
  • fenv_access-Pragmafenv_access pragma
  • float_control-Pragmafloat_control pragma
  • fp_contract-Pragmafp_contract pragma
  • Globale Variablen werden nicht in der Reihenfolge initialisiert, in der sie deklariert werden, wenn Sie über globale Variablen in von Pragma verwalteten bzw nicht von Pragma verwalteten und nicht verwalteten Abschnitten verfügen.Global variables will not be initialized in the order they are declared if you have global variables in pragma managed, unmanaged and unmanaged sections. Dabei handelt es sich um eine möglicherweise bedeutungsvolle Änderung. Beispielsweise wird eine nicht verwaltete globale Variable mit verwalteten globalen Variablen initialisiert und ein vollständig konstruiertes verwaltetes Objekt ist erforderlich.This is a potential breaking change if, for example, an unmanaged global variable is initialized with a managed global variables, and a fully constructed managed object is required.
  • Mit „init_seg“ festgelegte Abschnitte sind jetzt schreibgeschützt und können nicht wie in den Vorgängerversionen bearbeitet werden.Sections specified with init_seg are now read only, and not read/write as in previous versions.
  • Der inline_depth-Standard ist jetzt 16.inline_depth default is now 16. Der Standard von 16 galt auch in Visual C++ .NET 2003.A default of 16 was also in effect in Visual C++ .NET 2003.
  • Das vordefinierte _INTEGRAL_MAX_BITS-Makro wurde hinzugefügt. Weitere Informationen finden Sie unter „Predefined Macros (Vordefinierte Makros)“._INTEGRAL_MAX_BITS predefined macro added, see Predefined Macros.
  • Die vordefinierten Makros „_M_CEE“, „_M_CEE_PURE“ und „_M_CEE_SAFE“ wurden hinzugefügt. Weitere Informationen finden Sie unter „Predefined Macros (Vordefinierte Makros)“._M_CEE, _M_CEE_PURE, and _M_CEE_SAFE predefined macros added, see Predefined Macros.
  • Das vordefinierte _M_IX86_FP-Makro wurde hinzugefügt._M_IX86_FP predefined macro added.
  • Das vordefinierte _M_X64-Makro wurde hinzugefügt._M_X64 predefined macro added.
  • make_public-Pragmamake_public pragma
  • Die Pragmasyntax managed,unmanaged wurde aktualisiert und verfügt jetzt über push und pop.managed, unmanaged pragma syntax updated (now has push and pop)
  • Auf „mscorlib.dll“ wird jetzt implizit von der #using-Anweisung in sämtlichen /clr-Kompilierungen verwiesen.mscorlib.dll is now implicitly referenced by The #using Directive in all /clr compilations.
  • Das vordefinierte _OPENMP-Makro wurde hinzugefügt._OPENMP predefined macro added.
  • „optimize“-Pragma wurde aktualisiert, „a“ und „w“ gelten nicht mehr als gültige Parameter.optimize pragma has been updated, a and w are no longer valid parameters.
  • Das no_registry#import-Attribut wurde hinzugefügt.no_registry#import attribute has been added.
  • Die Pragmas region und endregion wurden hinzugefügt.region, endregion pragmas added
  • Das vordefinierte _VC_NODEFAULTLIB-Makro wurde hinzugefügt._VC_NODEFAULTLIB predefined macro added.
  • Variadic-Makros sind jetzt implementiert.Variadic Macros are now implemented.
  • vtordisp ist veraltet und wird in einem der nächsten Releases von Visual C++ entfernt.vtordisp is deprecated and will be removed in a future release of Visual C++.
  • Das warning-Pragma verfügt jetzt über den suppress-Spezifizierer.The warning pragma now has the suppress specifier.

Neue Linker-FeaturesNew Linker Features

  • Module (MSIL-Ausgabedateien, die keiner Assembly angehören) sind jetzt als Eingabe für den Linker zulässig.Modules (non-assembly MSIL output files) are now allowed as input to the linker.
  • Die /ALLOWISOLATION-Linkeroption (Manifestsuche) wurde hinzugefügt./ALLOWISOLATION (Manifest Lookup) linker option has been added.
  • /ASSEMBLYRESOURCE (Verwaltete Ressource einbetten) wurde aktualisiert, und Sie können jetzt den Namen der Ressource in der Assembly angeben und angeben, dass die Ressource privat ist./ASSEMBLYRESOURCE (Embed a Managed Resource) has been updated to now allow you to specify the name of the resource in the assembly, and to specify that the resource is private in the assembly.
  • Die /CLRIMAGETYPE-Linkeroption (Angeben des CLR-Bildtyps) wurde hinzugefügt./CLRIMAGETYPE (Specify Type of CLR Image) linker option has been added.
  • Die /CLRSUPPORTLASTERROR-Linkeroption (Letzten Fehlercode für PInvoke-Aufrufe beibehalten) wurde hinzugefügt./CLRSUPPORTLASTERROR (Preserve Last Error Code for PInvoke Calls) linker option has been added.
  • Die /CLRTHREADATTRIBUTE-Linkeroption (Festlegen des CLR-Threadattributs) wurde hinzugefügt./CLRTHREADATTRIBUTE (Set CLR Thread Attribute) linker option has been added.
  • Die /CLRUNMANAGEDCODECHECK-Linkeroption (SuppressUnmanagedCodeSecurityAttribute hinzufügen) wurde hinzugefügt./CLRUNMANAGEDCODECHECK (Add SuppressUnmanagedCodeSecurityAttribute) linker option has been added.
  • Die /ERRORREPORT-Linkeroption (Weiterleiten von internen Linkerfehlern) wurde hinzugefügt./ERRORREPORT (Report Internal Linker Errors) linker option has been added.
  • Die /EXETYPE-Linkeroption wurde entfernt./EXETYPE linker option has been removed. Der Linker unterstützt das Erstellen von Gerätetreibern für Windows 95 und Windows 98 nicht mehr.The linker no longer supports creating Windows 95 and Windows 98 device drivers. Verwenden Sie eine geeignete DDK zum Erstellen dieser Gerätetreiber.Use an appropriate DDK to create these device drivers. Das EXETYPE-Schlüsselwort ist für Moduldefinitionsdateien nicht mehr gültig.The EXETYPE keyword is no longer valid for module definition files.
  • Die /FUNCTIONPADMIN-Linkeroption (Erstellen eines Hotpatch-fähigen Images) wurde hinzugefügt./FUNCTIONPADMIN (Create Hotpatchable Image) linker option has been added.
  • Die /LTCG-Linkeroption wird jetzt für mit /clr kompilierten Modulen unterstützt./LTCG linker option is now supported on modules compiled with /clr. /LTCG wurde außerdem aktualisiert, um die profilgesteuerte Optimierung zu unterstützen./LTCG has also been updated to support profile-guided optimizations.
  • Die /MANIFEST-Linkeroption (Paralleles Assemblymanifest erstellen) wurde hinzugefügt./MANIFEST (Create Side-by-Side Assembly Manifest) linker option has been added.
  • Die /MANIFESTDEPENDENCY-Linkeroption (Manifestabhängigkeiten angeben) wurde hinzugefügt./MANIFESTDEPENDENCY (Specify Manifest Dependencies) linker option has been added.
  • Die /MANIFESTFILE-Linkeroption (Benennen der Manifestdatei) wurde hinzugefügt./MANIFESTFILE (Name Manifest File) linker option has been added.
  • Die /MAPINFO:LINES-Linkeroption wurde entfernt./MAPINFO:LINES linker option has been removed.
  • Die /NXCOMPAT-Linkeroption (Kompatibel mit der Datenausführungsverhinderung) wurde hinzugefügt./NXCOMPAT (Compatible with Data Execution Prevention) linker option has been added.
  • Die /PGD-Linkeroption (Datenbank für profilgesteuerte Optimierungen festlegen) wurde hinzugefügt./PGD (Specify Database for Profile-Guided Optimizations) linker option has been added.
  • Die /PROFILE-Linkeroption (Leistungstoolsprofiler) wurde hinzugefügt./PROFILE (Performance Tools Profiler) linker option has been added.
  • Die /SECTION-Linkeroption (Abschnittsattribute festlegen) unterstützt jetzt zwar die Attributnegation, aber die Attribute „L“ oder „D“ (VxD-bezogen) werden nicht mehr unterstützt./SECTION (Specify Section Attributes) linker option now supports attribute negation and no longer supports the L or D (VxD-related) attributes.
  • Unicode-Unterstützung im Compiler und LinkerUnicode Support in the Compiler and Linker
  • Die /VERBOSE-Linkeroption (Meldungen zum Ausgabefortschritt) akzeptiert jetzt auch ICF und REF./VERBOSE (Print Progress Messages) linker option now also accepts ICF and REF.
  • Die /VXD-Linkeroption wurde entfernt./VXD linker option has been removed. Der Linker unterstützt das Erstellen von Gerätetreibern für Windows 95 und Windows 98 nicht mehr.The linker no longer supports creating Windows 95 and Windows 98 device drivers. Verwenden Sie eine geeignete DDK zum Erstellen dieser Gerätetreiber.Use an appropriate DDK to create these device drivers. Das VXD-Schlüsselwort ist für Moduldefinitionsdateien nicht mehr gültig.The VXD keyword is no longer valid for module definition files.
  • Die /WS-Linkeroption wurde entfernt./WS linker option has been removed. /WS wurde verwendet, um Images zu verändern, die von Windows NT 4.0 als Ziel verwendet werden./WS was used to modify images targeted for Windows NT 4.0. „IMAGECFG.exe“: Anstelle von /WS können jetzt R-Dateinamen verwendet werden.IMAGECFG.exe -R filename can be used instead of /WS. „IMAGECFG.exe“ befindet sich jetzt auf der Windows NT 4.0 CD-ROM in „SUPPORT\DEBUG\I386\IMAGECFG.EXE“.IMAGECFG.exe can be found on the Windows NT 4.0 CD-ROM in SUPPORT\DEBUG\I386\IMAGECFG.EXE.
  • Die /WX-Linkeroption (Linkerwarnungen als Fehler behandeln) wird jetzt dokumentiert./WX (Treat Linker Warnings as Errors) linker option is now documented.

Neue Features des Linker-HilfsprogrammsNew Linker Utility Features

  • Die /ALLOWISOLATION-editbin-Option wurde hinzugefügt./ALLOWISOLATION editbin option had been added
  • Die DESCRIPTION-Moduldefinitionsanweisungen für Dateien wurde entfernt.DESCRIPTION module definition file statement is removed. Der Linker unterstützt das Erstellen von virtuellen Gerätetreibern nicht mehr.The linker no longer supports building virtual device drivers.
  • Die /ERRORREPORT-Option wurde zu „bscmake.exe“, „dumpbin.exe“, „editbin.exe“ und „lib.exe“ hinzugefügt./ERRORREPORT option has been added to bscmake.exe, dumpbin.exe, editbin.exe, and lib.exe.
  • Die /LTCG-Liboption wurde hinzugefügt./LTCG lib option has been added.
  • Die /NXCOMPAT-editbin-Liboption wurde hinzugefügt./NXCOMPAT editbin option has been added.
  • Die /RANGE-dumpbin-Option wurde hinzugefügt./RANGE dumpbin option has been added.
  • Die /TLS-dumpbin-Option wurde hinzugefügt./TLS dumpbin option has been added.
  • Die /WS-editbin-Option wurde entfernt./WS editbin option has been removed. /WS wurde verwendet, um Images zu verändern, die von Windows NT 4.0 als Ziel verwendet werden./WS was used to modify images targeted for Windows NT 4.0. „IMAGECFG.exe“: Anstelle von /WS können jetzt R-Dateinamen verwendet werden.IMAGECFG.exe -R filename can be used instead of /WS. „IMAGECFG.exe“ befindet sich jetzt auf der Windows NT 4.0 CD-ROM in „SUPPORT\DEBUG\I386\IMAGECFG.EXE“.IMAGECFG.exe can be found on the Windows NT 4.0 CD-ROM in SUPPORT\DEBUG\I386\IMAGECFG.EXE.
  • Die /WX[:NO]-lib-Option wurde hinzugefügt./WX[:NO] lib option has been added.

Neue NMAKE-FeaturesNew NMAKE Features

  • /ERRORREPORT wurde hinzugefügt./ERRORREPORT has been added.
  • /G wurde hinzugefügt./G has been added.
  • Die vordefinierten Regeln wurden aktualisiert.The predefined rules have been updated.
  • Das $(MAKE)-Makro, das in Rekursionsmakros dokumentiert wird, gibt jetzt den vollständigen Pfad zu „nmake.exe“ an.The $(MAKE) macro, which is documented in Recursion Macros, now gives the full path to nmake.exe.

Neue MASM-FeaturesNew MASM Features

  • MASM-Ausdrücke sind jetzt 64-Bit-Werte.MASM expressions are now 64-bit values. In Vorgängerversionen hat es sich bei den MASM-Ausdrücken um 32-Bit-Werte gehandelt.In previous versions MASM expressions were 32-bit values.
  • Die Anweisung „__asm int 3“ bewirkt jetzt, dass eine Funktion in nativen Code kompiliert wird.The instruction __asm int 3 now causes a function to be compiled to native.
  • ALIAS (MASM) wird jetzt dokumentiert.ALIAS (MASM) is now documented.
  • Die /ERRORREPORT-Optionen „ml.exe“ und „ml64.exe“ wurden hinzugefügt./ERRORREPORT ml.exe and ml64.exe option is added.
  • .FPO wird jetzt dokumentiert..FPO is now documented.
  • „H2INC.exe“ wird in Visual C++ 2005 nicht veröffentlicht.H2INC.exe will not ship in Visual C++ 2005. Wenn Sie „H2INC“ weiterhin verwenden müssen, verwenden Sie „H2INC.exe“ aus einer Vorgängerversion von Visual C++.If you need to continue to use H2INC, use H2INC.exe from a previous version of Visual C++.
  • Operator IMAGEREL wurde hinzugefügt.operator IMAGEREL has been added.
  • Operator HIGH32 wurde hinzugefügt.operator HIGH32 has been added.
  • Operator LOW32 wurde hinzugefügt.operator LOW32 has been added.
  • „ml64.exe“ ist eine Version von MASM für die x64-Architektur.ml64.exe is a version of MASM for the x64 architecture. Die Datei fasst x64-ASM-Dateien in x64-Objektdateien zusammen.It assembles x64 .asm files into x64 object files. Die Inlineassemblysprache wird im x64-Compiler nicht unterstützt.Inline assembly language is not supported in the x64 compiler. Die folgenden MASM-Anweisung wurden für „ml64.exe“ (x64) hinzugefügt.The following MASM directives have been added for ml64.exe (x64):
  • .ALLOCSTACK.ALLOCSTACK
  • .ENDPROLOG.ENDPROLOG
  • .PUSHFRAME.PUSHFRAME
  • .PUSHREG.PUSHREG
  • .SAVEREG.SAVEREG
  • .SAVEXMM128.SAVEXMM128
  • Neben .SETFRAME wurde auch die PROC-Anweisung mit einer Syntax aktualisiert, die sich nur auf x64 bezieht..SETFRAME In addition, the PROC directive was updated with x64-only syntax.
  • Die MMWORD-Anweisung wurde hinzugefügt.MMWORD directive has been added
  • /omf (Befehlszeilenoption „ML.exe“) impliziert jetzt /c./omf (ML.exe command line option) now implies /c. „ML.exe“ unterstützt nicht die Verknüpfung von OMF-Formatobjekten.ML.exe does not support linking OMF format objects.
  • Die SEGMENT-Anweisung unterstützt jetzt zusätzliche Attribute.The SEGMENT directive now supports additional attributes.
  • Der Operator SECTIONREL wurde hinzugefügt.operator SECTIONREL has been added.
  • Die XMMWORD-Anweisung wurde hinzugefügt.XMMWORD directive has been added

Neue CRT-FeaturesNew CRT Features

  • Sichere Versionen verschiedener Funktionen wurden hinzugefügt.Secure versions of several functions have been added. Diese Funktionen bieten eine verbesserte Möglichkeit zur Verarbeitung von Fehlern und erzwingen strenge Kontrollen für Puffer, um häufig auftretende Sicherheitsmängel zu vermeiden.These functions handle errors in a better way and enforce stricter controls on buffers to help avoid common security flaws. Die neuen sicheren Versionen werden durch das Suffix _s markiert.The new secure versions are identified by the _s suffix.
  • Vorhandene Versionen vieler Funktionen mit geringerer Sicherheit wurden als veraltet gekennzeichnet.Existing less secure versions of many functions have been deprecated. Definieren Sie „_CRT_SECURE_NO_WARNINGS“, um die Ablaufwarnungen zu deaktivieren.To disable the deprecation warnings, define _CRT_SECURE_NO_WARNINGS.
  • Viele bereits vorhandene Funktionen überprüfen jetzt ihre jeweiligen Parameter und rufen den ungültigen Parameterhandler auf, wenn ein ungültiger Parameter übergeben wird.Many existing functions now validate their parameters and invoke the invalid parameter handler when an invalid parameter is passed.
  • Viele bereits vorhandene Funktionen legen jetzt an neuen Stellen errno fest.Many existing functions now set errno where they did not before.
  • Die Typdefinition errno_t wurde zusammen mit einem Typinteger hinzugefügt.The typedef errno_t with type integer was added. errno_t wird immer dann verwendet, wenn ein Rückgabetyp oder ein Parameter einer Funktion Fehlercodes von errno verarbeitet.errno_t is used whenever a function return type or parameter deals with error codes from errno. errno_t ersetzt errcode.errno_t replaces errcode.
  • Es gibt jetzt Versionen von gebietsschemaabhängigen Funktionen, die das Gebietsschema als Parameter anstelle des aktuellen Gebietsschemas verwenden.Locale-dependent functions now have versions which take the locale as a parameter rather than using the current locale. Diese neuen Funktionen haben das Suffix _l.These new functions have the _l suffix. Es wurden einige neue Funktionen hinzugefügt, die mit Gebietsschemaobjekten zusammenarbeiten.Several new functions were added to work with locale objects. Die neuen Funktionen _get_current_locale, _create_locale und _free_locale wurden hinzugefügt.New functions include _get_current_locale, _create_locale and _free_locale.
  • Neue Funktionen wurden hinzugefügt, um das Sperren und Entsperren von Dateihandles zu unterstützen.New functions were added to support locking and unlocking file handles.
  • Die _spawn-Familie der Funktionen setzt „errno“ nicht wie in früheren Versionen erfolgreich auf 0 (null) zurück.The _spawn family of functions does not reset errno to zero on success, as it did in previous versions.
  • Versionen der printf-Familie der Funktionen sind verfügbar, mit deren Hilfe Sie die Reihenfolge festlegen können, in der die Argumente verwendet werden sollen.Versions of the printf family of functions that allow you to specify the order in which the arguments are used are available.
  • Das Textformat „Unicode“ wird jetzt unterstützt.Unicode is now a supported text format. Die Funktion _open unterstützt die Attribute „_O_TEXTW“, „_O_UTF8“ und „_O_UTF16“.The function _open supports _O_TEXTW, _O_UTF8 and _O_UTF16 attributes. Die fopen-Funktion unterstützt die Methode „ccs=ENCODING“ zum Angeben eines Unicode-Formats.The fopen function supports the "ccs=ENCODING" method of specifying a Unicode format.
  • Eine neue Version der CRT-Bibliotheken, die in verwaltetem Code erstellt werden, ist jetzt verfügbar und wird verwendet, wenn mit der/clr-Option (Common Language Runtime-Kompilierung) ein Kompilierungsvorgang durchgeführt wird.A new version of the CRT libraries built in managed code (MSIL) is now available and is used when compiling with the /clr (Common Language Runtime Compilation) option.
  • „_fileinfo“ wurde entfernt._fileinfo has been removed.
  • time_t hat jetzt standardmäßig eine Größe von 64 Bit. Dadurch wird der Bereich von time_tund einigen weiteren Zeitfunktionen bis ins Jahr 3000 ausgeweitet.The default size for time_t is now 64 bits, which expands the range of time_t and several of the time functions out to the year 3000.
  • CRT unterstützt jetzt das Festlegen eines Gebietsschemas auf Threadbasis.The CRT now supports setting the locale on a per thread basis. Die _configthreadlocale-Funktion wurde hinzugefügt, um dieses Feature zu unterstützten.The function _configthreadlocale was added to support this feature.
  • Die Funktionen _statusfp2 und __control87_2 wurden hinzugefügt, um Zugriff auf und Kontrolle über das Gleitkommasteuerwort auf dem x87- und SSE2-Gleitkommaprozessor zu gewähren.The _statusfp2 and __control87_2 functions were added to allow access to and control of the floating point control word on both the x87 and SSE2 floating point processor.
  • Die Funktionen _mkgmtime und _mkgmtime64 wurden hinzugefügt, um Unterstützung für die Konvertierung der Zeitangaben (tm-Struktur) in Greenwich Mean Time (GMT) bereitzustellen.The _mkgmtime and _mkgmtime64 functions were added to provide support for converting times (struct tm) to Greenwich Mean Time (GMT).
  • An swprintf und vswprintf wurden Änderungen vorgenommen, um die Standards einzuhalten.Changes were made to swprintf and vswprintf to better conform with the standard.
  • Über eine neue Headerdatei (INTRIN.H) werden Prototypen für einige intrinsische Funktionen bereitgestellt.A new header file, INTRIN.H, provides prototypes for some intrinsic functions.
  • Die fopen-Funktion verfügt jetzt über ein N-Attribut.The fopen function now has an N attribute.
  • Die _open-Funktion verfügt jetzt über ein _O_NOINHERIT-Attribut.The _open function now has an _O_NOINHERIT attribute.
  • Die atoi-Funktion gibt jetzt „INT_MAX“ zurück und legt im Falle eines Überlaufs errno auf „ERANGE“ fest.The atoi function now returns INT_MAX and sets errno to ERANGE on overflow. In früheren Versionen war das Überlaufverhalten nicht definiert.In previous versions, the overflow behavior was undefined.
  • Die printf-Familie unterstützt die Ausgabe von Hexadezimalgleitkommawerten, die gemäß dem ANSI C99-Standard mithilfe der Formattypspezifizierer „%a“ und „%A“ implementiert wurden.The printf family of functions supports hexadecimal floating point output implemented according to the ANSI C99 standard using the format type specifiers %a and %A.
  • Die printf-Familie unterstützt jetzt das Größenpräfix „ll“ (long long).The printf family now supports the "ll" (long long) size prefix.
  • Die _controlfp-Funktion wurde optimiert, um die Leistung zu verbessern.The _controlfp function has been optimized for better performance.
  • Debugversionen einiger Funktionen wurden hinzugefügt.Debug versions of some functions have been added.
  • _chgsignl und _cpysignlwurden hinzugefügt (long double-Versionen).Added _chgsignl and _cpysignl (long double versions).
  • Der _locale_t-Typ wurde der Typtabelle hinzugefügt.Added _locale_t type to type table.
  • Das neue _countof-Makro wurde zur Berechnungen der Anzahl der Elemente in einem Array hinzugefügt.New macro _countof Macro added for computing number of elements in an array.
  • Zu jedem Funktionsthema wurde ein Abschnitt zu .NET Framework-Äquivalenten hinzugefügt.In each function topic, a section on .NET Framework equivalents has been added.
  • Mehrere Zeichen folgen Funktionen haben jetzt die Möglichkeit, Zeichen folgen zu kürzen, anstatt einen Fehler zu haben, wenn Ausgabepuffer zu klein sind. siehe _TRUNCATE.Several string functions now have the option of truncating strings rather than failing when output buffers are too small; see _TRUNCATE.
  • _set_se_translator erfordert jetzt die Verwendung der /EHa-Compileroption._set_se_translator now requires the use of the /EHa compiler option.
  • fpos_t befindet sich jetzt __int64 unter /Za (für C-Code) und wenn stdc manuell festgelegt wird (für C++-Code).fpos_t is now __int64 under /Za (for C code) and when STDC is set manually (for C++ code). Dabei handelt es sich um eine struct .It used to be a struct.
  • „_CRT_DISABLE_PERFCRIT_LOCKS“ kann die E/A-Leistung von Programmen mit einem Thread verbessern._CRT_DISABLE_PERFCRIT_LOCKS can improve the I/O performance of single-threaded programs.
  • POSIX-Namen wurden als veraltet markiert und durch ISO-konforme C++-Namen ersetzt (verwenden Sie z.B. _getch anstelle von getch).POSIX names have been deprecated in favor of ISO C++ conformant names (for example, use _getch rather than getch).
  • Neue Linkoptionen für OBJ-Dateien sind im reinen Modus verfügbar.New link options .obj files are available for pure mode
  • _recalloc kombiniert Features von realloc und calloc._recalloc combines features of realloc and calloc.

Neuerungen bei C++ in Visual Studio 2003What's New for C++ in Visual Studio 2003

CompilerCompiler

  • Informationen zum Ausführen einer Managed Extensions for C++-Anwendung, die mit dem Compiler der aktuellen Version für eine Vorgängerversion der Runtime erstellt wird.Information on how to run a Managed Extensions for C++ application built with the current version's compiler on a previous version of the runtime.
  • Häufig gestellte Fragen: Managed Extensions for C++Managed Extensions for C++ Frequently Asked Questions.
  • Eine exemplarische Vorgehensweise wurde hinzugefügt, um darzustellen, wie eine bereits vorhandene native Anwendung für die Verwendung von Managed Extensions for C++ portiert wird (Walkthrough: Porting an Existing Native C++ Application to Interoperate with .NET Framework Components (Exemplarische Vorgehensweise: Portieren einer bereits vorhandenen nativen C++-Anwendung zur Zusammenarbeit mit .NET Framework-Komponenten)).A walkthrough has been added showing how to port an existing, native application to use Managed Extensions for C++: Walkthrough: Porting an Existing Native C++ Application to Interoperate with .NET Framework Components.
  • Sie können jetzt einen Delegat für eine Methode eines Werttypen erstellen.You can now create a delegate on a method of a value type.
  • Die Konformität des Compilers mit dem C++-Standard wurde für Visual C++ .NET 2003 deutlich verbessert.The compiler's conformance with the C++ standard has been significantly enhanced for Visual C++ .NET 2003.
  • Die /arch-Compileroption wurde hinzugefügt./arch compiler option is added.
  • /Gf ist als veraltet markiert und wird mit der nächsten Visual C++-Version entfernt./Gf is deprecated and will be removed in the next version of Visual C++.
  • Die /G7-Compileroption wurde hinzugefügt./G7 compiler option is added.
  • Die /GS-Compileroption wurde erweitert, um die lokalen Variablen vor direkten Pufferüberläufen zu schützen.The /GS compiler option has been enhanced to help protect local variables from direct buffer overruns.
  • Die /noBool-Compileroption wurde entfernt.The /noBool compiler option has been removed. Der Compiler erlaubt jetzt bool , nur als Schlüsselwort (und nicht als Bezeichner) in einer C++-Quell Code Datei zu erscheinen.The compiler now allows bool to appear only as a keyword (and not an identifier) in a C++ source code file.
  • Der- long long Typ ist nun als verfügbar typedef __int64 . Beachten Sie, dass long long in der CRT noch keine Unterstützung für vorhanden ist.The long long type is now available as a typedef of __int64 Note that there is not yet support for long long in the CRT.
  • Die /Zm-Compileroption legt jetzt die maximale Speicherbelegung für den vorkompilierten Header fest.The /Zm compiler option now specifies the precompiled header memory allocation limit.
  • Die intrinsische _InterlockedCompareExchange-Funktion wird jetzt dokumentiert._InterlockedCompareExchange intrinsic now documented.
  • Die intrinsische _InterlockedDecrement-Funktion wird jetzt dokumentiert._InterlockedDecrement intrinsic now documented.
  • Die intrinsische _InterlockedExchange-Funktion wird jetzt dokumentiert._InterlockedExchange intrinsic now documented.
  • Die intrinsische _InterlockedExchangeAdd-Funktion wird jetzt dokumentiert._InterlockedExchangeAdd intrinsic now documented.
  • Die intrinsische _InterlockedIncrement-Funktion wird jetzt dokumentiert._InterlockedIncrement intrinsic now documented.
  • Die intrinsische _ReadWriteBarrier-Funktion wurde hinzugefügt._ReadWriteBarrier intrinsic added.

AttributeAttributes

  • Das Attribut implements wird jetzt dokumentiert.implements attribute is now documented.

Linker-FeaturesLinker features

Die folgenden Linkerparameter wurden hinzugefügt:The following linker switches have been added:

  • /ASSEMBLYDEBUG/ASSEMBLYDEBUG
  • /ASSEMBLYLINKRESOURCE/ASSEMBLYLINKRESOURCE
  • DELAYSIGNDELAYSIGN
  • /KEYFILE/KEYFILE
  • /KEYCONTAINER/KEYCONTAINER
  • /SAFESEH/SAFESEH

MASMMASM

Das .SAFESEH-Verzeichnis und die /safeseh-ml.exe-Option wurden hinzugefügt.The .SAFESEH directive and /safeseh ml.exe option were added.

Weitere InformationenSee also

Visual C++-Handbuch: Portieren und AktualisierenVisual C++ Porting and Upgrading Guide