Visual C++ Nyheter 2003 till och med 2015

2025-05-29

Den här sidan samlar alla "Nyheter"-sidor för alla versioner av Visual C++ från Visual Studio 2015 tillbaka till 2003. Den här informationen tillhandahålls som en bekvämlighet om den kan vara användbar när du uppgraderar från tidigare versioner av Visual Studio.

Anmärkning

Information om den aktuella versionen av Visual Studio finns i Nyheter för Visual C++ i Visual Studio och Efterlevnadsförbättringar i Visual C++ i Visual Studio.

Nyheter för C++ i Visual Studio 2015

I Visual Studio 2015 och senare kan pågående förbättringar av kompilatorefterlevnad ibland ändra hur kompilatorn förstår din befintliga källkod. När detta inträffar kan det uppstå nya eller olika fel under bygget, eller till och med beteendeskillnader i kod som tidigare skapats och som verkade köras korrekt.

Som tur är har dessa skillnader liten eller ingen inverkan på de flesta av källkoden och när källkoden eller andra ändringar behövs för att åtgärda dessa skillnader är korrigeringarna vanligtvis små och raka. Vi har inkluderat många exempel på tidigare godtagbar källkod som kan behöva ändras (före) och korrigeringarna för att korrigera dem (efter).

Även om dessa skillnader kan påverka källkoden eller andra kompileringsartefakter påverkar de inte binär kompatibilitet mellan uppdateringar av Visual C++-versioner. En mer allvarlig typ av ändring, den brytande ändringen, kan påverka binär kompatibilitet, men sådana ändringar sker endast mellan huvudversioner av Visual C++. Till exempel mellan Visual C++ 2013 och Visual C++ 2015. Information om de icke-bakåtkompatibla ändringar som inträffade mellan Visual C++ 2013 och Visual C++ 2015 finns i Visual C++ ändringshistorik 2003 –2015.

Anpassningsförbättringar i Visual Studio 2015
Överensstämmelseförbättringar i Visual Studio 2015 Update 1
Överensstämmelseförbättringar i Visual Studio 2015 Update 2
Anpassningsförbättringar i Visual Studio 2015 Update 3

Anpassningsförbättringar i Visual Studio 2015

/Zc:forScope- alternativ

Kompilatoralternativet /Zc:forScope- är inaktuellt och tas bort i en framtida version.
```
  Command line warning  D9035: option 'Zc:forScope-' has been deprecated and will be removed in a future release
```
Alternativet användes vanligtvis för att tillåta icke-standardkod som använder loopvariabler efter den punkt där de enligt standarden borde ha gått utanför omfånget. Det var bara nödvändigt när du kompilerar med /Za alternativet eftersom det alltid är tillåtet att använda en för-loop-variabel efter slutet av loopen utan /Za. Om du inte bryr dig om standardefterlevnad (till exempel om koden inte är avsedd att vara portabel för andra kompilatorer) kan du inaktivera /Za alternativet (eller ange egenskapen Inaktivera språktillägg till Nej). Om du bryr dig om att skriva portabel, standardkonform kod bör du skriva om koden så att den överensstämmer med standarden genom att flytta deklarationen av sådana variabler till en punkt utanför loopen.
```
  // 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-kompilatoralternativ.

Kompilatoralternativet /Zg (Generera funktionsprototyper) är inte längre tillgängligt. Det här kompilatoralternativet var tidigare inaktuellt.
Du kan inte längre köra enhetstester med C++/CLI från kommandoraden med mstest.exe. Använd i stället vstest.console.exe
mutable-nyckelord.

Lagringsklassspecificeraren mutable tillåts inte längre på platser där den tidigare kompilerades utan fel. Nu ger kompilatorn felet C2071 (ogiltig lagringsklass). Enligt standarden kan den föränderliga specificeraren endast tillämpas på namn på klassdatamedlemmar och kan inte tillämpas på namn som deklarerats som const eller statiska och kan inte tillämpas på referensmedlemmar.

Tänk till exempel på följande kod:
```
  struct S {
      mutable int &r;
  };
```
Tidigare versioner av Microsoft C++-kompilatorn accepterade detta, men nu ger kompilatorn följande fel:
```
  error C2071: 'S::r': illegal storage class
```
Åtgärda felet genom att helt enkelt ta bort det redundanta mutable nyckelordet.
char_16_t och char32_t

Du kan inte längre använda char16_t eller char32_t som alias i en typedef eftersom dessa typer nu behandlas som inbyggda. Det var vanligt att användare och biblioteksförfattare definierade char16_t och char32_t som alias uint16_t för respektive uint32_t.
```
  #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;
  }
```
Om du vill uppdatera koden tar du bort deklarationerna typedef och byter namn på andra identifierare som kolliderar med dessa namn.
Mallparametrar som inte är av typen

Viss kod som omfattar mallparametrar som inte är av typen kontrolleras nu korrekt för typkompatibilitet när du anger explicita mallargument. Följande kod kompileras till exempel utan fel i tidigare versioner av 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>();
  }
```
Den nuvarande kompilatorn ger korrekt ett fel eftersom mallparametertypen inte stämmer överens med mallargumentet (det rör sig om en pekare till en konstant medlem, men funktionen f är inte konstant).
```
  error C2893: Failed to specialize function template 'void S2::f(void)'note: With the following template arguments:note: 'C=S1'note: 'Function=S1::f'
```
Om du vill åtgärda det här felet i koden kontrollerar du att typen av mallargument som du använder matchar mallparameterns deklarerade typ.
__declspec(align)

Kompilatorn accepterar inte längre __declspec(align) vid funktioner. Detta ignorerades alltid, men nu genererar det ett kompilatorfel.
```
  error C3323: 'alignas' and '__declspec(align)' are not allowed on function declarations
```
Åtgärda problemet genom att ta bort __declspec(align) från funktionsdeklarationen. Eftersom det inte hade någon effekt, att ta bort det ändrar ingenting.
Undantagshantering

Det finns ett par ändringar i undantagshantering. För det första måste undantagsobjekt vara antingen kopierbara eller flyttbara. Följande kod kompileras i Visual Studio 2013, men kompileras inte i Visual Studio 2015:
```
  struct S {
  public:
      S();
  private:
      S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Problemet är att kopieringskonstruktorn är privat, så objektet kan inte kopieras på samma sätt som vid normal hantering av ett undantag. Detsamma gäller när kopieringskonstruktorn deklareras explicit.
```
  struct S {
      S();
      explicit S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Om du vill uppdatera koden kontrollerar du att kopieringskonstruktorn för undantagsobjektet är offentlig och inte markerad explicit.

Att fånga ett undantag efter värde kräver också att undantagsobjektet kan kopieras. Följande kod kompileras i Visual Studio 2013, men kompileras inte i Visual Studio 2015:
```
  struct B {
  public:
      B();
  private:
      B(const B &);
  };

  struct D : public B {
  };

  int main()
  {
      try
      {
      }
      catch (D d) // error
      {
      }
  }
```
Du kan åtgärda det här problemet genom att ändra parametertypen för catch till en referens.
```
  catch(D& d)
  {
  }
```
Strängliteraler följda av makron

Kompilatorn stöder nu användardefinierade literaler. Därför tolkas strängliteraler följt av makron utan mellanliggande blanksteg som användardefinierade literaler, vilket kan ge fel eller oväntade resultat. I tidigare kompilatorer kompilerades till exempel följande kod:
```
  #define _x "there"
  char* func() {
      return "hello"_x;
  }
  int main()
  {
      char * p = func();
      return 0;
  }
```
Kompilatorn tolkade detta som en strängliteral "hello" följt av ett makro, som expanderas "där", och sedan sammanfogades de två strängliteralerna till en. I Visual Studio 2015 tolkar kompilatorn detta som en användardefinierad literal, men eftersom det inte finns någon matchande användardefinierad literal _x definierad ger den ett fel.
```
  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?
```
Åtgärda problemet genom att lägga till ett blanksteg mellan strängkonstanten och makrot.
Intilliggande strängliteraler

På samma sätt som i föregående, på grund av relaterade ändringar i strängparsning, tolkades angränsande strängliteraler (antingen breda eller smala teckensträngliteraler) utan blanksteg som en enda sammanfogad sträng i tidigare versioner av Visual C++. I Visual Studio 2015 måste du nu lägga till blanksteg mellan de två strängarna. Följande kod måste till exempel ändras:
```
  char * str = "abc""def";
```
Lägg bara till ett blanksteg mellan de två strängarna.
```
  char * str = "abc" "def";
```
Placering ny och ta bort

En ändring har gjorts i operatorn delete för att anpassa den till C++14-standarden. Information om standardändringen finns på C++ Size Deallocation. Ändringarna lägger till en form av den globala delete operatorn som tar en storleksparameter. Den icke-bakåtkompatibla ändringen är att om du tidigare använde en delete-operator med samma signatur (för att motsvara en placement new-operator) får du ett kompilatorfel (C2956, som inträffar vid den tidpunkt då placement new-operatorn används, eftersom det är positionen i koden där kompilatorn försöker identifiera en lämplig matchande delete-operator).

Funktionen void operator delete(void *, size_t) var en placement delete-operator som motsvarar placement new-funktionenvoid * operator new(size_t, size_t) i C++11. Med C++14-storleksfrigöring är den här delete-funktionen nu en vanlig frigöringsfunktion (global delete-operator). Standarden kräver att om användningen av en placement new söker upp en motsvarande delete funktion och hittar en vanlig frigöringsfunktion, är programmet felaktigt utformat.

Anta till exempel att koden definierar både en ny placering och en placeringsborttagning:
```
  void * operator new(std::size_t, std::size_t);
  void operator delete(void*, std::size_t) noexcept;
```
Problemet uppstår på grund av matchningen i funktionssignaturer mellan en placement delete-operator som du har definierat och den nya globale sized-operatorn . Fundera på om du kan använda en annan typ än size_t för någon placement new och delete-operatorer. Observera att typen av size_ttypedef är kompilatorberoende. Den är ett typedef för unsigned int i Visual C++. En bra lösning är att använda en uppräkningstyp som den här:
```
  enum class my_type : size_t {};
```
Ändra sedan definitionen av placering new och delete använd den här typen som det andra argumentet i stället för size_t. Du måste också uppdatera anropen till placement new för att skicka den nya typen (till exempel genom att använda static_cast<my_type> för att konvertera från heltalsvärdet) och uppdatera definitionen av new och delete för att kasta tillbaka till heltalstypen. Du behöver inte använda en enum för detta. En klasstyp med en size_t medlem fungerar också.

En alternativ lösning är att du kan eliminera placement new helt och hållet. Om koden använder en ny placering för att implementera en minnespool där placeringsargumentet är storleken på objektet som allokeras eller tas bort, kan funktionen för storleksfördelning vara lämplig för att ersätta din egen kod för den anpassade minnespoolen, och du kan bli av med placeringsfunktionerna och bara använda din egen tvåargumentsoperator delete i stället för placeringsfunktionerna.

Om du inte vill uppdatera koden omedelbart kan du återgå till det gamla beteendet med hjälp av kompilatoralternativet /Zc:sizedDealloc-. Om du använder det här alternativet, finns inte de tvåargumentsfunktionerna delete, och därför orsakar de ingen konflikt med din placeringsborttagningsoperator.
Unionsdatamedlemmar

Datamedlemmar i fackföreningar kan inte längre ha referenstyper. Följande kod kompilerades korrekt i Visual Studio 2013, men genererar ett fel i Visual Studio 2015.
```
  union U1 {
      const int i;
  };
  union U2 {
     int &i;
  };
  union U3 {
      struct {int &i;};
  };
```
Föregående kod genererar följande fel:
```
  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
```
Åtgärda problemet genom att ändra referenstyperna till en pekare eller ett värde. Om du ändrar typen till en pekare krävs ändringar i koden som använder union-fältet. Om du ändrar koden till ett värde ändras data som lagras i unionen, vilket påverkar andra fält eftersom fält i unionstyper delar samma minne. Beroende på värdets storlek kan det också ändra storleken på unionen.

Anonyma fackföreningar

är nu mer överensstämmande med standarden. Tidigare versioner av kompilatorn genererade en explicit konstruktor och destructor för anonyma fackföreningar. Dessa tas bort i Visual Studio 2015.

struct S {
    S();
};

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

Föregående kod genererar följande fel i 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

Lös problemet genom att ange egna definitioner av konstruktorn och/eller destruktor.

  struct S {
     // Provide a default constructor by adding an empty function body.
     S() {}
  };

  union {
     struct {
        S s;
     };
  } u;

Fackföreningar med anonyma structs

För att uppfylla standarden har körningsbeteendet ändrats för medlemmar i anonyma strukturer i fackföreningar. Konstruktorn för anonyma strukturmedlemmar i en union anropas inte längre implicit när en sådan union skapas. Dessutom kallas inte längre destruktorn för anonyma strukturmedlemmar i en union implicit när unionen går utanför sitt omfång. Tänk på följande kod, där en union U innehåller en anonym struktur som innehåller en medlem som är en namngiven struktur S som har en 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;
  }

I Visual Studio 2013 anropas konstruktorn för S när unionen skapas och destruktören för S anropas när stacken för funktionen f rensas. Men i Visual Studio 2015 anropas inte konstruktorn och destruktören. Kompilatorn varnar om den här beteendeändringen.

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

Om du vill återställa det ursprungliga beteendet ger du den anonyma strukturen ett namn. Körningsbeteendet för icke-anonyma strukturer är detsamma, oavsett kompilatorversion.

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

Alternativt kan du prova att flytta koden för konstruktorn och destruktorn till nya funktioner och lägga till anrop till dessa funktioner från konstruktorn och destruktorn för unionen.

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

Mallupplösning

Ändringar har gjorts i namnupplösning för mallar. I C++, när du överväger kandidater för lösning av ett namn, kan det vara så att ett eller flera namn som övervägs som potentiella matchningar skapar en ogiltig mallinstansiering. Dessa ogiltiga instansieringar orsakar normalt inte kompilatorfel, en princip som kallas SFINAE (ersättningsfel är inte ett fel).

Om SFINAE kräver att kompilatorn instansierar specialiseringen av en klassmall är nu eventuella fel som inträffar under den här processen kompilatorfel. I tidigare versioner skulle kompilatorn ignorera sådana fel. Tänk till exempel på följande kod:
```
  #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);
  }
```
Om du kompilerar med den aktuella kompilatorn får du följande fel:
```
  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
          ]
```
Detta beror på att klassen "D" ännu inte har definierats vid tidpunkten för den första anropet av is_base_of.

I det här fallet är korrigeringen inte att använda sådana typegenskaper förrän klassen har definierats. Om du flyttar definitionerna av B och D till början av kodfilen löses felet. Om definitionerna finns i huvudfiler kontrollerar du ordningen på include-instruktionerna för huvudfilerna för att se till att alla klassdefinitioner kompileras innan de problematiska mallarna används.
Kopia-konstruktorer

I både Visual Studio 2013 och Visual Studio 2015 genererar kompilatorn en kopieringskonstruktor för en klass om klassen har en användardefinierad flyttkonstruktor men ingen användardefinierad kopieringskonstruktor. I Dev14 är den här implicit genererade kopieringskonstruktorn också märkt "= delete".

Efterlevnadsförbättringar i Visual Studio 2015 Update 1

Privata virtuella basklasser och indirekt arv

Tidigare versioner av kompilatorn tillät en härledd klass att anropa medlemsfunktioner i dess indirekt härleddaprivate virtual basklasser. Det här gamla beteendet var felaktigt och överensstämmer inte med C++-standarden. Kompilatorn accepterar inte längre kod som skrivits på det här sättet och utfärdar kompilatorfel C2280 som ett resultat.

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

Exempel (före)

  class base
  {
  protected:
      base();
      ~base();
  };

  class middle: private virtual base {};class top: public virtual middle {};

  void destroy(top *p)
  {
      delete p;  //
  }

Exempel (efter)

  class base;  // as above

  class middle: protected virtual base {};
  class top: public virtual middle {};

  void destroy(top *p)
  {
      delete p;
  }

-eller-

  class base;  // as above

  class middle: private virtual base {};
  class top: public virtual middle, private virtual bottom {};

  void destroy(top *p)
  {
      delete p;
  }

Överlagrade operatorn new och operator delete

Tidigare versioner av kompilatorn tillät att icke-medlemsoperatorn new och icke-medlemsoperatorn delete kunde deklareras som statiska och i andra namnområden än det globala namnområdet. Det här gamla beteendet skapade en risk för att programmet inte skulle anropa den operatorimplementering new eller delete som programmeraren avsåg, vilket resulterade i tysta problem under körning. Kompilatorn accepterar inte längre kod som skrivits på det här sättet och utfärdar kompilatorfel C2323 i stället.
```
  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.
```
Exempel (före)
```
  static inline void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // error C2323
```
Exempel (efter)
```
  void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // removed 'static inline'
```
Även om kompilatorn inte ger någon specifik diagnostik anses den nya infogade operatorn vara dåligt utformad.
Anropar operatortyp()( användardefinierad konvertering) på icke-klasstyper Tidigare versioner av kompilatorn tillät " operatortyp()" att anropas på icke-klasstyper samtidigt som den ignoreras tyst. Det gamla beteendet skapade en risk för tyst felaktig kodgenerering, vilket resulterade i oförutsägbart exekveringsbeteende. Kompilatorn accepterar inte längre kod som skrivits på det här sättet och utfärdar kompilatorfel C2228 i stället.
```
  error C2228: left of '.operator type' must have class/struct/union
```
Exempel (före)
```
  typedef int index_t;

  void bounds_check(index_t index);

  void login(int column)
  {
      bounds_check(column.operator index_t());  // error C2228
  }
```
Exempel (efter)
```
  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'
  }
```
Redundant typename i utarbetade typspecificerare Tidigare versioner av kompilatorn tillåts typename i en utarbetad typspecificerare. Kod som skrivits på det här sättet är semantiskt felaktig. Kompilatorn accepterar inte längre kod som skrivits på det här sättet och utfärdar kompilatorfel C3406 i stället.
```
  error C3406: 'typename' cannot be used in an elaborated type specifier
```
Exempel (före)
```
  template <typename class T>
  class container;
```
Exempel (efter)
```
  template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case
  class container;
```

Skriv avdrag för matriser från en initialiserarlista Tidigare versioner av kompilatorn hade inte stöd för typavdrag av matriser från en initialiserarlista. Kompilatorn stöder nu den här typen av typavdrag och därför kan anrop till funktionsmallar som använder initieringslistor nu vara tvetydiga eller så kan en annan överbelastning väljas än i tidigare versioner av kompilatorn. För att lösa dessa problem måste programmet nu uttryckligen ange den överlagring som programmeraren avsåg.

När det här nya beteendet gör att överbelastningslösningen överväger ytterligare en kandidat som är lika bra som den historiska kandidaten blir anropet tvetydigt och kompilatorn utfärdar kompilatorfelet C2668 som ett resultat.

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

Exempel 1: Tvetydigt anrop till överbelastad funktion (före)

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

Exempel 1: tvetydigt anrop till överbelastad funktion (efter)

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

När det här nya beteendet gör att överbelastningslösningen överväger en ytterligare kandidat som är en bättre matchning än den historiska kandidaten, löser samtalet entydigt den nya kandidaten, vilket orsakar en förändring i programmets beteende som förmodligen skiljer sig från programmerarens avsedda.

Exempel 2: ändring i överlagringsupplösning (före)

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

Exempel 2: ändring i överbelastningslösning (efter)

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

Återställning av switch-instruktionsvarningar

En tidigare version av kompilatorn tog bort tidigare befintliga varningar relaterade till switch -instruktioner. Dessa varningar har nu återställts. Kompilatorn utfärdar nu de återställde varningarna och varningar relaterade till specifika fall (inklusive standardfallet) utfärdas nu på raden som innehåller det felaktiga ärendet, i stället för på den sista raden i switch-instruktionen. Som ett resultat av att dessa varningar nu utfärdas på andra rader än tidigare kan varningar som tidigare undertryckts med hjälp av #pragma warning(disable:####) inte längre undertryckas som man tänkt sig. För att förhindra dessa varningar som avsett kan det vara nödvändigt att flytta #pragma warning(disable:####) direktivet till en rad ovanför det första potentiellt stötande fallet. Följande är de återställde varningarna.

  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

Exempel på C4063 (före)

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

Exempel på C4063 (efter)

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

Exempel på andra återställde varningar finns i dokumentationen.

#include: användning av överordnad katalogspecificerare '..' i sökväg (påverkar /Wall/WXendast )

Tidigare versioner av kompilatorn identifierade inte användningen av den överordnade katalogspecificeraren .. i direktivens #include sökväg. Kod som skrivs på det här sättet är vanligtvis avsedd att innehålla rubriker som finns utanför projektet genom att felaktigt använda projektrelativa sökvägar. Det här gamla beteendet skapade en risk för att programmet kunde kompileras genom att inkludera en annan källfil än programmeraren avsåg, eller att dessa relativa sökvägar inte skulle vara portabla för andra byggmiljöer. Kompilatorn identifierar och meddelar nu programmeraren av kod som skrivits på det här sättet och utfärdar en valfri kompilatorvarning C4464, om den är aktiverad.
```
  warning C4464: relative include path contains '..'
```
Exempel (före)
```
  #include "..\headers\C4426.h"  // emits warning C4464
```
Exempel (efter)
```
  #include "C4426.h"  // add absolute path to 'headers\' to your project's include directories
```
Även om kompilatorn inte ger någon specifik diagnostik rekommenderar vi också att den överordnade katalogspecificeraren ".." ska användas för att ange projektets inkluderingskataloger.
#pragma optimize() sträcker sig bortom slutet av huvudfilen (påverkar endast /Wall/WX)

Tidigare versioner av kompilatorn identifierade inte ändringar i optimeringsflaggans inställningar som undflyr en rubrikfil som ingår i en översättningsenhet. Kompilatorn identifierar och meddelar nu programmeraren av kod som skrivits på det här sättet och utfärdar en valfri kompilatorvarning C4426 på platsen för den felaktiga #include, om den är aktiverad. Den här varningen utfärdas endast om ändringarna står i konflikt med de optimeringsflaggor som angetts av kommandoradsargument till kompilatorn.
```
  warning C4426: optimization flags changed after including header, may be due to #pragma optimize()
```
Exempel (före)
```
  // C4426.h
  #pragma optimize("g", off)
  ...
  // C4426.h ends

  // C4426.cpp
  #include "C4426.h"  // warning C4426
```
Exempel (efter)
```
  // 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"
```

Felmatchad #pragma warning(push) och #pragma warning(pop) (påverkar endast /Wall/WX)

Tidigare versioner av kompilatorn identifierade #pragma warning(push) inte tillståndsändringar som paras ihop med #pragma warning(pop) tillståndsändringar i en annan källfil, vilket sällan är avsett. Det här gamla beteendet skapade en risk för att programmet skulle kompileras med en annan uppsättning varningar aktiverade än programmeraren avsåg, vilket kan leda till tyst felaktigt körningsbeteende. Kompilatorn identifierar och meddelar nu programmeraren av kod som skrivits på det här sättet och utfärdar en valfri kompilatorvarning C5031 på platsen för matchande #pragma warning(pop), om den är aktiverad. Den här varningen innehåller en anteckning som refererar till platsen för motsvarande #pragma warning(push).

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

Exempel (före)

  // 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
  ...

Exempel (efter)

  // 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"
  ...

Även om det är ovanligt är kod skriven på det här sättet ibland avsiktlig. Kod som skrivs på det här sättet är känslig för ändringar i #include ordning. När det är möjligt rekommenderar vi att källkodsfiler hanterar varningstillståndet på ett självständigt sätt.

Omatchad #pragma varning(push) (påverkar endast /Wall/WX)

Tidigare versioner av kompilatorn identifierade inte omatchade tillståndsändringar #pragma warning(push) i slutet av en översättningsenhet. Kompilatorn identifierar nu och meddelar programmeraren om kod skriven på det här sättet och utfärdar en valfri kompilatorvarning C5032 vid platsen för den omatchade #pragma warning(push), om den är aktiverad. Den här varningen utfärdas endast om det inte finns några kompileringsfel i översättningsenheten.

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

Exempel (före)

  // 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

Exempel (efter)

  // 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)

Ytterligare varningar kan utfärdas till följd av förbättrad spårning av #pragma varningstillstånd

Tidigare versioner av kompilatorn spårade tillståndsändringar #pragma warning inte tillräckligt bra för att utfärda alla avsedda varningar. Det här beteendet skapade en risk för att vissa varningar effektivt skulle undertryckas under andra omständigheter än programmeraren avsåg. Kompilatorn spårar #pragma warning nu tillståndet mer robust – särskilt relaterade till #pragma warning tillståndsändringar i mallar – och utfärdar eventuellt nya varningar C5031 och C5032 som är avsedda att hjälpa programmeraren att hitta oavsiktliga användningsområden för #pragma warning(push) och #pragma warning(pop).

Som ett resultat av förbättrad #pragma warning spårning av tillståndsändringar kan varningar som tidigare felaktigt undertryckts eller varningar relaterade till problem som tidigare var feldiagnostiserade nu utfärdas.
Förbättrad identifiering av oåtkomlig kod

Ändringar i C++-standardbiblioteket och förbättrad möjlighet att anropa infogade funktioner jämfört med tidigare versioner av kompilatorn kan göra det möjligt för kompilatorn att bevisa att viss kod nu inte kan nås. Det här nya beteendet kan resultera i nya och vanligare utfärdade instanser av varning C4720.
```
  warning C4720: unreachable code
```
I många fall kan den här varningen endast utfärdas när kompilering med optimeringar är aktiverade, eftersom optimeringar kan infoga fler funktionsanrop, eliminera redundant kod eller på annat sätt göra det möjligt att fastställa att viss kod inte kan nås. Vi har observerat att nya instanser av varning C4720 ofta har inträffat i try/catch-block, särskilt när det gäller användning av std::find.

Exempel (före)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // ok
  }
```
Exempel (efter)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // warning C4702: unreachable code
  }
```
Borttagning av avrullningsoptimering pow(T, int)

Tidigare versioner av C++-standardbiblioteket definierade en pow(T, int) funktionsmall som skulle avveckla ett pow funktionsanrop till en serie multiplikationsoperationer. Den här tekniken skulle medföra en stor mängd noggrannhetsfel på grund av flyttalsoperationer, vilket orsakar slutresultat som kan vara betydligt felaktiga. I Visual Studio 2015 Update 1 togs det här beteendet bort för att undvika oavsiktlig förlust av noggrannhet vid användning pow av funktionen. Den här versionen av pow var dock mycket snabbare än rätt beräkning. Om den här ändringen orsakar en betydande prestandaregression och projektet inte kräver exakta flyttalsresultat (till exempel att projektet redan kompileras med /fp:fast) bör du överväga att ersätta anrop till pow med den här lösningsfunktionen:
```
template <class T> 
inline T pow_int(T x, int y) throw() {
     unsigned int n;
     if (y >= 0) {
         n = (unsigned int)(y);
     } else {
         n = (unsigned int)(-y);
     }
     for (T z = T(1); ; x *= x) {
         if ((n & 1) != 0) {
             z *= x;
         }
         if ((n >>= 1) == 0) {
             return (y < 0 ? T(1) / z : z);
         }
     }
}
```
Den här implementeringen är identisk med vad som ingick i tidigare versioner av Visual Studio.

Överensstämmelseförbättringar i Visual Studio 2015 Update 2

Ytterligare varningar och fel kan utfärdas till följd av partiellt stöd för uttrycket SFINAE

Tidigare versioner av kompilatorn parsade inte vissa typer av uttryck i decltype specificerare på grund av bristande stöd för uttrycket SFINAE. Det här gamla beteendet var felaktigt och överensstämmer inte med C++-standarden. Kompilatorn parsar nu dessa uttryck och har delvis stöd för uttrycket SFINAE på grund av pågående anpassningsförbättringar. Därför utfärdar kompilatorn nu varningar och fel som hittades i uttryck som tidigare versioner av kompilatorn inte parsade.

När det här nya beteendet parsar ett decltype uttryck som innehåller en typ som ännu inte har deklarerats, utfärdar kompilatorn kompilatorfel C2039 som ett resultat.

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

Exempel 1: Användning av en odeklarerad typ (före)

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

    template<typename>
    struct s2 {};
  }

Exempel 1 (efter)

  struct s1
  {
    template <typename>  // forward declare s2struct s2;

    template <typename T>
    auto f() -> decltype(s2<T>::type::f());

    template<typename>
    struct s2 {};
  }

När det här nya beteendet parsar ett decltype uttryck som saknar nödvändig användning av nyckelordet typename för att ange att ett beroende namn är en typ, utfärdar kompilatorn kompilatorn varning C4346 tillsammans med kompilatorfel 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'

Exempel 2: Beroende namn är inte en typ (före)

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

Exempel 2 (efter)

  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 medlemsvariabler förhindrar implicit definierade konstruktorer och tilldelningsoperatorer Tidigare versioner av kompilatorn tillät en klass som har volatile medlemsvariabler att ha standardkonstruktorer för kopiering/flytt och standardoperatorer för kopierings-/flytttilldelning automatiskt genererade. Det här gamla beteendet var felaktigt och överensstämmer inte med C++-standarden. Kompilatorn anser nu att en klass som har flyktiga medlemsvariabler har icke-triviala bygg- och tilldelningsoperatorer som förhindrar att standardimplementeringar av dessa operatorer genereras automatiskt. När en sådan klass är medlem i en union (eller en anonym union i en klass) definieras kopierings-/flyttkonstruktorerna och kopierings-/flytttilldelningsoperatorerna för unionen (eller klassen som innehåller den anonyma unionen) implicit som borttagna. Att försöka konstruera eller kopiera unionen (eller klassen som innehåller den anonyma unionen) utan att uttryckligen definiera dem är ett fel och kompilatorn utfärdar kompilatorfelet C2280 som ett resultat.
```
  error C2280: 'B::B(const B &)': attempting to reference a deleted function
```
Exempel (före)
```
  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
```
Exempel (efter)
```
  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
```
Statiska medlemsfunktioner stöder inte cv-kvalificeringar.

Tidigare versioner av Visual C++ 2015 tillät statiska medlemsfunktioner att ha cv-kvalificerare. Det här beteendet beror på en regression i Visual C++ 2015 och Visual C++ 2015 Update 1; Visual C++ 2013 och tidigare versioner av Visual C++ avvisa kod som skrivits på det här sättet. Beteendet för Visual C++ 2015 och Visual C++ 2015 Update 1 är felaktigt och överensstämmer inte med C++-standarden. Visual Studio 2015 Update 2 avvisar kod som skrivits på det här sättet och utfärdar kompilatorfel C2511 i stället.
```
  error C2511: 'void A::func(void) const': overloaded member function not found in 'A'
```
Exempel (före)
```
  struct A
  {
    static void func();
  };

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

  void A::func() {}  // removed const
```

Vidaredeklaration av uppräkning tillåts inte i WinRT-kod (påverkar endast /ZW)

Kod som kompilerats för Windows Runtime (WinRT) tillåter inte att enum-typer framåtförklaras, på samma sätt som när hanterad C++-kod kompileras för .Net Framework med kompilatorväxeln /clr. Det här beteendet säkerställer att storleken på en uppräkning alltid är känd och kan projiceras korrekt till WinRT-typsystemet. Kompilatorn avvisar kod som skrivits på det här sättet och utfärdar kompilatorfel C2599 tillsammans med kompilatorfel C3197.

  error C2599: 'CustomEnum': the forward declaration of a WinRT enum is not allowed

  error C3197: 'public': can only be used in definitions

Exempel (före)

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

Exempel (efter)

            // forward declaration of CustomEnum removed
  namespace A {
    public enum class CustomEnum: int32
    {
      Value1
    };
  }

  public ref class Component sealed
  {
  public:
    CustomEnum f()
    {
      return CustomEnum::Value1;
    }
  };

Överlagrad icke-medlemsoperator ny och operatörsborttagning kanske inte deklareras infogad (nivå 1 (/W1) on-by-default)

Tidigare versioner av kompilatorn utfärdar ingen varning när icke-medlemsoperatorns nya och operatörsborttagningsfunktioner deklareras infogade. Kod som skrivs på det här sättet är dåligt utformad (ingen diagnostik krävs) och kan orsaka minnesproblem till följd av felmatchning av new- och delete-operatorer (särskilt när de används tillsammans med deallokering baserad på storlek) som kan vara svår att upptäcka. Kompilatorn utfärdar nu kompilatorvarning C4595 för att identifiera kod som skrivits på det här sättet.
```
  warning C4595: 'operator new': non-member operator new or delete functions may not be declared inline
```
Exempel (före)
```
  inline void* operator new(size_t sz)  // warning C4595
  {
    ...
  }
```
Exempel (efter)
```
  void* operator new(size_t sz)  // removed inline
  {
    ...
  }
```
Att åtgärda kod som skrivs på det här sättet kan kräva att operatordefinitionerna flyttas från en rubrikfil och till en motsvarande källfil.

Anpassningsförbättringar i Visual Studio 2015 Update 3

std::is_convertable identifierar nu självtilldelning (standardbibliotek) Tidigare versioner av typdraget std::is_convertable identifierade inte korrekt självtilldelning av en klasstyp när dess kopieringskonstruktor tas bort eller är privat. Nu ställs std::is_convertable<>::value korrekt in på false när den tillämpas på en klasstyp med en borttagen eller privat kopieringskonstruktor.

Det finns ingen kompilatordiagnostik associerad med den här ändringen.

Exempel
```
  #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");
```
I tidigare versioner av Visual C++ genomför de statiska påståendena längst ned i det här exemplet eftersom std::is_convertable<>::value var felaktigt inställd på true. std::is_convertable<>::value är nu korrekt inställd på false, vilket gör att de statiska påståendena misslyckas.
Standard- eller borttagna triviala kopierings- och flyttkonstruktorer respekterar åtkomstspecifierare

Tidigare versioner av kompilatorn kontrollerade inte åtkomstspecificeraren för standardmässiga eller borttagna triviala kopierings- och flyttkonstruktorer innan de kunde anropas. Det här gamla beteendet var felaktigt och överensstämmer inte med C++-standarden. I vissa fall skapade det här gamla beteendet en risk för tyst felaktig kodgenerering, vilket resulterade i oförutsägbart körningsbeteende. Kompilatorn kontrollerar nu åtkomstspecificeraren för standardmässiga eller borttagna triviala kopierings- och flyttkonstruktorer för att avgöra om den kan anropas, och om inte, utfärdar kompilatorn varning C2248 som ett resultat.
```
  error C2248: 'S::S' cannot access private member declared in class 'S'
```
Exempel (före)
```
  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
  }
```
Exempel (efter)
```
  class S {
  public:
     S() = default;
  private:
      S(const S&) = default;
  };

  void f(const S&);  // pass S by reference

  int main()
  {
      S s;
      f(s);
  }
```

Utfasning av tilldelat ATL-kodstöd (nivå 1 (/W1) on-by-default)

Tidigare versioner av kompilatorn stödde tillskriven ATL-kod. Som nästa fas för att ta bort stöd för attributerad ATL-kod som började i Visual C++ 2008 har attributerad ATL-kod blivit avvecklad. Kompilatorn utfärdar nu kompilatorvarning C4467 för att identifiera den här typen av inaktuell kod.

  warning C4467: Usage of ATL attributes is deprecated

Om du vill fortsätta använda tilldelad ATL-kod tills stöd har tagits bort från kompilatorn kan du inaktivera den här varningen genom att skicka kommandoradsargumenten /Wv:18 eller /wd4467 till kompilatorn eller genom att lägga till #pragma warning(disable:4467) källkoden.

Exempel 1 (före)

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

Exempel 1 (efter)

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

Ibland kanske du behöver eller vill skapa en IDL-fil för att undvika att använda inaktuella ATL-attribut, som i exempelkoden nedan

Exempel 2 (före)

  [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
  {
      // ...
  };

Skapa först filen *.idl; den vc140.idl-genererade filen kan användas för att hämta en *.idl-fil som innehåller gränssnitten och anteckningarna.

Lägg sedan till ett MIDL-steg i bygget för att se till att C++-gränssnittsdefinitionerna genereras.

Exempel 2 IDL (efter)

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

Använd sedan ATL direkt i implementeringsfilen, som i exempelkoden nedan.

Genomförande av exempel 2 (efter)

  #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()
  };

Förkompilerade huvudfiler (PCH) och felmatchade #include direktiv (påverkar /Wall/WXendast )

Tidigare versioner av kompilatorn accepterade felmatchade #include direktiv i källfiler mellan -Yc och -Yu kompileringar när PCH-filer (precompiled header) används. Kod som skrivs på det här sättet accepteras inte längre av kompilatorn. Kompilatorn utfärdar nu kompilatorvarning CC4598 för att identifiera felmatchade #include direktiv när PCH-filer används.
```
  warning C4598: 'b.h': included header file specified for Ycc.h at position 2 does not match Yuc.h at that position
```
Exempel (före):

X.cpp (-Ycc.h)
```
  #include "a.h"
  #include "b.h"
  #include "c.h"
```
Z.cpp (-Yuc.h)
```
  #include "b.h"
  #include "a.h"  // mismatched order relative to X.cpp
  #include "c.h"
```
Exempel (efter)

X.cpp (-Ycc.h)
```
  #include "a.h"
  #include "b.h"
  #include "c.h"
```
Z.cpp (-Yuc.h)
```
  #include "a.h"
  #include "b.h" // matched order relative to X.cpp
  #include "c.h"
```
Förkompilerade huvudfiler (PCH) och felmatchade inkluderingskataloger (påverkar endast /Wall/WX)

Tidigare versioner av kompilatorn accepterade felmatchade katalogvägar i kommandoradsargumenten till kompilatorn mellan -I och -Yc kompileringar när förkompilerade huvudfiler (PCH) användes. Kod som skrivs på det här sättet accepteras inte längre av kompilatorn. Kompilatorn utfärdar nu kompilatorvarning CC4599 för att identifiera felmatchade kommandoradsargument för katalog (-I) när PCH-filer används.
```
  warning C4599: '-I..' : specified for Ycc.h at position 1 does not match Yuc.h at that position
```
Exempel (före)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h Z.cpp
```
Exempel (efter)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h -I.. Z.cpp
```

Nyheter för C++ i Visual Studio 2013

Förbättrat stöd för ISO C/C++-standarder

Kompilator

MSVC har stöd för dessa ISO C++11-språkfunktioner:

Standardmallargument för funktionsmallar.
Delegera konstruktorer
Explicita konverteringsoperatorer.
Initierarlistor och enhetlig initiering.
Råa strängliteraler.
Mallar för variabla argument.
Aliasmallar.
Borttagna funktioner.
Initierare av icke-statiska datamedlemmar (NSDMIs).
Standardfunktioner. *
Stöder dessa ISO C99-språkfunktioner:
_Bool
Sammansatta literaler.
Anvisade initialiserare
Blanda deklarationer med kod.
Strängliteral konvertering till ändringsbara värden kan inte tillåtas med hjälp av det nya kompilatoralternativet /Zc:strictStrings. I C++98 blev konverteringen från strängliteraler till char* (och breda strängliteraler till wchar_t*) inaktuell. I C++11 togs konverteringen bort helt. Även om kompilatorn strikt kan följa standarden, ger /Zc:strictStrings den i stället alternativet så att du kan styra konverteringen. Som standard är alternativet inaktiverat. Observera att när du använder det här alternativet i felsökningsläge kompileras inte STL:en.
rvalue/lvalue Reference Casts. Med rvalue-referenser kan C++11 tydligt skilja mellan lvalues och rvalues. Tidigare tillhandahöll kompilatorn inte detta i specifika typgjutningsscenarier. Ett nytt kompilatoralternativ, /Zc:rvalueCast, har lagts till för att göra kompilatorn överensstämmande med C++ Language Working Paper(se avsnitt 5.4, [expr.cast]/1). Standardbeteendet när det här alternativet inte anges är detsamma som i Visual Studio 2012.

Anmärkning

För standardfunktioner stöds inte användning av =default för att begära medlemsvisa flyttkonstruktorer och flyttilldelningsoperatorer.

C99-bibliotek

Deklarationer och implementeringar läggs till för funktioner som saknas i dessa rubriker: math.h, ctype.h, wctype.h, stdio.h, stdlib.h och wchar.h. Dessutom läggs de nya rubrikerna complex.h, stdbool.h, fenv.h och inttypes.h och implementeringar för alla funktioner som deklareras i dem. Det finns nya C++-omslutningshuvuden (ccomplex, cfenv, cinttypes, ctgmath) och ett antal andra uppdateras (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar och cwctype).

Standardmallbibliotek

Stöd för explicita konverteringsoperatorer för C++11, initialiserarlistor, begränsade uppräkningar och variadiska mallar. Alla containrar har nu stöd för de detaljerade elementkraven för C++11. Stöd för dessa C++14-funktioner:

"Transparenta operatorfunktioner" mindre<>, större<>, plus<>, gånger<> och så vidare.
<make_unique T>(args...) och make_unique<T[]>(n)
cbegin()/cend(), rbegin()/rend() och crbegin()/crend() icke-medlemsfunktioner.
<atomic> har fått många prestandaförbättringar.
< > type_traits fått stora stabiliserings- och kodkorrigeringar.

Brytande förändringar

Detta förbättrade stöd för ISO C/C++-standarder kan kräva ändringar i befintlig kod så att den överensstämmer med C++11 och kompileras korrekt i Visual C++ i Visual Studio 2013.

Förbättringar av Visual C++-bibliotek

C++ REST SDK läggs till. Den har en modern C++-implementering av REST-tjänster.
Stöd för C++ AMP-texturer har förbättrats. Den innehåller nu stöd för mipmaps och nya samplingslägen.
PPL-uppgifter stöder flera schemaläggningstekniker och asynkron felsökning. Nya API:er gör det möjligt att skapa PPL-uppgifter för både normala resultat och undantagsvillkor.

C++-programprestanda

Autovektoriserare identifierar och optimerar nu fler C++-mönster för att få koden att köras snabbare.
Förbättringar av kodkvaliteten för ARM-plattformen och Atom-mikroarkitekturen.
Anropskonventionen __vectorcall läggs till. Skicka vektortypsargument med hjälp av __vectorcall anropande konvention för att använda vektorregister.
Nya alternativ för länkaren. Växlarna /Gw (kompilatorn) och /Gy (assembler) möjliggör länkoptimeringar för att skapa smalare binärfiler.
Stöd för delat C++ AMP-minne för att minska eller eliminera datakopiering mellan CPU och GPU.

PGO-förbättringar (Profile Guided Optimization)

Prestandaförbättringar från en minskning av arbetsuppsättningen med appar som optimeras med hjälp av PGO.
Ny PGO för utveckling av Windows Runtime-appar.

Utvecklingsstöd för Windows Runtime-appar

Stöd för boxade typer i värdestrukturer.

Nu kan du definiera värdetyper med hjälp av fält som kan vara null, IBox<int>^ till exempel i stället för int. Det innebär att fälten antingen kan ha ett värde eller vara lika med nullptr.
Mer omfattande undantagsinformation.

C++/CX stöder den nya Windows-felmodellen som möjliggör insamling och spridning av omfattande undantagsinformation i det binära programgränssnittet (ABI). Detta inkluderar anropsstackar och anpassade meddelandesträngar.
Object::ToString() är nu virtuellt.

Nu kan du åsidosätta ToString i användardefinierade Windows Runtime-referenstyper.
Stöd för inaktuella API:er.

Offentliga Windows Runtime-API:er kan nu markeras som inaktuella och få ett anpassat meddelande som visas som en byggvarning och kan ge migreringsvägledning.
Förbättringar av felsökningsprogrammet.

Stöd för intern/JavaScript-interop-felsökning, Windows Runtime-undantagsdiagnos och asynkron kodfelsökning (både Windows Runtime och PPL).

Anmärkning

Förutom de C++-specifika funktioner och förbättringar som beskrivs i det här avsnittet kan andra förbättringar i Visual Studio också hjälpa dig att skriva bättre Windows Runtime-appar.

Diagnostikförbättringar

Förbättringar av felsökningsprogrammet. Stöd för asynkron felsökning och Just My Code-felsökning.
Kodanalyskategorier. Nu kan du visa kategoriserade utdata från Kodanalys för att hjälpa dig att hitta och åtgärda kodfel.
XAML-diagnostik. Nu kan du diagnostisera problem med UI-svarstider och batterianvändning i din XAML.
Förbättringar av grafik och GPU-felsökning.
Fjärrinspelning och uppspelning på verkliga enheter.
Samtidig C++ AMP- och CPU-felsökning.
Förbättrad C++ AMP-körningsdiagnostik.
Spårningsfelsökning för HLSL Compute shader.

3D-grafikförbättringar

Stöd för bildhanteringspipeline för förmultipliserat alfa-DDS-format.
Bildredigeraren använder internt förmultnad alfa för återgivning och undviker därmed återgivning av artefakter som mörka halos.
Bild- och modellredigerare. Användardefinierad filtergenerering stöds nu i Shader Designer i bildredigeraren och modellredigeraren.

IDE och produktivitet

Förbättrad kodformatering. Du kan använda fler formateringsinställningar för C++-koden. Med hjälp av de här inställningarna kan du styra ny radplacering av klammerparenteser och nyckelord, indrag, avstånd och radomslutning. Koden formateras automatiskt när du slutför instruktioner och block och när du klistrar in kod i en fil.

Klammerslutförande. C++-koden slutför nu automatiskt de avslutande tecknen som motsvarar dessa inledande tecken:

{ (måsvinge)
[ (hakparentes)
( (parenteser)
" (enkelt citattecken)
" (dubbelt citattecken)

Ytterligare funktioner för automatisk slutförande av C++.

Lägger till semikolon för klasstyper.
Slutför parenteser för råa strängliteraler.
Slutför flerradskommentarer (/* */)

Hitta alla referenser matchar och filtrerar referenser i bakgrunden automatiskt när listan med textmatchningar visas.

Context-Based Filtrering av medlemslista. Otillgängliga medlemmar filtreras bort från IntelliSense-medlemslistorna. Privata medlemmar visas till exempel inte i medlemslistan om du inte ändrar koden som implementerar typen. När medlemslistan är öppen kan du trycka på Ctrl+J för att ta bort en nivå av filtrering (gäller endast för det aktuella medlemslistefönstret). Du kan trycka på Ctrl+J igen för att ta bort textfiltreringen och visa varje medlem.

Hjälp för parameter rullning Den visade funktionssignaturen i knappbeskrivningen parameter-help ändras nu baserat på antalet parametrar som du faktiskt har skrivit, i stället för att bara visa en godtycklig signatur och inte uppdatera den baserat på den aktuella kontexten. Parameterhjälp fungerar också korrekt när den visas på kapslade funktioner.

Växla mellan rubrik och kodfil. Du kan nu växla mellan ett huvud och dess motsvarande kodfil med hjälp av ett kommando på snabbmenyn eller ett kortkommando.

Ändringsbart C++-projekt-egenskapsfönster

Automatisk generering av händelsehanterarkod i C++/CX och C++/CLI. När du skriver kod för att lägga till en händelsehanterare i en C++/CX- eller C++/CLI-kodfil kan redigeraren automatiskt generera definitionen för ombudsinstans och händelsehanterare. Ett verktygsfönster visas när händelsehanterarkod kan genereras automatiskt.

DPI-medvetenhetsförbättring. Inställningen DPI-medvetenhet för programmanifestfiler stöder nu inställningen "Hög DPI-medveten per skärm".

Snabbare konfigurationsväxling. För stora program körs växlingskonfigurationer – särskilt efterföljande växlingsåtgärder – mycket snabbare.

Skapa tidseffektivitet. Många optimeringar och användning av flera kärnor gör byggen snabbare, särskilt för stora projekt. Inkrementella versioner för C++-program som har referenser till C++ WinMD är också mycket snabbare.

Nyheter för C++ i Visual Studio 2012

Förbättrat stöd för C++11-standarder

Standardmallbibliotek

Stöd för nya STL-huvuden: <atomic>, <chrono>, <condition_variable>, <filesystem>, <future>, <mutex>, <ratio> och <thread>.
Containrar är nu mindre för att optimera minnesresursanvändningen. I x86-versionsläge med standardinställningar std::vector har till exempel krympt från 16 byte i Visual Studio 2010 till 12 byte i Visual Studio 2012 och std::map krympt från 16 byte i Visual Studio 2010 till 8 byte i Visual Studio 2012.
Som tillåts men inte krävs av C++11 Standard har SCARY-iteratorer implementerats.

Andra C++11-förbättringar

Intervallbaserad för loopar. Du kan skriva mer robusta loopar som fungerar med matriser, STL-containrar och Windows Runtime-samlingar i formuläret för ( for-range-declaration : expression ). Detta är en del av core language-stödet.
Tillståndslösa lambdas, som är kodblock som börjar med en tom lambda-introduktion [] och inte samlar in några lokala variabler, kan nu implicit konverteras till funktionspekare enligt C++11 Standard.
Stöd för begränsade uppräkningar. Uppräkningsnyckeln för C++-uppräkningsklass stöds nu. Följande kod visar hur uppräkningsnyckeln skiljer sig från tidigare uppräkningsbeteende.
```
enum class Element { Hydrogen, Helium, Lithium, Beryllium };
void func1(Element e);
func1(Hydrogen); // error C2065: 'Hydrogen' : undeclared identifier
func1(Element::Helium); // OK
```

Utvecklingsstöd för Windows Runtime-appar

Inbyggd XAML-baserad användargränssnittsmodell. För Windows Runtime-appar kan du använda den nya interna XAML-baserade användargränssnittsmodellen.
Visual C++-komponenttillägg. Dessa tillägg förenklar förbrukningen av Windows Runtime-objekt, som är en nödvändig del av Windows Runtime-appar. Mer information finns i Översikt över Windows Runtime-appar med C++ och Visual C++-språkreferens (C++/CX)
DirectX-spel. Du kan utveckla engagerande spel med hjälp av det nya DirectX-stödet för Windows Runtime-appar.
XAML/DirectX interop. Windows Runtime-appar som använder både XAML och DirectX samverkar nu effektivt.
DLL-utveckling för Windows Runtime-komponent. Komponent-DLL-utveckling gör Windows Runtime-miljön utökningsbar.

Kompilator och länkare

Automatisk vektoriserare. Kompilatorn analyserar loopar i koden och genererar, om möjligt, instruktioner som använder vektorregister och instruktioner som finns i alla moderna processorer. Detta gör att looparna körs snabbare. (Processorinstruktionerna kallas SSE för simd-tillägg för direktuppspelning). Du behöver inte aktivera eller begära den här optimeringen eftersom den tillämpas automatiskt.
Automatisk parallellisering. Kompilatorn kan analysera loopar i koden och generera instruktioner som sprider beräkningarna över flera kärnor eller processorer. Detta kan göra att looparna körs snabbare. Du måste begära den här optimeringen eftersom den inte är aktiverad som standard. I många fall hjälper det till att inkludera en #pragma loop(hint_parallel(N)) i koden omedelbart före de loopar som du vill parallellisera.
Autovektoriseraren och autoparallelliseraren kan fungera tillsammans så att beräkningar sprids över flera kärnor och koden på varje kärna använder sina vektorregister.

Nytt i Visual Studio 2012 Update 1

Rikta in dig på Windows XP när du skapar C++-koden. Du kan använda Microsoft C++-kompilatorn och biblioteken för att rikta in dig på Windows XP och Windows Server 2003.

Stöd för parallell programmering

C++ Accelererad massiv parallellitet (AMP)

C++ AMP påskyndar körningen av C++-koden genom att dra nytta av den dataparallell maskinvara som vanligtvis finns som GPU på ett diskret grafikkort. Programmeringsmodellen C++ AMP innehåller flerdimensionella matriser, indexering, minnesöverföring, tiling och ett matematiskt funktionsbibliotek. Genom att använda C++ AMP-språktillägg och kompileringsbegränsningar kan du styra hur data flyttas från processorn till GPU:n och tillbaka.

Felsökning. Felsökningsfunktionen för appar som använder C++ AMP för att rikta in sig på GPU:n är precis som felsökning för andra C++-appar. Detta inkluderar de nya parallella felsökningstilläggen som nämndes tidigare.

Profilering. Det finns nu stöd för profilering för GPU-aktivitet som baseras på C++ AMP och andra Direct3D-baserade programmeringsmodeller.

Allmänna förbättringar av parallell programmering

Med maskinvara som flyttas till arkitekturer med flera kärnor och många kärnor kan utvecklare inte längre förlita sig på ständigt ökande klockhastigheter från enkärnor. Det parallella programmeringsstödet i Concurrency Runtime gör det möjligt för utvecklare att dra nytta av dessa nya arkitekturer. I Visual Studio 2010 introducerades kraftfulla C++-parallelliseringsbibliotek, till exempel biblioteket parallella mönster, tillsammans med funktioner för att dra nytta av samtidighet genom att uttrycka avancerade dataflödespipelines. I Visual Studio 2012 har dessa bibliotek utökats för att ge bättre prestanda, mer kontroll och mer stöd för de parallella mönster som utvecklare behöver mest. I erbjudandets bredd ingår nu:

En omfattande uppgiftsbaserad programmeringsmodell som stöder asynkron och fortsättning.
Parallella algoritmer, som stöder parallellitet med gafflar (parallel_for, parallel_for med tillhörighet, parallel_for_each, parallel_sort, parallel_reduce parallel_transform).
Samtidighetssäkra containrar som tillhandahåller trådsäkra versioner av std-datastrukturer som priority_queue, kö, vektor och karta.
Biblioteket asynkrona agenter, som utvecklare kan använda för att uttrycka dataflödespipelines som naturligt delas upp i samtidiga enheter.
En anpassningsbar schemaläggare och resurshanterare som underlättar den smidiga sammansättningen av mönstren i den här listan.

Allmänna förbättringar av parallell felsökning

Förutom fönstret Parallella uppgifter och fönstret Parallella staplar erbjuder Visual Studio 2012 ett nytt Parallel Watch-fönster så att du kan undersöka värdena för ett uttryck i alla trådar och processer och utföra sortering och filtrering av resultatet. Du kan också använda dina egna visualiserare för att utöka fönstret, och du kan dra nytta av det nya stöd för flera processer i alla verktygsfönster.

IDE

Stöd för Visual Studio-mallar. Nu kan du använda Visual Studio Templates-tekniken för att skapa C++-projekt- och objektmallar.

Asynkron lösningsbelastning. Projekt läses nu in asynkront – de viktigaste delarna i lösningen först – så att du kan börja arbeta snabbare.

Automatiserad distribution för fjärrfelsökning. Distributionen av filer för fjärrfelsökning i Visual C++ har förenklats. Alternativet Distribuera på projektkontextmenyn kopierar automatiskt filerna som anges i felsökningskonfigurationsegenskaperna till fjärrdatorn. Det krävs inte längre att filer kopieras manuellt till fjärrdatorn.

C++/CLI IntelliSense. C++/CLI har nu fullständigt IntelliSense-stöd. IntelliSense-funktioner som snabbinformation, parameterhjälp, listmedlemmar och automatiskt slutförande fungerar nu för C++/CLI. Dessutom fungerar även de andra Förbättringarna av IntelliSense och IDE som anges i det här dokumentet för C++/CLI.

Rikare IntelliSense-verktygstips. C++ IntelliSense Snabbinformation knappbeskrivningar visar nu mer omfattande XML-dokumentation kommentarer stilinformation. Om du använder ett API från ett bibliotek, till exempel C++ AMP, som har XML-dokumentationskommentarer, visar IntelliSense-knappbeskrivningen mer information än bara deklarationen. Om koden också har XML-dokumentationskommentarerna visar IntelliSense-knappbeskrivningarna den mer omfattande informationen.

C++-kodkonstruktioner. Skeleton-kod är tillgänglig för switch, if-else, för loop och andra grundläggande kodkonstruktioner i listrutan Listmedlemmar. Välj en kod i listan för att infoga den i koden och fyll sedan i den logik som krävs. Du kan också skapa egna anpassade kodstycken för användning i redigeraren.

Visa en lista över förbättringar för medlemmar. Listrutan Listmedlemmar visas automatiskt när du skriver kod i kodredigeraren. Resultaten filtreras så att endast relevanta medlemmar visas när du skriver. Du kan styra vilken typ av filtreringslogik som används av medlemslistan i dialogrutan Alternativ under Textredigeraren>C/C++>Avancerat.

Semantisk färgning. Typer, uppräkningar, makron och andra C++-token har nu färgläggning som standard.

Referensmarkering. Om du väljer en symbol markeras nu alla instanser av symbolen i den aktuella filen. Tryck på Ctrl+Flytta+uppåtpil eller Ctrl+Skift+nedåtpil för att flytta mellan de markerade referenserna. Du kan inaktivera den här funktionen i dialogrutan Alternativ under Textredigeraren>C/C++>Avancerat.

Verktyg för programlivscykelhantering

Analys av statisk kod

Statisk analys för C++ har uppdaterats för att ge mer detaljerad felkontextinformation, fler analysregler och bättre analysresultat. I det nya fönstret Kodanalys kan du filtrera meddelanden efter nyckelord, projekt och allvarlighetsgrad. När du väljer ett meddelande i fönstret markeras raden i koden där meddelandet utlöstes i kodredigeraren. För vissa C++-varningar visar meddelandet källrader som visar körningssökvägen som leder till varningen. Beslutspunkter och skälen till att ta den specifika vägen är markerade. Kodanalys ingår i de flesta utgåvor av Visual Studio 2012. I utgåvorna Professional, Premium och Ultimate ingår alla regler. I Express-utgåvorna för Windows 8 och Windows Phone ingår bara de mest kritiska varningarna. Kodanalys ingår inte i Express Edition för webben. Här följer några andra förbättringar av kodanalysen:

Nya samtidighetsvarningar hjälper dig att undvika samtidighetsbuggar genom att se till att du använder rätt låsdiscipliner i C/C++-program med flera flöden. Analyseraren identifierar potentiella konkurrensförhållanden, inversioner av låsordning, avtalsöverträdelser för anropare/samtalsmottagare, felmatchade synkroniseringsåtgärder och andra samtidighetsbuggar.
Du kan ange de C++-regler som du vill tillämpa på kodanalyskörningar med hjälp av regeluppsättningar.
I fönstret Kodanalys kan du infoga en pragma i källkoden som undertrycker en markerad varning.
Du kan förbättra noggrannheten och fullständigheten i statisk kodanalys med hjälp av den nya versionen av Microsofts källkodsanteckningsspråk (SAL) för att beskriva hur en funktion använder sina parametrar, de antaganden som den gör om dem och de garantier som den gör när den är klar.
Stöd för 64-bitars C++-projekt.

Uppdaterat enhetstestramverk

Använd det nya C++-enhetstestramverket i Visual Studio för att skriva C++-enhetstester. Lägg till ett nytt enhetstestprojekt i din befintliga C++-lösning genom att hitta mallen C++ Enhetstestprojekt under kategorin Visual C++ i dialogrutan Nytt projekt. Börja skriva enhetstesterna i den genererade TEST_METHOD kodstub i filen Unittest1.cpp. När testkoden skrivs skapar du lösningen. När du vill köra testerna öppnar du fönstret Enhetstestutforskaren genom att välja Visa>andra>. Välj sedan Kör valt test på snabbmenyn för det testfall du vill använda. När testkörningen är klar kan du visa testresultat och ytterligare stackspårningsinformation i samma fönster.

Diagram över arkitekturberoende

För att förstå koden bättre kan du nu generera beroendediagram för binärdiagram, klass, namnrymd och inkludera filer i en lösning. På menyraden väljer du Arkitektur>Generera beroendediagram och sedan För lösning eller För Inkludera fil för att generera ett beroendediagram. När grafgenereringen är klar kan du utforska den genom att expandera varje nod, lära dig beroenderelationer genom att flytta mellan noder och bläddra i källkoden genom att välja Visa innehåll på snabbmenyn för en nod. Om du vill generera ett beroendediagram för inkluderingsfiler går du till snabbmenyn för en *.cpp källkodsfil eller *.h-huvudfil och väljer Generera diagram över inkludera filer.

Arkitekturexplorer

Med hjälp av Arkitekturutforskaren kan du utforska tillgångarna i din C++-lösning, dina projekt eller filer. På menyraden väljer du Arkitektur>Utforskaren för Windows-arkitektur>. Du kan välja en nod som du är intresserad av, till exempel Klassvy. I det här fallet expanderas den högra sidan av verktygsfönstret med en lista över namnområden. Om du väljer ett namnområde visar en ny kolumn en lista över klasser, structs och uppräkningar i det här namnområdet. Du kan fortsätta att utforska dessa tillgångar eller gå tillbaka till kolumnen längst till vänster för att starta en annan fråga. Se Hitta kod med Architecture Explorer.

Kodtäckning

Kodtäckningen har uppdaterats för att dynamiskt instrumentera binärfiler under körning. Detta sänker konfigurationskostnaderna och ger bättre prestanda. Du kan också samla in kodtäckningsdata från enhetstester för C++-appar. När du har skapat C++-enhetstester kan du använda Enhetstestutforskaren för att identifiera tester i din lösning. Om du vill köra enhetstesterna och samla in kodtäckningsdata åt dem väljer du Analysera kodtäckning i Enhetstestutforskaren. Du kan undersöka kodtäckningsresultaten i fönstret Resultat av kodtäckning – på menyraden väljer du Testa>Resultat för Windows-kodtäckning>.

Nyheter för C++ i Visual Studio 2010

C++ Compiler och Linker

automatiskt nyckelord. Nyckelordet auto har ett nytt syfte. Använd standardvärdet för nyckelordet auto för att deklarera en variabel vars typ härleds från initieringsuttrycket i deklarationen av variabeln. Kompilatoralternativet /Zc:auto anropar antingen den nya eller den tidigare innebörden av nyckelordet auto .

decltype Typspecifikator Typspecificeraren decltype returnerar typen av ett angivet uttryck. decltype Använd typspecificeraren i kombination med nyckelordet auto för att deklarera en typ som antingen är komplex eller endast känd för kompilatorn. Använd till exempel kombinationen för att deklarera en mallfunktion vars returtyp beror på typen av mallargument. Eller deklarera en mallfunktion som anropar en annan funktion och sedan returnerar returtypen för den anropade funktionen.

Lambda-uttryck. Lambda-funktioner har en funktionstext men inget namn. Lambda-funktioner kombinerar de bästa egenskaperna för funktionspekare och funktionsobjekt. Använd en lambda-funktion själv, som en mallfunktionsparameter i stället för ett funktionsobjekt, eller tillsammans med nyckelordet auto för att deklarera en variabel vars typ är en lambda.

Rvalue-referens. Rvalue-referensdeklaratorn (&&) deklarerar en referens till ett rvalue. Med en rvalue-referens kan du använda flyttsemantik och perfekt vidarebefordring för att skriva mer effektiva konstruktorer, funktioner och mallar.

static_assert deklaration. En static_assert deklaration testar en mjukvaruassertion vid kompilering, till skillnad från andra assert-mekanismer som testas vid körning. Om försäkran misslyckas misslyckas kompilering och ett angivet felmeddelande utfärdas.

nullptr och __nullptr nyckelord. Med MSVC kan du använda nyckelordet nullptr med inbyggd kod eller med hanterad kod. Nyckelordet nullptr anger att ett objekthandtag, en inre pekare eller en inbyggd pekartyp inte pekar på ett objekt. Kompilatorn tolkar nullptr som hanterad kod när du använder kompilatoralternativet /clr och intern kod när du inte använder /clr alternativet. Det Microsoft-specifika nyckelordet __nullptr har samma betydelse som nullptr, men det gäller endast intern kod. Om du kompilerar inbyggd C/C++-kod med hjälp /clr av kompilatoralternativet kan kompilatorn inte avgöra om nyckelordet nullptr är en intern eller en hanterad term. Om du vill göra avsikten tydlig för kompilatorn använder du nyckelordet nullptr för att ange den hanterade termen och __nullptr för att ange den interna termen.

/Zc:trigraphs Kompilatoralternativ. Som standard är stöd för trigrafer inaktiverat. Använd kompileringsalternativet /Zc:trigraphs för att aktivera stöd för trigrafer. En trigraf består av två på varandra följande frågetecken (??) följt av ett unikt tredje tecken. Kompilatorn ersätter en trigraf med motsvarande skiljetecken. Kompilatorn ersätter till exempel ?? = trigraph med tecknet # (taltecken). Använd trigrafer i C-källfiler som använder en teckenuppsättning som inte innehåller vissa skiljetecken.

Nytt Profile-Guided optimeringsalternativ. PogoSafeMode är ett nytt profilstyrt optimeringsalternativ där du kan ange om du vill använda felsäkert läge eller snabbt läge när du optimerar programmet. Felsäkert läge är trådsäkert, men det är långsammare än snabbt läge. Snabbläge är standardbeteendet.

Nytt CLR-alternativ (Common Language Runtime) /clr:nostdlib. Ett nytt alternativ läggs till för /clr (Common Language Runtime-kompilering). Om olika versioner av samma bibliotek ingår utfärdas ett kompileringsfel. Med det nya alternativet kan du exkludera CLR-standardbiblioteken så att programmet kan använda en angiven version.

Nytt pragmadirektiv detect_mismatch. Med pragma-direktivet detect_mismatch kan du placera en tagg i dina filer som jämförs med andra taggar som har samma namn. Om det finns flera värden för samma namn genererar länkaren ett fel.

XOP Intrinsics, FMA4 Intrinsics och LWP Intrinsics. Nya inbyggda funktioner har lagts till för att stödja XOP Intrinsics Added for Visual Studio 2010 SP1, FMA4 Intrinsics Added for Visual Studio 2010 SP1 och LWP Intrinsics Added for Visual Studio 2010 SP1 processor technologies. Använd __cpuid __cpuidex för att avgöra vilka processortekniker som stöds på en viss dator.

Visual Studio C++-projekt och byggsystemet

MSBuild. Visuella C++-lösningar och -projekt skapas nu med hjälp av MSBuild.exe, som ersätter VCBuild.exe. MSBuild är samma flexibla, utökningsbara, XML-baserade byggverktyg som används av de andra Visual Studio-språken och projekttyperna. På grund av den här ändringen använder Visual Studio C++-projektfiler nu ett XML-filformat och har filnamnstillägget .vcxproj. Visual Studio C++-projektfiler från tidigare versioner av Visual Studio konverteras automatiskt till det nya filformatet.

VC++ kataloger. VC++-kataloginställningen finns nu på två platser. Använd projektegenskapssidor för att ange värden per projekt för VC++-kataloger. Använd Egenskapshanteraren och ett egenskapsblad för att ange globala värden per konfiguration för VC++-kataloger.

Projekt-till-projekt-beroenden. I tidigare versioner lagrades definierade beroenden mellan projekt i lösningsfilen. När dessa lösningar konverteras till det nya projektfilformatet konverteras beroenden till projekt-till-projekt-referenser. Den här ändringen kan påverka program eftersom begreppen för lösningsberoenden och referenser från projekt till projekt skiljer sig åt.

Makron och miljövariabler. Det nya _ITERATOR_DEBUG_LEVEL makrot anropar felsökningsstöd för iteratorer. Använd det här makrot i stället för äldre _SECURE_SCL och _HAS_ITERATOR_DEBUGGING makron.

Visual C++-bibliotek

Samtidighetskörningsbibliotek. Concurrency Runtime-ramverket stöder program och komponenter som körs samtidigt och är ramverket för att programmera samtidiga program i Visual C++. För att stödja programmering med samtidiga program tillhandahåller PPL (Parallel Patterns Library) allmänna containrar och algoritmer för att utföra detaljerad parallellitet. Biblioteket för asynkrona agenter tillhandahåller en aktörsbaserad programmeringsmodell och gränssnitt för meddelandeöverföring för grova dataflöden och pipelining-uppgifter.

Standard-C++-bibliotek. I följande lista beskrivs många av de ändringar som har gjorts i Standard C++-biblioteket.

Den nya Rvalue-referensen för C++-språkfunktionen har använts för att implementera flyttsemantik och perfekt vidarebefordran för många funktioner i standardmallbiblioteket. Flytta semantik och perfekt vidarebefordran förbättrar avsevärt prestandan för åtgärder som allokerar eller tilldelar variabler eller parametrar.
Rvalue-referenser används också för att implementera den nya unique_ptr klassen, som är en säkrare smart pekartyp än auto_ptr klassen. Klassen unique_ptr är flyttbar men inte kopierbar, implementerar strikt ägarskapssemantik utan att påverka säkerheten och fungerar bra med containrar som är medvetna om rvalue-referenser. Klassen auto_ptr är inaktuell.
Femton nya funktioner, till exempel find_if_not, copy_if och is_sorted, har lagts till i algoritmrubriken <>.
<I minneshuvudet> är den nya make_shared-funktionen ett bekvämt, robust och effektivt sätt att skapa en delad pekare till ett objekt samtidigt som objektet skapas.
Singly länkade listor stöds av det <forward_list>-huvudet.
De nya medlemsfunktionerna cbegin, cend, crbegin och crend tillhandahåller en const_iterator som rör sig framåt eller bakåt genom en container.
< System_error-huvudet >och relaterade mallar stöder bearbetning av systemfel på låg nivå. Medlemmar i exception_ptr klassen kan användas för att transportera undantag mellan trådar.
Codecvt-huvudet <> stöder konvertering av olika kodningar av Unicode-tecken till andra kodningar.
Allokeringshuvudet <> definierar flera mallar som hjälper till att allokera och frigöra minnesblock för nodbaserade containrar.
Det finns många uppdateringar av <random>-rubriken.

Microsoft Foundation-klassbiblioteket (MFC)

Windows 7-funktioner. MFC har stöd för många Windows 7-funktioner, till exempel band-gränssnittet, aktivitetsfältet, hopp-listor, flikminiatyrbilder, miniatyrförhandsvisningar, förloppsindikatorn, ikonöverlägg och sökindexering. Eftersom MFC automatiskt stöder många Windows 7-funktioner kanske du inte behöver ändra ditt befintliga program. Om du vill ha stöd för andra funktioner i nya program använder du MFC-programguiden för att ange vilka funktioner du vill använda.

Multi-touch-medvetenhet. MFC stöder program som har ett multi-touch-användargränssnitt, till exempel program som är skrivna för Microsoft Surface-operativsystemet. Ett multi-touch-program kan hantera Windows Touch-meddelanden och gestmeddelanden, vilket är kombinationer av touch-meddelanden. Registrera bara ditt program för touch- och gesthändelser så dirigerar operativsystemet multi-touch-händelser till dina händelsehanterare.

High-DPI Medvetenhet. Som standard är MFC-program nu Hög-DPI-medvetna. Om ett program är medvetet om hög punkttäthet (High-DPI), kan operativsystemet skala fönster, text och andra gränssnittselement till den aktuella skärmupplösningen. Det innebär att en skalad bild är mer sannolikt att vara korrekt utlagd och inte klippt eller pixelerad.

Omstartshanteraren Omstartshanteraren sparar automatiskt dokument och startar om programmet om det oväntat stängs eller startas om. Du kan till exempel använda omstartshanteraren för att starta programmet när det har stängts av en automatisk uppdatering. Mer information om hur du konfigurerar programmet för att använda omstartshanteraren finns i Så här lägger du till Stöd för Omstartshanteraren.

CTaskDialog. Klassen CTaskDialog kan användas i stället för standardmeddelanderutan AfxMessageBox . Klassen CTaskDialog visar och samlar in mer information än vad standardmeddelanderutan gör.

SafeInt-bibliotek

Det nya SafeInt-biblioteket utför säkra aritmetiska operationer som tar hänsyn till heltalsöverflöde. I det här biblioteket jämförs också olika typer av heltal.

Nya ATL-makron (Active Template Library)

Nya makron har lagts till i ATL för att utöka funktionerna i PROP_ENTRY_TYPE och PROP_ENTRY_TYPE_EX. PROP_ENTRY_INTERFACE och PROP_ENTRY_INTERFACE_EX låter dig lägga till en lista över giltiga CLSID:er. Med PROP_ENTRY_INTERFACE_CALLBACK och PROP_ENTRY_INTERFACE_CALLBACK_EX kan du ange en återanropsfunktion för att avgöra om ett CLSID är giltigt.

/analysera varningar

De flesta /analyze (Enterprise Code Analysis) varningar har tagits bort från C Run-Time (CRT), MFC och ATL bibliotek.

Stöd för animering och D2D

MFC stöder nu animering och Direct2D-grafik. MFC-biblioteket har flera nya MFC-klasser och funktioner som stöder den här funktionen. Det finns också två nya genomgångar som visar hur du lägger till ett D2D-objekt och ett animeringsobjekt i ett projekt. De här genomgångarna är genomgång : Lägga till ett D2D-objekt i ett MFC-projekt och en genomgång : Lägga till animering i ett MFC-projekt.

IDE

Förbättrad IntelliSense. IntelliSense för Visual C++ har gjorts om helt för att bli snabbare, mer exakt och kunna hantera större projekt. För att uppnå den här förbättringen gör IDE skillnad mellan hur en utvecklare visar och ändrar källkoden och hur IDE använder källkods- och projektinställningar för att skapa en lösning. På grund av den här uppdelningen av uppgifter hanteras webbläsarfunktioner som Klassvy och den nya dialogrutan Navigera till av ett system som baseras på en ny SQL Server-fil (.sdf) som ersätter den gamla filen ingen kompileringsbläddring (.ncb). IntelliSense-funktioner som snabb information, automatisk slutförande och parameterhjälp parsar endast översättningsenheter när det behövs. Hybridfunktioner som det nya anropshierarkifönstret använder en kombination av funktionerna browse och IntelliSense. Eftersom IntelliSense endast bearbetar den information som du behöver just nu är IDE:t mer dynamiskt. Eftersom informationen är mer uppdaterad är IDE-vyer och fönster mer exakta. Eftersom IDE-infrastrukturen är bättre organiserad, mer kapabel och mer skalbar kan den hantera större projekt.

Förbättrade IntelliSense-fel. IDE identifierar bättre fel som kan orsaka förlust av IntelliSense och visar röda vågiga understrykningar under dem. Dessutom rapporterar IDE IntelliSense-fel till fönstret Fellista. Om du vill visa koden som orsakar problemet dubbelklickar du på felet i fönstret Fellista.

#include funktionen för automatisk komplettering. IDE stöder automatisk slutförande av nyckelordet #include . När du skriver #includeskapar IDE en listruta med giltiga rubrikfiler. Om du fortsätter genom att skriva ett filnamn filtrerar IDE listan baserat på din post. När som helst kan du välja den fil som du vill ta med i listan. På så sätt kan du snabbt inkludera filer utan att känna till det exakta filnamnet.

Navigera till. I dialogrutan Navigera till kan du söka efter alla symboler och filer i projektet som matchar en angiven sträng. Sökresultaten ändras omedelbart när du skriver ytterligare tecken i söksträngen. I fältet Resultatfeedback får du information om antalet objekt som hittats och hjälper dig att bestämma om du vill begränsa sökningen. Feedbackfälten Kind/Scope, Location och Preview hjälper dig att skilja objekt som har liknande namn. Dessutom kan du utöka den här funktionen för att stödja andra programmeringsspråk.

Parallell felsökning och profilering. Visual Studio-felsökaren är medveten om Concurrency Runtime och hjälper dig att felsöka parallella bearbetningsprogram. Du kan använda det nya verktyget samtidighetsprofiler för att visualisera programmets övergripande beteende. Du kan också använda nya verktygsfönster för att visualisera tillståndet för uppgifter och deras anropsstackar.

Ribbon-designer Menyfliksdesignern är en grafisk redigerare som gör att du kan skapa och ändra ett användargränssnitt för MFC-menyfliksområdet. Det slutliga menyfliksområdets användargränssnitt representeras av en XML-baserad resursfil (.mfcribbon-ms). För befintliga program kan du avbilda det aktuella menyfliksområdets användargränssnitt genom att tillfälligt lägga till några rader kod och sedan anropa menyfliksdesignern. När resursfilen för menyfliksområdet har skapats kan du ersätta den handskrivna gränssnittskoden för menyfliksområdet med några instruktioner som läser in menyfliksområdets resurs.

Anrop Hierarki. Med fönstret Samtalshierarki kan du navigera till alla funktioner som anropas av en viss funktion eller till alla funktioner som anropar en viss funktion.

Arbetsredskap

MFC-klassguiden. Visual C++ 2010 tar tillbaka det väl ansedda MFC-klassguideverktyget. MFC-klassguiden är ett bekvämt sätt att lägga till klasser, meddelanden och variabler i ett projekt utan att behöva ändra uppsättningar med källfiler manuellt.

ATL-kontrollguiden. ATL-kontrollguiden fyller inte längre fältet ProgID automatiskt. Om en ATL-kontroll inte har någon ProgIDfungerar kanske andra verktyg inte med den. Ett exempel på ett verktyg som kräver att kontroller har en ProgID är dialogrutan Infoga aktiv kontroll . Mer information om dialogrutan finns i Infoga ActiveX-kontroller.

Referens för Microsoft Macro Assembler

Tillägget av YMMWORD-datatypen stöder de 256-bitars multimediaoperor som ingår i AVX-instruktionerna (Intel Advanced Vector Extensions).

Nyheter för C++ i Visual Studio 2008

Visual C++ Integrated Development Environment (IDE)

Dialogrutor som skapas i ATL-, MFC- och Win32-program följer nu riktlinjerna för Windows Vista-format. När du skapar ett nytt projekt med hjälp av Visual Studio 2008 överensstämmer alla dialogrutor som du infogar i ditt program med stilguiden för Windows Vista. Om du kompilera om ett projekt som du skapade med en tidigare version av Visual Studio kommer alla befintliga dialogrutor att behålla samma utseende som tidigare. Mer information om hur du infogar dialogrutor i ditt program finns i Dialogredigeraren.
ATL-projektguiden har nu ett alternativ för att registrera komponenter för alla användare. Från och med Visual Studio 2008 registreras COM-komponenterna och typbiblioteken som skapas av ATL Project-guiden i HKEY_CURRENT_USER noden i registret om du inte väljer Registrera komponent för alla användare.
ATL-projektguiden innehåller inte längre ett alternativ för att skapa tilldelade ATL-projekt. Från och med Visual Studio 2008 har ATL-projektguiden inget alternativ för att ändra statusen för ett nytt projekt. Alla nya ATL-projekt som guiden skapar är nu oattributerade.
Skrivning till registret kan omdirigeras. Med introduktionen av Windows Vista krävs det att ett program körs i förhöjt läge för att skriva till vissa delar av registret. Det är inte önskvärt att alltid köra Visual Studio i förhöjt läge. Omdirigering per användare omdirigerar automatiskt registerskrivningar från HKEY_CLASSES_ROOT till HKEY_CURRENT_USER utan några programmeringsändringar.
Klassdesignern har nu begränsat stöd för inbyggd C++-kod. I tidigare versioner av Visual Studio fungerade klassdesignern endast med Visual C# och Visual Basic. C++-användare kan nu använda klassdesignern, men endast i skrivskyddat läge. Mer information om hur du använder klassdesignern med C++finns i Arbeta med Visual C++ Code i Class Designer.
Projektguiden har inte längre ett alternativ för att skapa ett C++ SQL Server-projekt. Från och med Visual Studio 2008 har den nya projektguiden inget alternativ för att skapa ett C++ SQL Server-projekt. SQL Server-projekt som skapats med hjälp av en tidigare version av Visual Studio kompileras fortfarande och fungerar korrekt.

Visual C++-bibliotek

Allmänt

Program kan bindas till specifika versioner av Visual C++-biblioteken. Ibland är ett program beroende av uppdateringar som har gjorts i Visual C++-biblioteken efter en version. I det här fallet kan körning av programmet på en dator som har tidigare versioner av biblioteken orsaka oväntat beteende. Nu kan du binda ett program till en specifik version av biblioteken så att det inte körs på en dator som har en tidigare version av biblioteken.

STL/CLR-bibliotek

Visual C++ innehåller nu STL/CLR-biblioteket. STL/CLR-biblioteket är en paketering av Standard Template Library (STL), en delmängd av Standard C++-biblioteket, för användning med C++ och .NET Framework common language runtime (CLR). Med STL/CLR kan du nu använda alla containrar, iteratorer och algoritmer för STL i en hanterad miljö.

MFC-bibliotek

Windows Vista har stöd för Vanliga kontroller. Över 150 metoder i 18 nya eller befintliga klasser har lagts till för att stödja funktioner i Windows Vista eller för att förbättra funktionerna i aktuella MFC-klasser.
Med den nya CNetAddressCtrl klassen kan du ange och verifiera IPv4- och IPv6-adresser eller DNS-namn.
Den nya CPagerCtrl klassen förenklar användningen av Windows bläddringskontrollen.
Den nya CSplitButton klassen förenklar användningen av Windows-delningsknappen för att välja en standardåtgärd eller valfri åtgärd.

C++-supportbibliotek

C++ introducerar marshaling-biblioteket. Marshaling-biblioteket är ett enkelt och optimerat sätt att samla in data mellan interna och hanterade miljöer. Biblioteket är ett alternativ till mer komplexa och mindre effektiva metoder som att använda PInvoke. För mer information, se Översikt över marshaling i C++.

ATL-server

ATL Server släpps som ett projekt med delad källa.
Merparten av ATL Server-kodbasen har släppts som ett delat källprojekt på CodePlex och är inte installerat som en del av Visual Studio 2008. Flera filer som är associerade med ATL Server ingår inte längre i Visual Studio. Listan över borttagna filer finns i Borttagna ATL-serverfiler.
Datakodnings- och avkodningsklasser från atlenc.h och verktygsfunktioner och klasser från atlutil.h och atlpath.h ingår nu i ATL-biblioteket.
Microsoft kommer att fortsätta att stödja versioner av ATL Server som ingår i tidigare versioner av Visual Studio så länge dessa versioner av Visual Studio stöds. CodePlex fortsätter att utveckla ATL Server-koden som ett communityprojekt. Microsoft stöder inte en CodePlex-version av ATL Server.

Visual C++ Kompilator och Länkare

Ändringar i kompilatorn

Kompilatorn stöder hanterade inkrementella versioner. När du anger det här alternativet kommer kompilatorn inte att kompilera om koden när en refererad sammansättning ändras. Istället kommer det att göra en inkrementell kompilering. Filer kompileras endast om ändringarna påverkar den beroende koden.
Attribut som är relaterade till ATL Server stöds inte längre. Kompilatorn stöder inte längre flera attribut som var direkt relaterade till ATL Server. För en komplett lista över borttagna attribut, se brytande ändringar.
Kompilatorn stöder Intel Core-mikroarchitecture. Kompilatorn innehåller justering för Intel Core-mikroarkitekturen under kodgenereringen. Som standard är den här justeringen på och kan inte inaktiveras eftersom den även hjälper Pentium 4 och andra processorer.
Intrinsics stöder nyare AMD- och Intel-processorer. Flera nya inbyggda instruktioner stöder större funktioner i nyare AMD- och Intel-processorer. Mer information om de nya intrinsiska funktionerna finns i Tillägg för streaming SIMD-instruktioner 3, SIMD-strömnings-tillägg 4 instruktioner, SSE4A- och Advanced Bit Manipulation-instrinsiska funktioner, AES-intrinsiska funktioner, _mm_clmulepi64_si128 och __rdtscp.
Funktionen __cpuid uppdateras. Funktionerna __cpuid, __cpuidex stöder nu flera nya funktioner från de senaste revisionerna av AMD- och Intel-processorer. Den nya __cpuidex inbyggda samlar in mer information hos de senaste processorerna.
Kompilatoralternativet /MP minskar den totala byggtiden. Alternativet /MP kan avsevärt minska den totala tiden för att kompilera flera källfiler genom att skapa flera processer som kompilerar filerna samtidigt. Det här alternativet är särskilt användbart på datorer som stöder hypertrådning, flera processorer eller flera kärnor.
Kompilatoralternativet /Wp64 och __w64 nyckelordet är inaktuella. Kompilatoralternativet /Wp64 och __w64 nyckelordet, som identifierar 64-bitars portabilitetsproblem, är inaktuella och tas bort i en framtida version av kompilatorn. I stället för det här kompilatoralternativet och nyckelordet använder du en MSVC som riktar sig mot en 64-bitars plattform.
/Qfast_transcendentals genererar infogad kod för transcendentala funktioner.
/Qimprecise_fwaits tar bort de interna fwait-kommandona för att prova block när du använder kompileringsalternativet /fp:except .

Linker-ändringar

Information om användarkontokontroll är nu inbäddad i manifestfiler för exekverbara filer av Visual C++-länkare (link.exe). Den här funktionen är aktiverad som standard. Mer information om hur du inaktiverar den här funktionen eller hur du ändrar standardbeteendet /MANIFESTUAC finns i (Bäddar in UAC-information i manifestet).
Länkaren har nu alternativet /DYNAMICBASE för att aktivera funktionen Adressutrymmeslayoutens slumpmässiga fördelning i Windows Vista. Det här alternativet ändrar rubriken för en körbar fil för att ange om programmet ska vara slumpmässigt ombaserat vid inläsning.

Nyheter för C++ i Visual Studio 2005

Följande funktioner var nya i Visual C++ 2005 Service Pack 1:

Intrinsiska funktioner för x86 och x64

__stoppa
__lidt
__Nop
__readcr8
__sidt
__svm_clgi
__svm_invlpga
__svm_skinit
__svm_stgi
__svm_vmload
__svm_vmrun
__svm_vmsave
__ud2
__vmx_off
__vmx_vmptrst
__writecr8

Endast instruktioner för x64

__vmx_on
__vmx_vmclear
__vmx_vmlaunch
__vmx_vmptrld
__vmx_vmread
__vmx_vmresume
__vmx_vmwrite

Nyckelord för nytt språk

__sptr, __uptr

Nya kompilatorfunktioner

Kompilatorn har icke-bakåtkompatibla ändringar i den här versionen.

64-bitars interna och korskompilatorer.
/analyze Kompilatoralternativet (Enterprise Code Analysis) har lagts till.
/bigobj kompilatoralternativet har lagts till.
/clr:pure, /clr:safeoch /clr:oldSyntax har lagts till. (Senare inaktuell i Visual Studio 2015 och togs bort i Visual Studio 2017.)
Inaktuella kompilatoralternativ: många kompilatoralternativ har blivit inaktuella i den här versionen. Mer information finns i Inaktuella kompilatoralternativ .
Dubbel thunking i /clr-koden minskas; se Double Thunking (C++) för mer information.
/EH (Undantagshanteringsmodell) eller /EHs kan inte längre användas för att fånga upp ett undantag som genereras med något annat än ett kast. Använd /EHa.
/errorReport Kompilatoralternativet (Rapport interna kompilatorfel) har lagts till.
/favor Kompilatoralternativet (Optimera för 64) har lagts till.
/FA, /Fa-kompilatoralternativet (listningsalternativet för filer) har lagts till.
/FC Kompilatoralternativet (fullständig sökväg för källkodsfil i diagnostik) har lagts till.
/fp Kompilatoralternativet (Ange Floating-Point beteende) har lagts till.
/G (Optimera för processor) kompilatoralternativ har lagts till.
/G (Optimera för processor) kompilatoralternativ har lagts till.
/G3, /G4, /G5, /G6, /G7 och /GB kompilatoralternativ har tagits bort. Kompilatorn använder nu en "blandad modell" som försöker skapa den bästa utdatafilen för alla arkitekturer.
/Gf har tagits bort. Använd /GF (Eliminera dubblettsträngar) i stället.
/GL (Hela programoptimeringen) är nu kompatibel med /CLRHEADER.
/GR är nu aktiverat som standard.
/GS (Buffertsäkerhetskontroll) ger nu säkerhetsskydd för sårbara pekarparametrar. /GS är nu aktiverat som standard. /GS fungerar nu även på funktioner som kompilerats till MSIL med /clr (Common Language Runtime Compil).
/homeparams Kompilatoralternativet (Kopiera registerparametrar till Stack) har lagts till.
/hotpatch Kompilatoralternativet (Skapa snabbkorrigeringsbar avbildning) har lagts till.
Inlinefunktionsheuristik har uppdaterats; se inline, __inline__forceinline och inline_depth för mer information
Många nya inbyggda funktioner har lagts till och många tidigare odokumenterade inbyggda funktioner dokumenteras nu.
Som standard utlöser alla anrop till nya som misslyckas ett undantag.
Komilatoralternativen /ML och /MLd har tagits bort. Visual C++ stöder inte längre stöd för enkeltrådade, statiskt länkade CRT-bibliotek.
Kompilatorn implementerade den namngivna optimeringen av returvärde, som aktiveras när du kompilerar med /O1, /O2 (Minimera storlek, Maximera hastighet), /Og (globala optimeringar) och /Ox (fullständig optimering).
/Oa kompilatoralternativet har tagits bort men kommer att ignoreras utan meddelande; använd modifierarna noalias eller restrict__declspec för att specificera hur kompilatorn hanterar alias.
/Op kompilatoralternativet hade tagits bort. Använd /fp (Ange Floating-Point beteende) i stället.
OpenMP stöds nu av Visual C++.
/openmp Kompileringsalternativet (Aktivera OpenMP 2.0 Support) har lagts till.
/Ow kompilatoralternativet har tagits bort men ignoreras tyst. Använd noalias- eller restrict__declspec-modifierare för att specificera hur kompilatorn hanterar aliasing.

Profile-Guided optimeringar

/QI0f har tagits bort.
/QIfdiv har tagits bort.
/QIPF_B Kompilatoralternativet (Errata för B CPU Stepping) har lagts till.
/QIPF_C Kompilatoralternativet (Errata för C CPU Stepping) har lagts till.
/QIPF_fr32 Kompilatoralternativet (Använd inte de översta 96 flyttalsregistren) har lagts till.
/QIPF_noPIC Kompilatoralternativet (Generera position beroende kod) har lagts till.
/QIPF_restrict_plabels Kompilatoralternativet (Anta att inga funktioner har skapats vid körning) har lagts till.

Unicode-stöd i kompilatorn och Linker

/vd (Inaktivera konstruktionsförskjutningar) låter dig nu använda dynamic_cast-operator på ett objekt som håller på att konstrueras (/vd2)
/YX kompilatoralternativet har tagits bort. Använd /Yc (Skapa fördefinierad rubrikfil) eller /Yu (Använd förkompilerad rubrikfil) i stället. Om du tar bort /YX från dina byggkonfigurationer och ersätter dem med ingenting kan det resultera i snabbare versioner.
/Zc:forScope är nu aktiverat som standard.
/Zc:wchar_t är nu aktiverat som standard.
/Zd kompilatoralternativet har tagits bort. Felsökningsinformation för endast radnummer stöds inte längre. Använd /Zi i stället (se /Z7, /Zi, /ZI (felsökningsinformationsformat) för mer information).
/Zg är nu endast giltigt för C-källkodsfiler och inte på C++-källkodsfiler.
/Zx Kompilatoralternativet (Felsöka optimerad Itanium Code) har lagts till.

Nya språkfunktioner

Attributeattributet är nu inaktuellt.
appdomain__declspec en modifier har lagts till.
__clrcall anropskonventionen har lagts till.
Med den inaktuella (C++) declspec-modifieraren kan du nu ange en sträng som ska visas vid kompileringstiden, när en användare försöker komma åt en inaktuell klass eller funktion.
dynamic_cast Operatorn har störande ändringar.
Med interna uppräkningar kan du nu ange den underliggande typen.
jitintrinsicdeclspec en modifier har lagts till.
noaliasdeclspec en modifier har lagts till.
process__declspec en modifier har lagts till.
abstrakt, override och sealed är giltiga för nativer kompileringar.
__restrict nyckelordet har lagts till.
restrictdeclspec en modifier har lagts till.
__thiscall är nu ett nyckelord.
__unaligned nyckelordet är nu dokumenterat.
volatile (C++) har uppdaterat beteendet när det gäller optimeringar.

Nya funktioner för förprocessor

__CLR_VER fördefinierat makro har lagts till.
Pragman (C/C++) accepterar nu /MANIFESTDEPENDENCY som en länkkommentar. Alternativet exestr för att kommentera är nu föråldrat.
embedded_idl attributet (direktivet #import ) tar nu en valfri parameter.
fenv_access pragma
float_control pragma
fp_contract pragma
Globala variabler initieras inte i den ordning de deklareras om du har globala variabler i pragmahanterade, ohanterade och ohanterade avsnitt. Detta är ett potentiellt kompatibilitetsbrott om till exempel en icke-hanterad global variabel initieras med en administrerad global variabel och ett fullständigt konstruerat administrerat objekt krävs.
Avsnitt som anges med init_seg är nu skrivskyddade, och inte läs-/skrivbara som i tidigare versioner.
inline_depth standard är nu 16. Standardvärdet 16 var också i kraft i Visual C++ .NET 2003.
_INTEGRAL_MAX_BITS fördefinierat makro som lagts till finns i Fördefinierade makron.
_M_CEE, _M_CEE_PURE och _M_CEE_SAFE fördefinierade makron som lagts till finns i Fördefinierade makron.
_M_IX86_FP fördefinierat makro har lagts till.
_M_X64 fördefinierat makro har lagts till.
make_public pragma
managed, unmanaged pragmasyntaxen har uppdaterats (har push nu och pop)
mscorlib.dll refereras nu implicit av direktivet #using i alla /clr kompileringar.
_OPENMP fördefinierat makro har lagts till.
optimera pragma har uppdaterats, a och w är inte längre giltiga parametrar.
no_registry#import-attributet har lagts till.
region, endregion pragmas har lagts till
_VC_NODEFAULTLIB fördefinierat makro har lagts till.
Variadiska makron har nu implementerats.
vtordisp är inaktuell och tas bort i en framtida version av Visual C++.
warning pragma har nu undertrycksspecificeraren.

Nya Linker-funktioner

Moduler (MSIL-utdatafiler som inte är assembly) tillåts nu som indata till linkern.
/ALLOWISOLATION Länkalternativet (ManifestSökning) har lagts till.
/ASSEMBLYRESOURCE (Bädda in en hanterad resurs) har uppdaterats så att du nu kan ange namnet på resursen i sammansättningen och ange att resursen är privat i sammansättningen.
/CLRIMAGETYPE (Ange typ av CLR-avbildning) har lagts till som länkalternativ.
/CLRSUPPORTLASTERROR (Alternativet Bevara senaste felkod för PInvoke-anrop) har lagts till.
/CLRTHREADATTRIBUTE Länkalternativet (Ange CLR-trådattribut) har lagts till.
/CLRUNMANAGEDCODECHECK länkalternativet (Add SuppressUnmanagedCodeSecurityAttribute) har lagts till.
/ERRORREPORT Länkalternativet (Rapportera interna länkfel) har lagts till.
/EXETYPE linker-alternativet har tagits bort. Länkaren har inte längre stöd för att skapa drivrutiner för Windows 95- och Windows 98-enheter. Använd en lämplig DDK för att skapa dessa enhetsdrivrutiner. EXETYPE-nyckelordet är inte längre giltigt för moduldefinitionsfiler.
/FUNCTIONPADMIN Länkalternativet (Skapa en bild som kan snabbkorrigeras) har lagts till.
/LTCG linker-alternativet stöds nu på moduler som kompilerats med /clr. /LTCG har också uppdaterats för att stödja profilstyrda optimeringar.
/MANIFEST -länkalternativet (Skapa Side-by-Side Assembly Manifest) har lagts till.
/MANIFESTDEPENDENCY Länkalternativet (Ange manifestberoenden) har lagts till.
/MANIFESTFILE Länkalternativet (Namnmanifestfil) har lagts till.
/MAPINFO:LINES linker-alternativet har tagits bort.
/NXCOMPAT Länkalternativet (kompatibelt med datakörningsskydd) har lagts till.
/PGD (Ange databas för Profile-Guided Optimeringar) har lagts till.
/PROFILE-länkalternativet "Performance Tools Profiler" har lagts till.
/SECTION (Alternativet Ange avsnittsattribut) stöder nu attributnegering och stöder inte längre attributen L eller D (VxD-relaterade).
Unicode-stöd i kompilatorn och Linker
/VERBOSE Länkalternativet (Skriv ut förloppsmeddelanden) accepterar nu även ICF och REF.
/VXD linker-alternativet har tagits bort. Länkaren har inte längre stöd för att skapa drivrutiner för Windows 95- och Windows 98-enheter. Använd en lämplig DDK för att skapa dessa enhetsdrivrutiner. VXD-nyckelordet är inte längre giltigt för moduldefinitionsfiler.
/WS linker-alternativet har tagits bort. /WS användes för att ändra bilder för Windows NT 4.0. IMAGECFG.exe -R filnamn kan användas i stället för /WS. IMAGECFG.exe finns på Windows NT 4.0-CD-ROM i SUPPORT\DEBUG\I386\IMAGECFG.EXE.
/WX (Alternativet Behandla Linker-varningar som fel) är nu dokumenterat.

Nya linker-verktygsfunktioner

/ALLOWISOLATION editbin-alternativet hade lagts till
Beskrivningsmodulens definitionsfiluttryck tas bort. Länkaren har inte längre stöd för att skapa virtuella enhetsdrivrutiner.
/ERRORREPORT-alternativ har lagts till i bscmake.exe, dumpbin.exe, editbin.exeoch lib.exe.
/LTCG lib-alternativet har lagts till.
/NXCOMPAT alternativet editbin har lagts till.
/RANGE dumpbin-alternativet har lagts till.
/TLS dumpbin-alternativet har lagts till.
/WS alternativet editbin har tagits bort. /WS användes för att ändra bilder för Windows NT 4.0. IMAGECFG.exe -R filnamn kan användas i stället för /WS. IMAGECFG.exe finns på Windows NT 4.0-CD-ROM i SUPPORT\DEBUG\I386\IMAGECFG.EXE.
Alternativet /WX[:NO] lib har lagts till.

Nya NMAKE-funktioner

/ERRORREPORT har lagts till.
/G har lagts till.
De fördefinierade reglerna har uppdaterats.
Makrot $(MAKE), som dokumenteras i Rekursionsmakron, ger nu den fullständiga sökvägen till nmake.exe.

Nya MASM-funktioner

MASM-uttryck är nu 64-bitarsvärden. I tidigare versioner var MASM-uttryck 32-bitarsvärden.
Instruktionen __asm int 3 gör nu att en funktion kompileras till native.
ALIAS (MASM) är nu dokumenterat.
/ERRORREPORT ml.exe och ml64.exe alternativet läggs till.
.FPO är nu dokumenterat.
H2INC.exe levereras inte i Visual C++ 2005. Om du behöver fortsätta att använda H2INC använder du H2INC.exe från en tidigare version av Visual C++.
operatorn IMAGEREL har lagts till.
operatorn HIGH32 har lagts till.
operatorn LOW32 har lagts till.
ml64.exe är en version av MASM för x64-arkitekturen. Den monterar x64 .asm-filer i x64-objektfiler. Inbäddad assemblerspråk stöds inte i x64-kompilatorn. Följande MASM-direktiv har lagts till för ml64.exe (x64):
. ALLOCSTACK
. ENDPROLOG
. PUSHFRAME
. PUSHREG
. SAVEREG
. SAVEXMM128
. SETFRAME Dessutom uppdaterades PROC-direktivet med endast x64-syntax.
MMWORD-direktivet har lagts till
/omf (ML.exe kommandoradsalternativ) innebär nu /c. ML.exe stöder inte länkning av OMF-formatobjekt.
SEGMENT-direktivet stöder nu ytterligare attribut.
operatorn SECTIONREL har lagts till.
XMMWORD-direktivet har lagts till

Nya CRT-funktioner

Säkra versioner av flera funktioner har lagts till. Dessa funktioner hanterar fel på ett bättre sätt och tillämpar striktare kontroller på buffertar för att undvika vanliga säkerhetsbrister. De nya säkra versionerna identifieras av suffixet _s .
Befintliga mindre säkra versioner av många funktioner har blivit inaktuella. Om du vill inaktivera utfasningsvarningarna definierar du _CRT_SECURE_NO_WARNINGS.
Många befintliga funktioner verifierar nu sina parametrar och anropar den ogiltiga parameterhanteraren när en ogiltig parameter skickas.
Många befintliga funktioner har nu angetts errno där de inte gjorde det tidigare.
Typedef errno_t med typ heltal har lagts till. errno_t används när en funktionsreturtyp eller parameter hanterar felkoder från errno. errno_t ersätter errcode.
Språkberoende funktioner har nu versioner som tar språkvarianten som en parameter i stället för att använda det aktuella nationella språket. Dessa nya funktioner har _l-suffixet. Flera nya funktioner har lagts till för att arbeta med språkvariantobjekt. Nya funktioner är _get_current_locale, _create_locale och _free_locale.
Nya funktioner har lagts till för att stödja låsning och upplåsning av filhandtag.
Funktionsfamiljen _spawn återställer inte errno till noll vid framgång, som i tidigare versioner.
Versioner av serien printf med funktioner som gör att du kan ange i vilken ordning argumenten används är tillgängliga.
Unicode är nu ett textformat som stöds. Funktionen _open stöder attributen _O_TEXTW, _O_UTF8 och _O_UTF16. Funktionen fopen stöder metoden "ccs=ENCODING" för att ange ett Unicode-format.
En ny version av CRT-biblioteken som är inbyggda i hanterad kod (MSIL) är nu tillgänglig och används vid kompilering med /clr alternativet (Common Language Runtime Compil).
_fileinfo har tagits bort.
Standardstorleken för time_t är nu 64 bitar, vilket utökar intervallet time_t för och flera av tidsfunktionerna till år 3000.
CRT stöder nu inställning av nationella inställningar per tråd. Funktionen _configthreadlocale har lagts till för att stödja den här funktionen.
Funktionerna _statusfp2 och __control87_2 har lagts till för att tillåta åtkomst till och kontroll över flyttalskontrollordet på både x87- och SSE2-flyttalsprocessorn.
Funktionerna _mkgmtime och _mkgmtime64 har lagts till för att ge stöd för konverteringstider (struct tm) till Greenwich Mean Time (GMT).
Ändringar har gjorts i swprintf och vswprintf för att bättre överensstämma med standarden.
En ny rubrikfil, INTRIN. H, tillhandahåller prototyper för vissa inbyggda funktioner.
Funktionen fopen har nu ett N-attribut.
Funktionen _open har nu ett _O_NOINHERIT attribut.
Funktionen atoi returnerar nu INT_MAX och ställer in errno på ERANGE vid spill. I tidigare versioner var spillbeteendet odefinierat.
Serien printf med funktioner stöder hexadecimala flyttalsutdata som implementeras enligt ANSI C99-standarden med formattypsspecificerarna %a och %A.
Familjen printf stöder nu storleksprefixet "ll" (långt långt).
Funktionen _controlfp har optimerats för bättre prestanda.
Felsökningsversioner av vissa funktioner har lagts till.
Lade till _chgsignl och _cpysignl (långa dubbla versioner).
Typ _locale_t har lagts till i typtabellen.
Nytt makro makro _countof har lagts till för beräkning av antalet element i en matris.
I varje funktionsavsnitt har ett avsnitt om .NET Framework-motsvarigheter lagts till.
Flera strängfunktioner har nu möjlighet att trunkera strängar i stället för att misslyckas när utdatabuffertar är för små. se _TRUNCATE.
_set_se_translator kräver nu att kompileringsalternativet /EHa används.
fpos_t är nu __int64 under /Za (för C-kod) och när __STDC__ anges manuellt (för C++-kod). Det brukade vara en struct.
_CRT_DISABLE_PERFCRIT_LOCKS kan förbättra I/O-prestanda för entrådade program.
POSIX-namn har blivit inaktuella till förmån för ISO C++-överensstämmande namn (till exempel använd _getch i stället getchför ).
Nya länkalternativ för .obj-filer är tillgängliga för rent läge
_recalloc kombinerar funktioner i realloc och calloc.

Nyheter för C++ i Visual Studio 2003

Kompilator

Information om hur du kör ett hanterat tillägg för C++-program som skapats med den aktuella versionens kompilator i en tidigare version av körningen.
Vanliga frågor och svar om hanterade tillägg för C++.
En genomgång har lagts till som visar hur du porterar ett befintligt, inbyggt program för att använda hanterade tillägg för C++: Genomgång: Portera ett befintligt internt C++-program för att samverka med .NET Framework-komponenter.
Nu kan du skapa en delegat för en värdetypsmetod.
Kompilatorns överensstämmelse med C++-standarden har förbättrats avsevärt för Visual C++ .NET 2003.
/arch kompilatoralternativet läggs till.
/Gf är inaktuell och tas bort i nästa version av Visual C++.
/G7 kompilatoralternativet läggs till.
Kompileringsalternativet /GS har förbättrats för att skydda lokala variabler från direkta buffertöverskridanden.
Kompilatoralternativet /noBool har tagits bort. Kompilatorn kan bool nu bara visas som ett nyckelord (och inte som en identifierare) i en C++-källkodsfil.
Typen long long är nu tillgänglig som en typedef av __int64 Observera att det ännu inte finns stöd för long long i CRT.
Kompileringsalternativet /Zm anger nu den förkompilerade huvudfilens minnesallokeringsgräns.
_InterlockedCompareExchange inbyggda nu dokumenterade.
_Den intrinsiska _InterlockedDecrement är nu dokumenterad.
_InterlockedExchange inbyggd nu dokumenterad.
_Dokumentationen för _InterlockedExchangeAdd intrinsic har nu publicerats._
Det inbyggda _InterlockedIncrement är nu dokumenterad.
_ReadWriteBarrier tillagt.

Egenskaper

implements -attributet är nu dokumenterat.

Linker-funktioner

Följande länkväxlar har lagts till:

/ASSEMBLYDEBUG
/ASSEMBLYLINKRESOURCE
DELAYSIGN
/KEYFILE
/KEYCONTAINER
/SAFESEH

MASM

Den SAFESEH-direktivet och /safeseh ml.exe-alternativ har lagts till.

Se även

Visual C++ Porting and Upgrading Guide

Feedback

Var den här sidan till hjälp?

Dela via

Visual C++ Nyheter 2003 till och med 2015

Nyheter för C++ i Visual Studio 2015

Anpassningsförbättringar i Visual Studio 2015

Efterlevnadsförbättringar i Visual Studio 2015 Update 1

Överensstämmelseförbättringar i Visual Studio 2015 Update 2

Anpassningsförbättringar i Visual Studio 2015 Update 3

Nyheter för C++ i Visual Studio 2013

Förbättrat stöd för ISO C/C++-standarder

Kompilator

C99-bibliotek

Standardmallbibliotek

Brytande förändringar

Förbättringar av Visual C++-bibliotek

C++-programprestanda

PGO-förbättringar (Profile Guided Optimization)

Utvecklingsstöd för Windows Runtime-appar

Diagnostikförbättringar

3D-grafikförbättringar

IDE och produktivitet

Nyheter för C++ i Visual Studio 2012

Förbättrat stöd för C++11-standarder

Standardmallbibliotek

Andra C++11-förbättringar

Utvecklingsstöd för Windows Runtime-appar

Kompilator och länkare

Nytt i Visual Studio 2012 Update 1

Stöd för parallell programmering

C++ Accelererad massiv parallellitet (AMP)

Allmänna förbättringar av parallell programmering

Allmänna förbättringar av parallell felsökning

IDE

Verktyg för programlivscykelhantering

Analys av statisk kod

Uppdaterat enhetstestramverk

Diagram över arkitekturberoende

Arkitekturexplorer

Kodtäckning

Nyheter för C++ i Visual Studio 2010

C++ Compiler och Linker

Visual Studio C++-projekt och byggsystemet

Visual C++-bibliotek

Microsoft Foundation-klassbiblioteket (MFC)

SafeInt-bibliotek

Nya ATL-makron (Active Template Library)

/analysera varningar

Stöd för animering och D2D

IDE

Arbetsredskap

Referens för Microsoft Macro Assembler

Nyheter för C++ i Visual Studio 2008

Visual C++ Integrated Development Environment (IDE)

Visual C++-bibliotek

Allmänt

STL/CLR-bibliotek

MFC-bibliotek

C++-supportbibliotek

ATL-server

Visual C++ Kompilator och Länkare

Ändringar i kompilatorn

Linker-ändringar

Nyheter för C++ i Visual Studio 2005

Intrinsiska funktioner för x86 och x64

Endast instruktioner för x64

Nyckelord för nytt språk

Nya kompilatorfunktioner

Profile-Guided optimeringar

Unicode-stöd i kompilatorn och Linker

Nya språkfunktioner

Nya funktioner för förprocessor

Nya Linker-funktioner

Nya linker-verktygsfunktioner

Nya NMAKE-funktioner

Nya MASM-funktioner

Nya CRT-funktioner

Nyheter för C++ i Visual Studio 2003

Kompilator

Egenskaper

Linker-funktioner

MASM