Novinky ve Visual C++ 2003–2015

Článek
10/12/2023

Tato stránka shromažďuje všechny stránky "Co je nového" pro všechny verze Visual C++ ze sady Visual Studio 2015 zpět do roku 2003. Tyto informace jsou k dispozici jako pohodlí pro případ, že by mohly být užitečné při upgradu ze starších verzí sady Visual Studio.

Poznámka:

Informace o aktuální verzi sady Visual Studio naleznete v tématu Co je nového pro Visual C++ v sadě Visual Studio a vylepšení shody v sadě Visual C++ v sadě Visual Studio.

Co je nového v jazyce C++ v sadě Visual Studio 2015

V sadě Visual Studio 2015 a novějších může probíhající vylepšení souladu kompilátoru někdy změnit způsob, jakým kompilátor rozumí vašemu existujícímu zdrojovému kódu. Když k tomu dojde, můžete během sestavení narazit na nové nebo jiné chyby nebo dokonce na rozdíly v chování v kódu, který jste dříve vytvořili a zdáli se, že jsou správně spuštěné.

Naštěstí tyto rozdíly mají malý nebo žádný vliv na většinu zdrojového kódu a pokud jsou k vyřešení těchto rozdílů potřeba zdrojový kód nebo jiné změny, opravy jsou obvykle malé a jednoduché. Zahrnuli jsme mnoho příkladů dříve přijatelného zdrojového kódu, které by mohly být potřeba změnit (před) a opravy pro jejich opravu (po).

I když tyto rozdíly můžou ovlivnit zdrojový kód nebo jiné artefakty sestavení, nemají vliv na binární kompatibilitu mezi aktualizacemi verzí Visual C++. Složitější druh změny, zásadní změna může ovlivnit binární kompatibilitu, ale tyto druhy přerušení binární kompatibility se vyskytují pouze mezi hlavními verzemi visual C++. Například mezi Visual C++ 2013 a Visual C++ 2015. Informace o zásadních změnách, ke kterým došlo mezi Visual C++ 2013 a Visual C++ 2015, najdete v tématu Historie změn visual C++ 2003 – 2015.

Vylepšení shody v sadě Visual Studio 2015
Vylepšení shody v sadě Visual Studio 2015 Update 1
Vylepšení shody v sadě Visual Studio 2015 Update 2
Vylepšení shody v sadě Visual Studio 2015 Update 3

Vylepšení shody v sadě Visual Studio 2015

/Zc:forScope- možnost

Možnost /Zc:forScope- kompilátoru je zastaralá a bude odebrána v budoucí verzi.
```
  Command line warning  D9035: option 'Zc:forScope-' has been deprecated and will be removed in a future release
```
Možnost se obvykle používala k povolení nestandardního kódu, který používá proměnné smyčky za bodem, kde by podle standardu měly být mimo rozsah. Bylo nutné pouze při kompilaci s /Za možností, protože bez /Zapoužití proměnné smyčky for po ukončení smyčky je vždy povoleno. Pokud vás nezajímá shoda se standardy (například pokud váš kód nemá být přenositelný do jiných kompilátorů), můžete tuto možnost vypnout /Za (nebo nastavit vlastnost Disable Language Extensions na Ne). Pokud vás zajímá psaní přenosného kódu vyhovujícího standardům, měli byste kód přepsat tak, aby odpovídal standardu přesunutím deklarace těchto proměnných do bodu mimo smyčku.
```
  // 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
  }
```
Možnost kompilátoru Zg.

Možnost kompilátoru /Zg (Generování prototypů funkcí) už není dostupná. Tato možnost kompilátoru byla dříve zastaralá.
Testy jednotek s C++/CLI už nemůžete spouštět z příkazového řádku s mstest.exe. Místo toho použijte vstest.console.exe.
proměnlivé klíčové slovo.

mutable Specifikátor třídy úložiště už není povolený na místech, kde se dříve zkompiloval bez chyby. Kompilátor teď zobrazí chybu C2071 (neplatná třída úložiště). Podle standardu lze měnitelný specifikátor použít pouze na názvy datových členů třídy a nelze jej použít u názvů deklarovaných const nebo static a nelze jej použít pro referenční členy.

Představte si například následující kód:
```
  struct S {
      mutable int &r;
  };
```
Předchozí verze kompilátoru jazyka Microsoft C++ tuto možnost přijali, ale teď kompilátor zobrazí následující chybu:
```
  error C2071: 'S::r': illegal storage class
```
Pokud chcete chybu opravit, jednoduše odeberte redundantní mutable klíčové slovo.
char_16_t a char32_t

V typedef už nemůžete používat char16_t aliasy, char32_t protože tyto typy jsou teď považovány za předdefinované. Pro uživatele a autory knihoven bylo běžné definovat char16_t a char32_t jako aliasy uint16_t a uint32_tv uvedeném pořadí.
```
  #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;
  }
```
Chcete-li aktualizovat kód, odeberte typedef deklarace a přejmenujte všechny ostatní identifikátory, které s těmito názvy kolidují.
Parametry šablony bez typu

Při zadávání explicitních argumentů šablony se teď správně kontroluje kompatibilita typů s určitým kódem, který zahrnuje parametry šablony jiného typu. Například následující kód se zkompiloval bez chyby v předchozích verzích 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>();
  }
```
Aktuální kompilátor správně zobrazí chybu, protože typ parametru šablony neodpovídá argumentu šablony (parametr je ukazatel na člen const, ale funkce f není const):
```
  error C2893: Failed to specialize function template 'void S2::f(void)'note: With the following template arguments:note: 'C=S1'note: 'Function=S1::f'
```
Pokud chcete tuto chybu vyřešit v kódu, ujistěte se, že typ argumentu šablony, který používáte, odpovídá deklarovanému typu parametru šablony.
__declspec(align)

Kompilátor už nepřijímá __declspec(align) funkce. To bylo vždy ignorováno, ale teď generuje chybu kompilátoru.
```
  error C3323: 'alignas' and '__declspec(align)' are not allowed on function declarations
```
Chcete-li tento problém vyřešit, odeberte __declspec(align) z deklarace funkce. Vzhledem k tomu, že neměl žádný vliv, odebrání nic nemění.
Ošetření výjimek

Zpracování výjimek má několik změn. Za prvé, objekty výjimek musí být buď kopírovatelné nebo pohyblivé. Následující kód zkompilovaný v sadě Visual Studio 2013, ale nekompiluje se v sadě Visual Studio 2015:
```
  struct S {
  public:
      S();
  private:
      S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Problémem je, že konstruktor kopírování je soukromý, takže objekt nelze zkopírovat stejně jako v normálním průběhu zpracování výjimky. Totéž platí při deklaraci explicitkonstruktoru kopírování .
```
  struct S {
      S();
      explicit S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Chcete-li aktualizovat kód, ujistěte se, že copy konstruktor pro váš objekt výjimky je veřejný a není označen explicit.

Zachycení výjimky podle hodnoty také vyžaduje, aby objekt výjimky byl kopírovatelný. Následující kód zkompilovaný v sadě Visual Studio 2013, ale nekompiluje se v sadě Visual Studio 2015:
```
  struct B {
  public:
      B();
  private:
      B(const B &);
  };

  struct D : public B {
  };

  int main()
  {
      try
      {
      }
      catch (D d) // error
      {
      }
  }
```
Tento problém můžete vyřešit změnou typu parametru catch pro odkaz na odkaz.
```
  catch(D& d)
  {
  }
```
Řetězcové literály následované makry

Kompilátor teď podporuje literály definované uživatelem. V důsledku toho se řetězcové literály následované makry bez jakéhokoli zásahu prázdných znaků interpretují jako literály definované uživatelem, což může vést k chybám nebo neočekávaným výsledkům. Například v předchozích kompilátorech se následující kód úspěšně zkompiloval:
```
  #define _x "there"
  char* func() {
      return "hello"_x;
  }
  int main()
  {
      char * p = func();
      return 0;
  }
```
Kompilátor to interpretoval jako řetězcový literál "hello" následovaný makrem, které je rozbalené "tam", a pak byly dva řetězcové literály zřetězeny do jednoho. Kompilátor v sadě Visual Studio 2015 to interpretuje jako literál definovaný uživatelem, ale protože neexistuje odpovídající literál definovaný uživatelem, _x definovaný, zobrazí chybu.
```
  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?
```
Chcete-li tento problém vyřešit, přidejte mezeru mezi řetězcový literál a makro.
Sousední řetězcové literály

Podobně jako v předchozím případě se vzhledem ke souvisejícím změnám analýzy řetězců v sousedních řetězcových literálech (širokých nebo úzkých znakových literálech) bez prázdných znaků interpretovaly jako jediný zřetězený řetězec v předchozích verzích Visaul C++. V sadě Visual Studio 2015 teď musíte mezi dva řetězce přidat prázdné znaky. Například musí být změněn následující kód:
```
  char * str = "abc""def";
```
Stačí mezi dva řetězce přidat mezeru.
```
  char * str = "abc" "def";
```
Nové umístění a odstranění

Operátor provedl delete změnu, aby ji mohl převést do souladu se standardem C++14. Podrobnosti o změně standardů najdete v sadě C++ Sized Deallocation. Změny přidávají formu globálního delete operátoru, který přebírá parametr velikosti. Změna způsobující chybu spočívá v tom, že pokud jste dříve používali operátor delete se stejným podpisem (aby odpovídal novému operátoru umístění), zobrazí se chyba kompilátoru (C2956, ke kterému dochází v okamžiku , kdy se použije nové umístění, protože se jedná o pozici v kódu, kde se kompilátor pokusí identifikovat odpovídající delete operátor).

Funkce void operator delete(void *, size_t) byla operátorem odstranění umístění, který odpovídá nové funkci void * operator new(size_t, size_t) umístění v jazyce C++11. U zrušení přidělení velikosti C++14 je tato delete funkce nyní obvyklou funkcí deallocation (globální delete operátor). Standard vyžaduje, aby pokud použití umístění nové vyhledá odpovídající delete funkci a najde obvyklou funkci přidělení, program je špatně vytvořen.

Předpokládejme například, že váš kód definuje nové umístění i odstranění umístění:
```
  void * operator new(std::size_t, std::size_t);
  void operator delete(void*, std::size_t) noexcept;
```
K problému dochází z důvodu shody v podpisech funkce mezi operátorem odstranění umístění, který jste definovali, a novým operátorem globální velikosti delete . Zvažte, jestli můžete použít jiný typ než size_t pro jakékoli nové umístění a delete operátory. Všimněte si, že typ kompilátoru size_ttypedef je závislý; je typedef to pro unsigned int v jazyce Visual C++. Dobrým řešením je použít výčtový typ, například:
```
  enum class my_type : size_t {};
```
Potom změňte definici umístění new a delete použijte tento typ jako druhý argument místo size_t. Budete také muset aktualizovat volání nového umístění tak, aby předala nový typ (například pomocí static_cast<my_type> převodu z celočíselné hodnoty) a aktualizovat definici new a delete přetypovat zpět na typ celého čísla. Pro tento typ není nutné použít enum . Typ třídy s size_t členem by také fungoval.

Alternativním řešením je, že můžete zcela eliminovat nové umístění . Pokud váš kód používá nové umístění pro implementaci fondu paměti, ve kterém je argument umístění velikost objektu přidělený nebo odstraněný, může být funkce přidělení velikosti vhodná k nahrazení vlastního kódu fondu paměti a můžete se zbavit funkcí umístění a použít pouze vlastní operátor dvou argumentů delete místo funkcí umístění.

Pokud nechcete kód okamžitě aktualizovat, můžete se vrátit ke starému chování pomocí možnosti /Zc:sizedDealloc-kompilátoru . Pokud použijete tuto možnost, funkce se dvěma argumenty delete neexistují a nezpůsobí konflikt s operátorem odstranění umístění.
Sjednocovat datové členy

Datové členy sjednocení už nemůžou mít odkazové typy. Následující kód byl úspěšně zkompilován v sadě Visual Studio 2013, ale v sadě Visual Studio 2015 dojde k chybě.
```
  union U1 {
      const int i;
  };
  union U2 {
     int &i;
  };
  union U3 {
      struct {int &i;};
  };
```
Předchozí kód generuje následující chyby:
```
  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
```
Pokud chcete tento problém vyřešit, změňte odkazové typy buď na ukazatel, nebo na hodnotu. Změna typu na ukazatel vyžaduje změny v kódu, který používá sjednocovací pole. Změna kódu na hodnotu by změnila data uložená ve sjednocení, což má vliv na jiná pole, protože pole v typech sjednocení sdílejí stejnou paměť. V závislosti na velikosti hodnoty může také změnit velikost sjednocení.

Anonymní sjednocení

jsou nyní více v souladu se standardem. Předchozí verze kompilátoru vygenerovaly explicitní konstruktor a destruktor pro anonymní sjednocení. Ty se odstraní v sadě Visual Studio 2015.

struct S {
    S();
};

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

Předchozí kód vygeneruje v sadě Visual Studio 2015 následující chybu:

  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

Pokud chcete tento problém vyřešit, zadejte vlastní definice konstruktoru nebo destruktoru.

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

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

Sjednocení s anonymními strukturami

Aby bylo možné splňovat standard, chování modulu runtime se změnilo pro členy anonymních struktur v sjednoceních. Konstruktor pro anonymní členy struktury ve sjednocení již není implicitně volána při vytvoření takové sjednocení. Destruktor pro anonymní členy struktury ve sjednocení se také implicitně nevolá, když sjednocení přejde mimo rozsah. Vezměte v úvahu následující kód, ve kterém sjednocení U obsahuje anonymní strukturu, která obsahuje člen, který je pojmenovaná struktura S, která má destruktor.

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

V sadě Visual Studio 2013 se při vytvoření sjednocení volá konstruktor pro S a při vyčištění zásobníku pro funkci f se volá destruktor pro S. V sadě Visual Studio 2015 se ale konstruktor a destruktor nevolají. Kompilátor zobrazí upozornění na tuto změnu chování.

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

Chcete-li obnovit původní chování, dejte anonymní struktuře název. Chování modulu runtime neanonymních struktur je stejné bez ohledu na verzi kompilátoru.

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

Případně zkuste přesunout konstruktor a destruktor kódu do nových funkcí a přidat volání těchto funkcí z konstruktoru a destruktoru pro sjednocení.

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

Rozlišení šablon

Změny překladu názvů pro šablony byly provedeny. V jazyce C++ může při zvažování kandidátů na překlad jména dojít k tomu, že jedna nebo více jmen, které je třeba vzít v úvahu jako potenciální shody, vytvoří neplatnou instanci šablony. Tyto neplatné instance obvykle nezpůsobují chyby kompilátoru, což je princip, který se označuje jako SFINAE (selhání nahrazení není chyba).

Pokud teď SFINAE vyžaduje, aby kompilátor vytvořil instanci specializace šablony třídy, všechny chyby, ke kterým dojde během tohoto procesu, jsou chyby kompilátoru. V předchozích verzích by kompilátor takové chyby ignoroval. Představte si například následující kód:
```
  #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);
  }
```
Pokud kompilujete s aktuálním kompilátorem, zobrazí se následující chyba:
```
  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
          ]
```
Důvodem je to, že v okamžiku prvního vyvolání is_base_of třída "D" ještě nebyla definována.

V tomto případě oprava nepoužívá takové vlastnosti typu, dokud není definována třída. Pokud přesunete definice B a D na začátek souboru kódu, chyba se vyřeší. Pokud jsou definice v souborech hlaviček, zkontrolujte pořadí příkazů include pro soubory hlaviček a ujistěte se, že jsou všechny definice tříd zkompilovány před tím, než se použijí problematické šablony.
Konstruktory kopírování

V sadě Visual Studio 2013 i Visual Studio 2015 kompilátor vygeneruje konstruktor kopírování pro třídu, pokud má tato třída konstruktor přesunutí definovaný uživatelem, ale žádný konstruktor kopírování definovaný uživatelem. V Dev14 je tento implicitně vygenerovaný konstruktor kopírování označen také jako "= delete".

Vylepšení shody v sadě Visual Studio 2015 Update 1

Privátní virtuální základní třídy a nepřímá dědičnost

Předchozí verze kompilátoru umožnily odvozené třídě volat členské funkce jeho nepřímo odvozenéprivate virtual základní třídy. Toto staré chování bylo nesprávné a neodpovídá standardu C++. Kompilátor už nepřijímá kód napsaný tímto způsobem a v důsledku toho vydává chybu kompilátoru C2280.

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

Příklad (před)

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

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

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

Příklad (za)

  class base;  // as above

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

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

nebo

  class base;  // as above

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

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

Přetížený operátor new and operator delete

Předchozí verze kompilátoru umožňovaly, aby byl nový a nečlenový operátor odstraněný jako statický a deklarován v jiných oborech názvů než globální obor názvů. Toto staré chování vytvořilo riziko, že program nebude volat new implementaci nebo delete operátora, kterou program chtěl, což vede k tichému špatnému chování za běhu. Kompilátor už nepřijímá kód napsaný tímto způsobem a místo toho vydává chybu kompilátoru C2323.
```
  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.
```
Příklad (před)
```
  static inline void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // error C2323
```
Příklad (za)
```
  void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // removed 'static inline'
```
Kromě toho, i když kompilátor neposkytuje konkrétní diagnostiku, vložený operátor nový je považován za neformovaný.
Volání "operator type()" (uživatelem definovaný převod) u jiných typů než třídy Předchozí verze kompilátoru povolil volání "operator type()" u typů, které nejsou třídami, zatímco bezobslužné ignorování. Toto staré chování vytvořilo riziko tichého špatného generování kódu, což vedlo k nepředvídatelným chování modulu runtime. Kompilátor už nepřijímá kód napsaný tímto způsobem a místo toho vydává chybu kompilátoru C2228.
```
  error C2228: left of '.operator type' must have class/struct/union
```
Příklad (před)
```
  typedef int index_t;

  void bounds_check(index_t index);

  void login(int column)
  {
      bounds_check(column.operator index_t());  // error C2228
  }
```
Příklad (za)
```
  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'
  }
```
Redundantní název typu v propracovaných specifikátorech typů Předchozí verze kompilátoru povolené typename ve specifikátoru propracovaného typu; kód napsaný tímto způsobem je sémanticky nesprávný. Kompilátor už nepřijímá kód napsaný tímto způsobem a místo toho vydává chybu kompilátoru C3406.
```
  error C3406: 'typename' cannot be used in an elaborated type specifier
```
Příklad (před)
```
  template <typename class T>
  class container;
```
Příklad (za)
```
  template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case
  class container;
```

Odpočty typů polí ze seznamu inicializátorů Předchozí verze kompilátoru nepodporují odpočty typů polí ze seznamu inicializátorů. Kompilátor teď podporuje tuto formu odpočtu typů a v důsledku toho může být volání šablon funkcí pomocí seznamů inicializátorů nejednoznačné nebo může být zvoleno jiné přetížení než v předchozích verzích kompilátoru. Chcete-li tyto problémy vyřešit, program teď musí explicitně určit přetížení, které program zamýšlen.

Když toto nové chování způsobí řešení přetížení zvážit další kandidát, který je stejně dobrý jako historický kandidát, volání se stane nejednoznačným a kompilátor vydá chybu kompilátoru C2668 v důsledku toho.

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

Příklad 1: Nejednoznačné volání přetížené funkce (před)

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

Příklad 1: nejednoznačné volání přetížené funkce (za)

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

Když toto nové chování způsobí řešení přetížení zvážit další kandidáta, který je lepší shoda než historický kandidát, volání jednoznačně vyřeší s novým kandidátem, což způsobí změnu chování programu, která se pravděpodobně liší od programátora.

Příklad 2: změna rozlišení přetížení (před)

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

Příklad 2: změna rozlišení přetížení (po)

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

Obnovení upozornění příkazu switch

Předchozí verze kompilátoru odebrala dříve existující upozornění související s switch příkazy. Tato upozornění byla nyní obnovena. Kompilátor nyní vydává obnovená upozornění a upozornění související s konkrétními případy (včetně výchozího případu) jsou nyní vydána na řádku obsahujícím případ off-end, nikoli na posledním řádku příkazu switch. V důsledku toho, že nyní tato upozornění vydáváte na různých řádcích než v minulosti, upozornění, která byla dříve potlačena použitím #pragma warning(disable:####) , už nemusí být potlačena tak, jak má. Pokud chcete tato upozornění potlačit tak, jak má, může být nutné přesunout #pragma warning(disable:####) direktivu na řádek nad prvním případem, který by mohl způsobovat urážku. Níže jsou obnovená upozornění.

  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

Příklad C4063 (před)

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

Příklad C4063 (za)

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

Příklady dalších obnovených upozornění jsou uvedeny v jejich dokumentaci.

#include: použití specifikátoru nadřazeného adresáře .. in pathname (pouze ovlivňuje /Wall/WX)

Předchozí verze kompilátoru nezjistily použití specifikátoru nadřazeného adresáře .. v pathname direktiv #include . Kód napsaný tímto způsobem je obvykle určen k zahrnutí hlaviček, které existují mimo projekt nesprávným použitím cest relativních k projektu. Toto staré chování vytvořilo riziko, že program může být kompilován zahrnutím jiného zdrojového souboru, než je zamýšlený programátor, nebo že tyto relativní cesty nebudou přenosné do jiných prostředí sestavení. Kompilátor teď rozpozná a upozorní programátora na kód napsaný tímto způsobem a v případě povolení vydá volitelné upozornění kompilátoru C4464.
```
  warning C4464: relative include path contains '..'
```
Příklad (před)
```
  #include "..\headers\C4426.h"  // emits warning C4464
```
Příklad (za)
```
  #include "C4426.h"  // add absolute path to 'headers\' to your project's include directories
```
Kromě toho, i když kompilátor neposkytuje konkrétní diagnostiku, doporučujeme, aby specifikátor nadřazeného adresáře "." měl být použit k určení adresářů zahrnutí projektu.
#pragma optimize() rozšiřuje poslední konec souboru hlaviček (pouze ovlivňuje /Wall/WX)

Předchozí verze kompilátoru nezjistily změny nastavení příznaku optimalizace, které uchytí hlavičkový soubor zahrnutý v jednotce překladu. Kompilátor nyní zjistí a upozorní programátora na kód napsaný tímto způsobem a vydá volitelné upozornění kompilátoru C4426 v umístění přesměrování #include, pokud je povoleno. Toto upozornění se vydává pouze v případě, že změny kolidují s příznaky optimalizace nastavené argumenty příkazového řádku kompilátoru.
```
  warning C4426: optimization flags changed after including header, may be due to #pragma optimize()
```
Příklad (před)
```
  // C4426.h
  #pragma optimize("g", off)
  ...
  // C4426.h ends

  // C4426.cpp
  #include "C4426.h"  // warning C4426
```
Příklad (za)
```
  // 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"
```

Neshoda #pragma warning(push) a #pragma warning(pop) (pouze ovlivňuje/Wall/WX)

Předchozí verze kompilátoru nezjistily #pragma warning(push) změny stavu spárované se #pragma warning(pop) změnami stavu v jiném zdrojovém souboru, který je zřídka zamýšlený. Toto staré chování vytvořilo riziko, že by program byl zkompilován s jinou sadou upozornění povolených než programátor zamýšlený, což může mít za následek tiché špatné chování modulu runtime. Kompilátor nyní rozpozná a upozorní programátora kódu napsaného tímto způsobem a vydá volitelné upozornění kompilátoru C5031 v umístění odpovídajícího #pragma warning(pop)kódu , pokud je povoleno. Toto upozornění obsahuje poznámku odkazující na umístění odpovídajícího #pragma warning(push).

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

Příklad (před)

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

Příklad (za)

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

I když je kód napsaný tímto způsobem často úmyslný. Kód napsaný tímto způsobem je citlivý na změny v #include pořadí. Pokud je to možné, doporučujeme, aby soubory zdrojového kódu spravily stav upozornění vlastním způsobem.

Nedostupné #pragma upozornění (nabízení) (pouze ovlivňuje /Wall/WX)

Předchozí verze kompilátoru nezjistily chybějící #pragma warning(push) změny stavu na konci jednotky překladu. Kompilátor nyní rozpozná a upozorní programátora kódu napsaného tímto způsobem a vydá volitelné upozornění kompilátoru C5032 v umístění chybějícího #pragma warning(push)souboru , pokud je povoleno. Toto upozornění se vydává pouze v případě, že v jednotce překladu nejsou žádné chyby kompilace.

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

Příklad (před)

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

Příklad (za)

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

V důsledku vylepšeného sledování stavu upozornění #pragma mohou být vydána další upozornění.

Předchozí verze kompilátoru sledující #pragma warning změny stavu nejsou dostatečně dobré, aby se zobrazila všechna zamýšlená upozornění. Toto chování vytvořilo riziko, že určitá upozornění by byla účinně potlačena za okolností odlišných od programátora. Kompilátor nyní sleduje #pragma warning stav robustněji – zejména související se #pragma warning změnami stavu uvnitř šablon – a volitelně vydává nová upozornění C5031 a C5032, které jsou určeny k tomu, aby programátoru pomohl najít nezamýšlené použití #pragma warning(push) a #pragma warning(pop).

V důsledku vylepšeného #pragma warning sledování změn stavu mohou být nyní vydána upozornění, která dříve nesprávně potlačená nebo upozornění související s dříve chybně diagnostikovanými problémy.
Vylepšená identifikace nedostupného kódu

Změny standardní knihovny jazyka C++ a vylepšená schopnost volání vložených funkcí v předchozích verzích kompilátoru může kompilátoru umožnit prokázat, že určitý kód je nyní nedostupný. Toto nové chování může vést k novým a častějším vydaným instancím upozornění C4720.
```
  warning C4720: unreachable code
```
V mnoha případech může být toto upozornění vydáno pouze při kompilaci s povolenými optimalizacemi, protože optimalizace můžou vyřaizovat více volání funkcí, eliminovat redundantní kód nebo jinak zajistit, že určitý kód je nedostupný. Zjistili jsme, že nové instance upozornění C4720 se často vyskytly v blocích try/catch , zejména v souvislosti s použitím příkazu std::find.

Příklad (před)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // ok
  }
```
Příklad (za)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // warning C4702: unreachable code
  }
```
pow(T, int) Odebrání zrušení registrace optimalizace

Předchozí verze standardní knihovny C++ definovaly pow(T, int) šablonu funkce, která by zruší registraci pow volání funkce do řady operací násobení. Tato technika by z důvodu povahy operací s plovoucí desetinou čárkou načítá velké množství nepřesnosti, což by mohlo způsobit významné nepřesnosti koncových výsledků. V sadě Visual Studio 2015 Update 1 bylo toto chování odebráno, aby se zabránilo neúmyslné ztrátě přesnosti při použití pow funkce. Tato verze pow však byla mnohem rychlejší než správný výpočet. Pokud tato změna způsobí významnou regresi výkonu a váš projekt nevyžaduje přesné výsledky s plovoucí desetinou čárkou (například projekt se už kompiluje pomocí /fp:fast), zvažte nahrazení volání pow touto alternativní funkcí:
```
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);
         }
     }
}
```
Tato implementace je identická s tím, co bylo součástí předchozích verzí sady Visual Studio.

Vylepšení shody v sadě Visual Studio 2015 Update 2

V důsledku částečné podpory výrazu SFINAE mohou být vydána další upozornění a chyby.

Předchozí verze kompilátoru neanalyzovali určité druhy výrazů uvnitř decltype specifikátorů kvůli nedostatku podpory výrazu SFINAE. Toto staré chování bylo nesprávné a neodpovídá standardu C++. Kompilátor teď tyto výrazy parsuje a má částečnou podporu výrazu SFINAE kvůli probíhajícím vylepšením shody. Kompilátor proto nyní vydává upozornění a chyby zjištěné ve výrazech, které předchozí verze kompilátoru neanalyly.

Když toto nové chování analyzuje decltype výraz, který obsahuje typ, který ještě nebyl deklarován, kompilátor vydá chybu kompilátoru C2039 v důsledku toho.

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

Příklad 1: použití nedelarovaného typu (před)

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

    template<typename>
    struct s2 {};
  }

Příklad 1 (za)

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

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

    template<typename>
    struct s2 {};
  }

Když toto nové chování analyzuje decltype výraz, který chybí nezbytné použití klíčového typename slova k určení, že závislý název je typ, kompilátor vydá upozornění kompilátoru C4346 společně s chybou kompilátoru 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'

Příklad 2: Závislý název není typem (před)

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

Příklad 2 (za)

  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Členské proměnné brání implicitně definovaným konstruktorům a operátorům přiřazení Předchozí verze kompilátoru povolily třídu, která má volatile členské proměnné mít výchozí konstruktory kopírování/přesunutí a výchozí operátory přiřazení kopírování/přesunutí automaticky vygenerovány. Toto staré chování bylo nesprávné a neodpovídá standardu C++. Kompilátor nyní považuje třídu, která má nestálé členské proměnné, aby měly netiktivní operátory konstrukce a přiřazení, které brání automatickému generování výchozích implementací těchto operátorů. Pokud je taková třída členem sjednocení (nebo anonymní sjednocení uvnitř třídy), konstruktory kopírování/přesunutí a operátory přiřazení kopírování/přesunutí sjednocení (nebo třídy obsahující unonymous sjednocení) budou implicitně definovány jako odstraněné. Pokus o vytvoření nebo zkopírování sjednocení (nebo třídy obsahující anonymní sjednocení) bez explicitního definování je chyba a kompilátor vydává chybu kompilátoru C2280 v důsledku toho.
```
  error C2280: 'B::B(const B &)': attempting to reference a deleted function
```
Příklad (před)
```
  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
```
Příklad (za)
```
  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
```
Statické členské funkce nepodporují kvalifikátory cv.

Předchozí verze Visual C++ 2015 povolily statické členské funkce, aby měly kvalifikátory cv. Toto chování je způsobeno regresí v sadě Visual C++ 2015 a Visual C++ 2015 Update 1; Visual C++ 2013 a předchozí verze visual C++ odmítnou kód napsaný tímto způsobem. Chování visual C++ 2015 a Visual C++ 2015 Update 1 je nesprávné a neodpovídá standardu C++. Visual Studio 2015 Update 2 odmítne kód napsaný tímto způsobem a místo toho vydá chybu kompilátoru C2511.
```
  error C2511: 'void A::func(void) const': overloaded member function not found in 'A'
```
Příklad (před)
```
  struct A
  {
    static void func();
  };

  void A::func() const {}  // C2511
```
Příklad (za)
```
  struct A
  {
    static void func();
  };

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

Forward deklarace výčtu není v kódu WinRT povolená (ovlivňuje /ZW pouze)

Kód zkompilovaný pro prostředí Windows Runtime (WinRT) neumožňuje enum deklaraci typů, podobně jako při kompilaci spravovaného kódu C++ pro rozhraní .Net Framework pomocí přepínače kompilátoru/clr. Toto chování zajišťuje, že velikost výčtu je vždy známá a může být správně promítaná do systému typů WinRT. Kompilátor odmítne kód napsaný tímto způsobem a vydá chybu kompilátoru C2599 společně s chybou kompilátoru C3197.

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

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

Příklad (před)

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

Příklad (za)

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

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

Přetížený operátor bez člena nový a operátor delete nemusí být deklarován jako vložený (úroveň 1 (/W1) ve výchozím nastavení).

Předchozí verze kompilátoru nevyvolají upozornění, pokud jsou vložené funkce pro odstranění operátoru, který není členem. Kód napsaný tímto způsobem je špatně vytvořený (nevyžaduje se diagnostika) a může způsobit problémy s pamětí způsobené neshodou nových operátorů a operátorů odstranění (zejména při použití společně s přidělením velikosti), které může být obtížné diagnostikovat. Kompilátor teď vydává upozornění kompilátoru C4595, aby pomohl identifikovat kód napsaný tímto způsobem.
```
  warning C4595: 'operator new': non-member operator new or delete functions may not be declared inline
```
Příklad (před)
```
  inline void* operator new(size_t sz)  // warning C4595
  {
    ...
  }
```
Příklad (za)
```
  void* operator new(size_t sz)  // removed inline
  {
    ...
  }
```
Oprava kódu napsaného tímto způsobem může vyžadovat, aby definice operátorů byly přesunuty z hlavičkového souboru a do odpovídajícího zdrojového souboru.

Vylepšení shody v sadě Visual Studio 2015 Update 3

std::is_convertable nyní zjistí, že při odstranění nebo privátním konstruktoru kopírování nebyly správně zjištěny předchozí verze std::is_convertable vlastnosti typu. std::is_convertable<>::value Nyní je správně nastaven na false při použití na typ třídy s odstraněným nebo privátním konstruktorem kopírování.

K této změně není přidružená žádná diagnostika kompilátoru.

Příklad
```
  #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");
```
V předchozích verzích visual C++ statické kontrolní výrazy v dolní části tohoto příkladu pass, protože std::is_convertable<>::value byly nesprávně nastaveny na true. std::is_convertable<>::value Nyní je správně nastaven na false, což způsobuje selhání statických kontrolních výrazů.
Výchozí nebo odstraněné triviální kopie a konstruktory přesunutí respektují specifikátory přístupu.

Předchozí verze kompilátoru nezkontrolovaly specifikátor přístupu výchozích nebo odstraněných triviálních konstruktorů kopírování a přesunutí před povolením jejich zavolání. Toto staré chování bylo nesprávné a neodpovídá standardu C++. V některých případech toto staré chování vytvořilo riziko tichého chybného generování kódu, což vede k nepředvídatelným chováním za běhu. Kompilátor teď zkontroluje specifikátor přístupu výchozího nebo odstraněného triviálního kopírování a konstruktory přesunutí, aby zjistil, jestli se dá volat, a pokud ne, vydá upozornění kompilátoru C2248 v důsledku toho.
```
  error C2248: 'S::S' cannot access private member declared in class 'S'
```
Příklad (před)
```
  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
  }
```
Příklad (za)
```
  class S {
  public:
     S() = default;
  private:
      S(const S&) = default;
  };

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

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

Vyřazení podpory kódu ATL s atributy (úroveň 1 (/W1) ve výchozím nastavení)

Předchozí verze kompilátoru podporovaly kód ATL s atributy. Jako další fáze odebrání podpory pro atributovaný kód ATL, který začal v jazyce Visual C++ 2008, byl atributovaný kód ATL zastaralý. Kompilátor teď vydává upozornění kompilátoru C4467, aby pomohl identifikovat tento druh zastaralého kódu.

  warning C4467: Usage of ATL attributes is deprecated

Pokud chcete pokračovat v používání atributovaného kódu ATL, dokud se podpora neodebere z kompilátoru, můžete toto upozornění zakázat předáním /Wv:18/wd4467 argumentů příkazového řádku kompilátoru nebo přidáním #pragma warning(disable:4467) do zdrojového kódu.

Příklad 1 (před)

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

Příklad 1 (za)

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

Někdy možná budete potřebovat nebo chcete vytvořit soubor IDL, abyste se vyhnuli zastaralým atributům ATL, jako v ukázkovém kódu níže.

Příklad 2 (před)

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

Nejprve vytvořte soubor *.idl; vygenerovaný soubor vc140.idl lze použít k získání souboru *.idl obsahujícího rozhraní a poznámky.

Dále do sestavení přidejte krok MIDL, abyste měli jistotu, že se vygenerují definice rozhraní C++.

Příklad 2 IDL (za)

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

Pak použijte ATL přímo v implementačním souboru, jak je znázorněno v ukázkovém kódu níže.

Příklad 2 Implementace (za)

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

Předkompilované soubory hlaviček (PCH) a neshodované direktivy #include (pouze ovlivňují /Wall/WX)

Předchozí verze kompilátoru přijímaly neshodné #include direktivy ve zdrojových souborech mezi -Yc a -Yu kompilacemi při použití předkompilovaných hlaviček (PCH). Kód napsaný tímto způsobem už kompilátor nepřijímá. Kompilátor teď vydává upozornění kompilátoru CC4598, které pomáhá identifikovat neshodované #include direktivy při použití souborů PCH.
```
  warning C4598: 'b.h': included header file specified for Ycc.h at position 2 does not match Yuc.h at that position
```
Příklad (před):

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"
```
Příklad (za)

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"
```
Předkompilované soubory hlaviček (PCH) a neshodované adresáře zahrnutí (pouze ovlivňuje /Wall/WX)

Předchozí verze kompilátoru přijali neshodu mezi argumenty příkazového řádku () adresáře (-I) kompilátoru mezi -Yc kompilacemi a -Yu jejich kompilacemi při použití předkompilovaných souborů hlaviček (PCH). Kód napsaný tímto způsobem už kompilátor nepřijímá. Kompilátor teď vydává upozornění kompilátoru CC4599, aby při použití souborů PCH pomohl identifikovat neshodované argumenty adresáře () v adresáři .-I
```
  warning C4599: '-I..' : specified for Ycc.h at position 1 does not match Yuc.h at that position
```
Příklad (před)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h Z.cpp
```
Příklad (za)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h -I.. Z.cpp
```

Co je nového v jazyce C++ v sadě Visual Studio 2013

Vylepšená podpora standardů ISO C/C++

Compiler

MSVC podporuje tyto jazykové funkce ISO C++11:

Výchozí argumenty šablony pro šablony funkcí
Delegování konstruktorů
Explicitní převodní operátory
Seznamy inicializátorů a jednotné inicializace
Nezpracované řetězcové literály.
Variadické šablony.
Šablony aliasů
Odstraněné funkce
Nestatické inicializátory datových členů (NSDMI).
Výchozí funkce *
Podporuje tyto jazykové funkce ISO C99:
_Bool
Složené literály.
Určené inicializátory.
Kombinování deklarací s kódem
Převod řetězcového literálu na modifikovatelné hodnoty lze zrušit pomocí nové možnosti /Zc:strictStringskompilátoru . V jazyce C++98 byl převod z řetězcových literálů do char* (a širokých řetězcových literálů na wchar_t*) zastaralý. V jazyce C++11 byl převod zcela odebrán. I když kompilátor by mohl přesně vyhovovat standardu, místo toho poskytuje /Zc:strictStrings možnost, abyste mohli řídit převod. Ve výchozím nastavení je tato možnost vypnutá. Všimněte si, že pokud používáte tuto možnost v režimu ladění, STL se nezkompiluje.
rvalue/lvalue Reference Casts. S odkazy rvalue může C++11 jasně rozlišovat mezi lvalues a rvalues. Dříve kompilátor tuto možnost nezadal v konkrétních scénářích přetypování. Byla přidána nová možnost kompilátoru, /Zc:rvalueCastaby kompilátor odpovídal pracovnímu dokumentu jazyka C++ (viz oddíl 5.4, [výraz.cast]/1). Výchozí chování, pokud není tato možnost zadána, je stejná jako v sadě Visual Studio 2012.

Poznámka:

U výchozích funkcí není použití =default k vyžádání konstruktorů přesunutí členů a operátorů přiřazení přesunutí podporováno.

Knihovny C99

Deklarace a implementace se přidají pro chybějící funkce v těchto hlavičkách: math.h, ctype.h, wctype.h, stdio.h, stdlib.h a wchar.h. Přidány jsou také nové hlavičky complex.h, stdbool.h, fenv.h a inttypes.h a implementace pro všechny funkce deklarované v nich. Existují nové hlavičky obálky C++ (ccomplex, cfenv, cinttypes, ctgmath) a řada dalších se aktualizují (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar a cwctype).

Standardní šablona knihovny

Podpora explicitních operátorů převodu C++11, seznamů inicializátorů, výčtů s vymezeným oborem a variadických šablon. Všechny kontejnery teď podporují jemně odstupňované požadavky elementů C++11. Podpora těchto funkcí C++14:

"Průhledné operátory" méně<>, větší<>, plus<>, násobení<> atd.
<make_unique T>(args...) a make_unique<T[]>(n)
cbegin()/cend(), rbegin()/rend() a crbegin()/crend() funkce, které nejsou členy.
<atomic> obdržel mnoho vylepšení výkonu.
<> type_traits obdržely zásadní stabilizaci a opravy kódu.

Zásadní změny

Tato vylepšená podpora standardů ISO C/C++ může vyžadovat změny stávajícího kódu tak, aby odpovídala jazyku C++11 a správně se zkompiluje v sadě Visual C++ v sadě Visual Studio 2013.

Vylepšení knihovny Visual C++

Přidá se sada C++ REST SDK. Má moderní implementaci služeb REST v jazyce C++.
Je vylepšena podpora texturY C++ AMP. Teď obsahuje podporu pro mipmapy a nové režimy vzorkování.
Úlohy PPL podporují více technologií plánování a asynchronní ladění. Nová rozhraní API umožňují vytvářet úlohy PPL pro normální výsledky i podmínky výjimek.

Výkon aplikací jazyka C++

Auto-Vectorizer teď rozpozná a optimalizuje více vzorů jazyka C++, aby váš kód běžel rychleji.
Vylepšení kvality kódu architektury ARM a mikro-architektury Atom
__vectorcall se přidá konvence volání. Předejte argumenty typu vektoru pomocí __vectorcall konvence volání pro použití vektorových registrů.
Nové možnosti linkeru Přepínače /Gw (kompilátor) a /Gy (assembler) umožňují optimalizaci linkerů vytvářet štíhlé binární soubory.
Podpora sdílené paměti C++ AMP pro snížení nebo odstranění kopírování dat mezi procesorem a GPU

Vylepšení optimalizace s asistencí profilu (PGO)

Vylepšení výkonu při snížení pracovní sady aplikací, které jsou optimalizované pomocí PGO.
Nový PGO pro vývoj aplikací prostředí Windows Runtime

podpora vývoje aplikací prostředí Windows Runtime

Podpora krabicových typů ve strukturách hodnot

Teď můžete definovat typy hodnot pomocí polí, která mohou mít hodnotu null , IBox<int>^ například na rozdíl od int. To znamená, že pole mohou mít buď hodnotu, nebo být rovna nullptr.
Bohatší informace o výjimce.

C++/CX podporuje nový chybový model Windows, který umožňuje zachytávání a šíření bohatých informací o výjimkách v binárním rozhraní aplikace (ABI); to zahrnuje zásobníky volání a vlastní řetězce zpráv.
Object::ToString() je teď virtuální.

Teď můžete přepsat ToString v uživatelsky definovaných prostředí Windows Runtime odkazových typech.
Podpora zastaralých rozhraní API

Veřejná prostředí Windows Runtime rozhraní API je teď možné označit jako zastaralá a poskytnout vlastní zprávu, která se zobrazí jako upozornění sestavení a může poskytnout pokyny k migraci.
Vylepšení ladicího programu

Podpora nativního nebo javascriptového ladění interoperability, diagnostiky výjimek prostředí Windows Runtime a asynchronního ladění kódu (prostředí Windows Runtime i PPL).

Poznámka:

Kromě funkcí a vylepšení specifických pro jazyk C++, které jsou popsány v této části, vám můžou další vylepšení v sadě Visual Studio pomoct také psát lepší prostředí Windows Runtime aplikace.

Vylepšení diagnostiky

Vylepšení ladicího programu Podpora asynchronního ladění a ladění just My Code
Kategorie analýzy kódu Teď můžete zobrazit výstup zařazený do kategorií z Analyzátoru kódu, který vám pomůže najít a opravit vady kódu.
Diagnostika XAML. V XAML teď můžete diagnostikovat problémy s odezvou uživatelského rozhraní a používáním baterie.
Vylepšení ladění grafiky a GPU
Vzdálené zachytávání a přehrávání na skutečných zařízeních.
Souběžné ladění C++ AMP a procesoru
Vylepšená diagnostika modulu runtime C++ AMP.
Ladění trasování shaderu výpočetního shaderu HLSL

Vylepšení 3D grafiky

Podpora kanálu obsahu obrázků pro předem vynásobený formát alfa DDS
Editor obrázků používá interně předem vynásobené alfa pro vykreslování, a tím se vyhne vykreslování artefaktů, jako jsou tmavé halosy.
Editory obrázků a modelů Vytváření filtrů definované uživatelem je nyní podporováno v Návrháři shaderů v Editoru obrázků a Editoru modelů.

Integrované vývojové prostředí (IDE) a produktivita

Vylepšené formátování kódu U kódu jazyka C++ můžete použít další nastavení formátování. Pomocí těchto nastavení můžete řídit umístění složených závorek a klíčových slov, odsazení, mezery a obtékání řádku. Kód se automaticky naformátuje při dokončování příkazů a bloků a při vkládání kódu do souboru.

Dokončení složené závorky Kód C++ teď automaticky dokončí zavírací znaky, které odpovídají těmto počátečním znakům:

{ (složená závorka)
[ (hranatá závorka)
( (závorky)
' (jednoduchá uvozovka)
"(uvozovky)

Další funkce automatického dokončování jazyka C++.

Přidá středník pro typy tříd.
Dokončí závorky pro nezpracované řetězcové literály.
Dokončí víceřádkové komentáře (/* */)

Funkce Najít všechny odkazy se teď automaticky překládá a filtruje odkazy na pozadí, jakmile zobrazí seznam textových shod.

Filtrování seznamu členů na základě kontextu Nepřístupní členové se odfiltrují ze seznamů členů IntelliSense. Soukromé členy se například nezobrazují v seznamu členů, pokud neupravujete kód, který implementuje typ. Když je seznam členů otevřený, můžete stisknutím ctrl +J odebrat jednu úroveň filtrování (platí jenom pro aktuální okno seznamu členů). Opětovnou klávesou Ctrl+J můžete odebrat textové filtrování a zobrazit každého člena.

Posouvání nápovědy k parametru Zobrazený podpis funkce v popisku nápovědy k parametru se teď mění na základě počtu parametrů, které jste skutečně zadali, a ne jenom zobrazovat libovolný podpis a neaktualizuje se na základě aktuálního kontextu. Nápověda k parametru také funguje správně, když je zobrazena u vnořených funkcí.

Přepněte hlavičku nebo soubor kódu. Mezi záhlavím a odpovídajícím souborem kódu teď můžete přepínat pomocí příkazu v místní nabídce nebo pomocí klávesové zkratky.

Okno vlastnosti projektu C++ s možností změny velikosti

Automatické generování kódu obslužné rutiny událostí v C++/CX a C++/CLI Při psaní kódu pro přidání obslužné rutiny události do souboru kódu C++/CX nebo C++/CLI může editor automaticky vygenerovat definici delegované instance a obslužné rutiny událostí. Zobrazí se okno popisu, když lze automaticky vygenerovat kód obslužné rutiny události.

Vylepšení zvyšování povědomí o DPI. Nastavení dpi pro soubory manifestu aplikace teď podporuje nastavení "Per Monitor High DPI Aware" (Sledování vysokého DPI).

Rychlejší přepínání konfigurace U velkých aplikací se přepínání konfigurací ( zejména následných operací přepínání) provádí mnohem rychleji.

Efektivita času sestavení Mnoho optimalizací a využití s více jádry urychluje sestavení, zejména pro velké projekty. Přírůstkové sestavení pro aplikace C++, které mají odkazy na C++ WinMD, jsou také mnohem rychlejší.

Co je nového pro C++ v sadě Visual Studio 2012

Vylepšená podpora standardů C++11

Standardní šablona knihovny

Podpora nových hlaviček STL: atomic, chrono, condition_variable, filesystem>, future>, <<mutex>, <ratio> a <thread.><><><><
Kvůli optimalizaci využití prostředků paměti jsou teď kontejnery menší. Například v režimu verze x86 s výchozím nastavením std::vector se v sadě Visual Studio 2010 na 12 bajtů v sadě Visual Studio 2012 zvětší 16 bajtů a std::map v sadě Visual Studio 2012 došlo ke zmenšení z 16 bajtů v sadě Visual Studio 2010 na 8 bajtů v sadě Visual Studio 2012.
Jak je povoleno, ale nevyžaduje standard C++11, byly implementovány iterátory SCARY.

Další vylepšení C++11

Pro smyčky založené na rozsahu. Můžete napsat robustnější smyčky, které pracují s poli, kontejnery STL a prostředí Windows Runtime kolekce ve formuláři pro ( for-range-deklarace : výraz ). Toto je součástí podpory základního jazyka.
Bezstavové lambda, což jsou bloky kódu, které začínají prázdným úvodem lambda [] a nezachytávají žádné místní proměnné, se teď implicitně konvertují na ukazatele funkcí podle požadavků standardu C++11.
Podpora výčtů s vymezeným oborem Jazyk C++ enum-key třídy je nyní podporován. Následující kód ukazuje, jak se tento výčtový klíč liší od předchozího chování výčtu.
```
enum class Element { Hydrogen, Helium, Lithium, Beryllium };
void func1(Element e);
func1(Hydrogen); // error C2065: 'Hydrogen' : undeclared identifier
func1(Element::Helium); // OK
```

podpora vývoje aplikací prostředí Windows Runtime

Nativní model uživatelského rozhraní založeného na XAML Pro prostředí Windows Runtime aplikace můžete použít nový nativní model uživatelského rozhraní založeného na XAML.
Rozšíření komponent jazyka Visual C++. Tato rozšíření zjednodušují spotřebu prostředí Windows Runtime objektů, které jsou nezbytnou součástí prostředí Windows Runtime aplikací. Další informace najdete v tématu Roadmapa pro prostředí Windows Runtime aplikace využívající referenční dokumentace jazyka C++ a Visual C++ (C++/CX).
DirectX hry. Pomocí nové podpory DirectX pro prostředí Windows Runtime aplikace můžete vyvíjet poutavé hry.
Interoperabilita XAML/DirectX prostředí Windows Runtime aplikace, které teď používají XAML i DirectX, teď interoperativně interoperativně.
prostředí Windows Runtime vývoj knihovny DLL komponent. Vývoj knihovny DLL komponent zajišťuje rozšiřitelnost prostředí prostředí Windows Runtime.

Kompilátor a linker

Automatický vektorizátor. Kompilátor analyzuje smyčky v kódu a tam, kde je to možné, vysílá instrukce, které používají vektorové registry a instrukce, které jsou přítomné ve všech moderních procesorech. Díky tomu budou smyčky rychlejší. (Pokyny procesoru se označují jako SSE pro rozšíření SIMD streamování). Tuto optimalizaci nemusíte povolit ani požadovat, protože se použije automaticky.
Automatický paralelizátor. Kompilátor může analyzovat smyčky v kódu a generovat instrukce, které rozdělují výpočty do více jader nebo procesorů. Díky tomu můžou smyčky běžet rychleji. Tuto optimalizaci musíte požádat, protože není ve výchozím nastavení povolená. V mnoha případech pomáhá zahrnout #pragma loop(hint_parallel(N)) do kódu bezprostředně před smyčky, které chcete paralelizovat.
Auto-vectorizer a auto-parallelizer může spolupracovat tak, aby výpočty byly rozloženy mezi více jader a kód na každém jádru používá své vektorové registry.

Novinka v sadě Visual Studio 2012 Update 1

Cílení na systém Windows XP při sestavování kódu jazyka C++. K cílení na systém Windows XP a Windows Server 2003 můžete použít kompilátor a knihovny jazyka Microsoft C++.

Podpora paralelního programování

C++ Accelerated Massive Parallelism (AMP)

C++ AMP urychluje provádění kódu C++ tím, že využívá výhod hardwaru paralelního zpracování dat, který je obvykle k dispozici jako GPU na diskrétní grafické kartě. Programovací model C++ AMP zahrnuje multidimenzionální pole, indexování, přenos paměti, svázání a matematickou knihovnu funkcí. Pomocí jazykových rozšíření C++ AMP a omezení kompilátoru můžete řídit, jak se data přesouvají z procesoru do GPU a zpět.

Ladění. Prostředí ladění pro aplikace, které používají C++ AMP k cílení na GPU, je stejně jako ladění pro ostatní aplikace C++. To zahrnuje nové doplňky paralelního ladění, které byly zmíněny dříve.

Profilace. Teď existuje podpora profilace pro aktivitu GPU založenou na C++ AMP a dalších programovacích modelech založených na Direct3D.

Obecná vylepšení paralelního programování

Díky přesunu hardwaru na vícejádrových a mnohajádrových architekturách už vývojáři nemůžou spoléhat na stále rostoucí rychlost hodin z jednojádrových jader. Podpora paralelního programování v concurrency Runtime umožňuje vývojářům využívat tyto nové architektury. V sadě Visual Studio 2010 byly zavedeny výkonné knihovny paralelizace C++, jako je knihovna Paralelní vzory, společně s funkcemi, které využívají souběžnost díky vyjádření sofistikovaných kanálů toku dat. V sadě Visual Studio 2012 byly tyto knihovny rozšířeny, aby poskytovaly lepší výkon, větší kontrolu a širší podporu paralelních vzorů, které vývojáři potřebují nejvíce. Šířka nabídky teď zahrnuje:

Bohatý programovací model založený na úlohách, který podporuje asynchronní a pokračování.
Paralelní algoritmy, které podporují paralelismus spojení forku (parallel_for, parallel_for se spřažením, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
Kontejnery concurrency-safe, které poskytují verze std datových struktur bezpečných pro přístup z více vláken, jako jsou priority_queue, fronta, vektor a mapa.
Knihovna asynchronních agentů, kterou můžou vývojáři použít k vyjádření kanálů toku dat, které se přirozeně rozloží do souběžných jednotek.
Přizpůsobitelný plánovač a správce prostředků, které usnadňují hladké složení vzorů v tomto seznamu.

Obecná vylepšení paralelního ladění

Kromě okna Paralelní úlohy a paralelní zásobníky nabízí Visual Studio 2012 nové okno paralelního kukátka , abyste mohli zkoumat hodnoty výrazu ve všech vláknech a procesech a provádět řazení a filtrování výsledku. K rozšíření okna můžete také použít vlastní vizualizéry a můžete využít výhod nové podpory více procesů ve všech oknech nástrojů.

IDE

Podpora šablon sady Visual Studio Teď můžete pomocí technologie Šablony sady Visual Studio vytvářet šablony projektů a položek jazyka C++.

Asynchronní načtení řešení Projekty se teď načítají asynchronně – jako první klíčové části řešení– abyste mohli začít pracovat rychleji.

Automatizované nasazení pro vzdálené ladění Nasazení souborů pro vzdálené ladění v jazyce Visual C++ bylo zjednodušeno. Možnost Nasadit v místní nabídce projektu automaticky zkopíruje do vzdáleného počítače soubory zadané ve vlastnostech konfigurace ladění. Ruční kopírování souborů do vzdáleného počítače se už nevyžaduje.

C++/CLI IntelliSense. C++/CLI teď má plnou podporu Technologie IntelliSense. Funkce IntelliSense, jako jsou rychlé informace, nápověda k parametrům, členové seznamu a automatické dokončování, teď fungují pro C++/CLI. Kromě toho ostatní vylepšení IntelliSense a integrovaného vývojového prostředí uvedené v tomto dokumentu fungují také pro C++/CLI.

Bohatší popisy intellisense Popisy rychlých informací v jazyce C++ IntelliSense teď zobrazují bohatší informace o stylu komentářů dokumentace XML. Pokud používáte rozhraní API z knihovny ( například C++ AMP), které obsahuje komentáře dokumentace XML, zobrazí popis IntelliSense více informací než jen deklarace. Pokud váš kód obsahuje komentáře k dokumentaci XML, zobrazí se v popisech IntelliSense další informace.

Konstrukty kódu jazyka C++. Skeleton code is available for switch, if-else, for loop, and other basic code constructs, in the List Members drop-down list. Výběrem části kódu ze seznamu ho vložte do kódu a pak vyplňte požadovanou logiku. Můžete také vytvořit vlastní části kódu pro použití v editoru.

Vylepšení členů seznamu Rozevírací seznam Členové seznamu se automaticky zobrazí při psaní kódu do editoru kódu. Výsledky se filtrují, takže se při psaní zobrazí jenom relevantní členové. Typ logiky filtrování, kterou používá seznam členů, můžete řídit v dialogovém okně Možnosti v části Textový editor>C/C++>Upřesnit.

Sémantické zabarvení. Typy, výčty, makra a další tokeny jazyka C++ teď mají ve výchozím nastavení barevné zabarvení.

Zvýraznění odkazů Když vyberete symbol, zvýrazní se všechny výskyty symbolu v aktuálním souboru. Mezi zvýrazněnými odkazy se můžete pohybovat stisknutím kombinace kláves Ctrl+Shift+Šipka nahoru nebo Ctrl+Shift+Šipka dolů. Tuto funkci můžete vypnout v dialogovém okně Možnosti v části Textový editor>C/C++>Upřesnit.

Nástroje pro správu životního cyklu aplikací

Analýza statického kódu

Statická analýza jazyka C++ byla aktualizována tak, aby poskytovala bohatší informace o kontextu chyb, další pravidla analýzy a lepší výsledky analýzy. V novém okně Analýza kódu můžete filtrovat zprávy podle klíčových slov, projektu a závažnosti. Když v okně vyberete zprávu, řádek v kódu, ve kterém se zpráva aktivovala, se v editoru kódu zvýrazní. U určitých upozornění jazyka C++ obsahuje zpráva seznam zdrojových řádků, které zobrazují cestu spuštění, která vede k upozornění; zvýrazní se rozhodovací body a důvody pro přijetí konkrétní cesty. Analýza kódu je součástí většiny edicí sady Visual Studio 2012. V edicích Professional, Premium a Ultimate jsou zahrnuta všechna pravidla. V edicích Express pro Windows 8 a Windows Telefon jsou zahrnuta pouze nejdůležitější upozornění. Analýza kódu není součástí edice Express pro web. Tady je několik dalších vylepšení analýzy kódu:

Nová upozornění souběžnosti pomáhají vyhnout se chybám souběžnosti tím, že zajistíte, že ve vícevláknových programech C/C++ používáte správné uzamykání disciplín. Analyzátor detekuje potenciální podmínky časování, inverze pořadí uzamčení volajícího nebo volaného zamykání kontraktu, neshodované synchronizační operace a další chyby souběžnosti.
Pravidla jazyka C++, která chcete použít pro spuštění analýzy kódu, můžete zadat pomocí sad pravidel.
V okně Analýza kódu můžete do zdrojového kódu vložit direktivu pragma, která potlačí vybrané upozornění.
Přesnost a úplnost statické analýzy kódu můžete zvýšit pomocí nové verze jazyka SAL (Source Code Annotation Language) od Microsoftu, která popisuje, jak funkce používá své parametry, předpoklady, že o nich dělá, a záruky, které provede po dokončení.
Podpora 64bitových projektů C++.

Aktualizovaná architektura testování jednotek

K zápisu testů jednotek jazyka C++ použijte novou architekturu testování jednotek jazyka C++ v sadě Visual Studio. Přidejte nový projekt testování jednotek do stávajícího řešení C++ vyhledáním šablony projektu testování jednotek C++ v kategorii Visual C++ v dialogovém okně Nový projekt. Začněte psát testy jednotek ve vygenerovaném kódu TEST_METHOD zástupný kód v souboru Unittest1.cpp. Po napsání testovacího kódu sestavte řešení. Pokud chcete testy spustit, otevřete okno Průzkumníka testů jednotek tak, že zvolíte Zobrazit>další průzkumníka testů jednotek systému Windows>a potom v místní nabídce požadovaného testovacího případu zvolte Spustit vybraný test. Po dokončení testovacího spuštění můžete zobrazit výsledky testů a další informace o trasování zásobníku ve stejném okně.

Grafy závislostí architektury

Abyste lépe porozuměli kódu, můžete teď generovat grafy závislostí pro binární, třídu, obor názvů a zahrnout soubory do řešení. Na řádku nabídek zvolte Architektura>vygenerovat graf závislostí a pak pro řešení nebo soubor pro zahrnutí vygenerujte graf závislostí. Po dokončení generování grafu ho můžete prozkoumat tak, že rozbalíte jednotlivé uzly, naučíte se vztahy závislostí tím, že se přesunete mezi uzly a přejdete ke zdrojovému kódu tak, že v místní nabídce uzlu zvolíte Zobrazit obsah . Pokud chcete vygenerovat graf závislostí pro zahrnuté soubory, zvolte v místní nabídce pro soubor zdrojového kódu *.cpp nebo *.h hlavičkový soubor vygenerovat graf zahrnutí souborů.

Průzkumník architektury

Pomocí Průzkumníka architektury můžete prozkoumat prostředky v řešení, projektech nebo souborech jazyka C++. Na řádku nabídek zvolte Průzkumník architektury>systému Windows.> Můžete vybrat uzel, který vás zajímá, například zobrazení třídy. V tomto případě se pravá strana okna nástroje rozbalí se seznamem oborů názvů. Pokud vyberete obor názvů, zobrazí nový sloupec seznam tříd, struktur a výčtů v tomto oboru názvů. Můžete pokračovat v prozkoumání těchto prostředků nebo se vrátit ke sloupci úplně vlevo a spustit další dotaz. Viz Hledání kódu pomocí Průzkumníka architektury.

Pokrytí kódu

Pokrytí kódu bylo aktualizováno tak, aby dynamicky instrumentovaly binární soubory za běhu. Tím se snižuje režijní náklady na konfiguraci a poskytuje lepší výkon. Můžete také shromažďovat data pokrytí kódu z testů jednotek pro aplikace C++. Po vytvoření testů jednotek jazyka C++ můžete pomocí Průzkumníka testů jednotek zjistit testy ve vašem řešení. Pokud chcete spustit testy jednotek a shromáždit data pokrytí kódu, zvolte v Průzkumníku testů jednotek možnost Analyzovat pokrytí kódu. Výsledky pokrytí kódu můžete prozkoumat v okně Výsledky pokrytí kódu – na řádku nabídek zvolte TestOvat>výsledky pokrytí kódu systému Windows>.

Co je nového v jazyce C++ v sadě Visual Studio 2010

Kompilátor jazyka C++ a linker

automatické klíčové slovo. Klíčové auto slovo má nový účel. Pomocí výchozího významu auto klíčového slova deklarujte proměnnou, jejíž typ je odvozen z inicializačního výrazu v deklaraci proměnné. Možnost /Zc:auto kompilátoru vyvolá nový nebo předchozí význam klíčového auto slova.

decltype – specifikátor typu. Specifikátor decltype typu vrátí typ zadaného výrazu. Pomocí specifikátoru decltype typu v kombinaci s auto klíčovým slovem deklarujte typ, který je složitý nebo známý pouze kompilátoru. Pomocí kombinace můžete například deklarovat funkci šablony, jejíž návratový typ závisí na typech argumentů šablony. Nebo deklarujte funkci šablony, která volá jinou funkci, a poté vrátí návratový typ volané funkce.

Výrazy lambda Funkce lambda mají tělo funkce, ale žádný název. Funkce lambda kombinují nejlepší charakteristiky ukazatelů funkcí a objektů funkcí. Funkci lambda použijte samostatně, jako parametr funkce šablony místo objektu funkce nebo společně s auto klíčovým slovem deklarujte proměnnou, jejíž typ je lambda.

Referenční dokumentace Rvalue Deklarátor odkazu rvalue (&&) deklaruje odkaz na hodnotu rvalue. Odkaz rvalue umožňuje používat sémantiku přesunutí a dokonalé předávání k zápisu efektivnějších konstruktorů, funkcí a šablon.

static_assert Deklarace. Deklarace static_assert testuje kontrolní výraz softwaru v době kompilace, na rozdíl od jiných kontrolních mechanismů, které testují za běhu. Pokud kontrolní výraz selže, kompilace selže a zobrazí se zadaná chybová zpráva.

nullptr a __nullptr Klíčová slova. MSVC umožňuje používat nullptr klíčové slovo s nativním kódem nebo se spravovaným kódem. Klíčové nullptr slovo označuje, že popisovač objektu, vnitřní ukazatel nebo nativní typ ukazatele neodkazuje na objekt. Kompilátor interpretuje nullptr , aby byl spravovaný kód při použití možnosti kompilátoru /clr a nativní kód, pokud tuto možnost nepoužíváte /clr . Klíčové slovo specifické pro Microsoft __nullptr má stejný význam jako nullptr, ale vztahuje se pouze na nativní kód. Pokud kompilujete nativní kód C/C++ pomocí možnosti kompilátoru /clr , kompilátor nemůže určit, zda nullptr je klíčové slovo nativní nebo spravovaný termín. Pokud chcete kompilátoru smazat záměr, použijte klíčové slovo nullptr k určení spravovaného termínu a __nullptr k určení nativního termínu.

/Zc:trigraphs Možnost kompilátoru Ve výchozím nastavení je podpora trigrafů zakázaná. Pomocí možnosti kompilátoru /Zc:trigraphs povolte podporu trigrafů. Trigraf se skládá ze dvou po sobě jdoucích otazník (??) následovaných jedinečným třetím znakem. Kompilátor nahradí trigraf odpovídajícím interpunkčním znakem. Kompilátor například nahradí ?? = trigraf se znakem # (znaménko čísla). Ve zdrojových souborech jazyka C používejte trigrafy, které používají znakovou sadu, která neobsahuje určité interpunkční znaky.

Nová možnost optimalizace s asistencí profilu Pogo Sejf Mode je nová možnost optimalizace s asistencí profilu, která umožňuje určit, jestli se má při optimalizaci aplikace používat nouzový režim nebo rychlý režim. Sejf režim je bezpečný pro přístup z více vláken, ale je pomalejší než rychlý režim. Rychlý režim je výchozí chování.

Nová možnost modulu CLR (Common Language Runtime) /clr:nostdlib. Přidá se nová možnost pro /clr (kompilace modulu Common Language Runtime). Pokud jsou zahrnuty různé verze stejných knihoven, je vydána chyba kompilace. Nová možnost umožňuje vyloučit výchozí knihovny CLR, aby váš program mohl použít zadanou verzi.

Nová direktiva pragma detect_mismatch. Direktiva pragma detect_mismatch umožňuje vložit značku do souborů ve srovnání s jinými značkami, které mají stejný název. Pokud existuje více hodnot pro stejný název, linker vydá chybu.

Vnitřní prvky XOP, vnitřní prvky FMA4 a vnitřní prvky LWP. Byly přidány nové vnitřní funkce pro podporu XOP Vnitřní prvky přidané pro Visual Studio 2010 SP1, FMA4 Vnitřní prvky přidané pro Visual Studio 2010 SP1 a LWP Vnitřní funkce přidané pro technologie procesoru Visual Studio 2010 SP1. Pomocí __cpuid __cpuidex určete, které technologie procesoru jsou podporovány v určitém počítači.

Projekty Visual Studio C++ a systém sestavení

Msbuild. Řešení a projekty Jazyka Visual C++ jsou nyní sestaveny pomocí msBuild.exe, který nahrazuje VCBuild.exe. NÁSTROJ MSBuild je stejný flexibilní, rozšiřitelný nástroj pro sestavení založený na jazyce XML, který používá ostatní jazyky a typy projektů sady Visual Studio. Vzhledem k této změně teď soubory projektu Visual Studio C++ používají formát souboru XML a mají příponu názvu souboru .vcxproj. Soubory projektu visual Studio C++ ze starších verzí sady Visual Studio se automaticky převedou do nového formátu souboru.

Adresáře VC++. Nastavení adresářů VC++ se teď nachází na dvou místech. Stránky vlastností projektu slouží k nastavení hodnot jednotlivých projektů pro adresáře VC++. Pomocí Správce vlastností a seznamu vlastností můžete nastavit globální hodnoty konfigurace pro adresáře VC++.

Závislosti mezi projekty V dřívějších verzích byly definované závislosti mezi projekty uloženy v souboru řešení. Při převodu těchto řešení do nového formátu souboru projektu se závislosti převedou na odkazy na projekt-projekt. Tato změna může ovlivnit aplikace, protože se liší koncepty závislostí řešení a odkazů mezi projekty.

Makra a proměnné prostředí Nové makro _ITERATOR_DEBUG_LEVEL vyvolá podporu ladění pro iterátory. Toto makro použijte místo starších _SECURE_SCL a _HAS_ITERATOR_DEBUGGING maker.

Knihovny jazyka Visual C++

Knihovny concurrency Runtime Architektura Concurrency Runtime podporuje aplikace a komponenty, které běží současně, a je rozhraním pro programování souběžných aplikací v jazyce Visual C++. Pro podporu programování souběžných aplikací poskytuje knihovna PPL (Parallel Patterns Library) kontejnery a algoritmy pro obecné účely pro provádění jemně odstupňovaného paralelismu. Knihovna asynchronních agentů poskytuje programovací model založený na objektech actor a předávání zpráv rozhraní pro hrubě odstupňovaný tok dat a úlohy pipeliningu.

Standardní knihovna C++. Následující seznam popisuje řadu změn provedených ve standardní knihovně C++.

Nová referenční funkce jazyka RValue jazyka C++ byla použita k implementaci sémantiky přesunutí a dokonalého předávání pro mnoho funkcí v knihovně standardních šablon. Přesun sémantiky a dokonalé předávání výrazně zlepšuje výkon operací, které přidělují nebo přiřazují proměnné nebo parametry.
Odkazy Rvalue se také používají k implementaci nové unique_ptr třídy, což je bezpečnější typ inteligentního auto_ptr ukazatele než třída. Třída unique_ptr je pohyblivá, ale nekopírovatelná, implementuje striktní sémantiku vlastnictví, aniž by to ovlivnilo bezpečnost, a funguje dobře s kontejnery, které vědí o odkazech rvalue. Třída auto_ptr je zastaralá.
Do hlavičky algoritmu> bylo přidáno <patnáct nových funkcí, find_if_notnapříklad , copy_ifa is_sorted.
<V záhlaví paměti> je nová funkce make_shared pohodlným, robustním a efektivním způsobem, jak vytvořit sdílený ukazatel na objekt současně s objektem.
Záhlaví forward_list> podporuje <ingly propojené seznamy.
Nové cbeginfunkce , cend, crbegina crend členské funkce poskytují const_iterator , která se posune dopředu nebo dozadu v kontejneru.
Hlavička <system_error> a související šablony podporují zpracování chyb systému nízké úrovně. exception_ptr Členy třídy lze použít k přenosu výjimek mezi vlákny.
Hlavička <kodeku> podporuje převod různých kódování znaků Unicode na jiné kódování.
Hlavička <alokátorů> definuje několik šablon, které pomáhají přidělovat a uvolnit bloky paměti pro kontejnery založené na uzlech.
Náhodné záhlaví obsahuje řadu aktualizací<>.

Knihovna MFC (Microsoft Foundation Class)

Funkce Systému Windows 7 MFC podporuje mnoho funkcí systému Windows 7, například uživatelské rozhraní pásu karet, hlavní panel, seznamy přeskakování, miniatury s kartami, náhledy miniatur, indikátor průběhu, překryvné ikony a indexování vyhledávání. Vzhledem k tomu, že mfc automaticky podporuje mnoho funkcí systému Windows 7, možná nebudete muset upravovat stávající aplikaci. Chcete-li podporovat další funkce v nových aplikacích, pomocí Průvodce aplikací MFC určete funkce, které chcete použít.

Vícedotykové povědomí. MFC podporuje aplikace, které mají vícedotykové uživatelské rozhraní, například aplikace napsané pro operační systém Microsoft Surface. Vícedotyková aplikace dokáže zpracovávat dotykové zprávy systému Windows a zprávy gest, což jsou kombinace dotykových zpráv. Stačí zaregistrovat aplikaci pro události dotykového ovládání a gest a operační systém bude směrovat události s více dotyky na obslužné rutiny událostí.

Vysoké rozlišení DPI. Ve výchozím nastavení jsou aplikace MFC nyní s podporou vysokého rozlišení DPI. Pokud je aplikace s podporou vysokého dpi (vysoké body na palec), může operační systém škálovat okna, text a další prvky uživatelského rozhraní na aktuální rozlišení obrazovky. To znamená, že škálovaný obrázek bude pravděpodobně správně rozložen, a ne oříznutý nebo pixelovaný.

Restartujte Správce. Správce restartování automaticky ukládá dokumenty a restartuje aplikaci, pokud se neočekávaně zavře nebo restartuje. Pomocí správce restartování můžete například spustit aplikaci po jejím zavření pomocí automatické aktualizace. Další informace o tom, jak nakonfigurovat aplikaci tak, aby používala správce restartování, naleznete v tématu Postupy: Přidání podpory správce restartování.

CTaskDialog. Třídu CTaskDialog lze použít místo standardního AfxMessageBox pole zprávy. Třída CTaskDialog zobrazí a shromáždí více informací než standardní pole se zprávou.

SafeInt – knihovna

Nová knihovna Sejf Int provádí bezpečné aritmetické operace, které představují celočíselné přetečení. Tato knihovna také porovnává různé druhy celých čísel.

Nová makra knihovny ATL (Active Template Library)

Do knihovny ATL byly přidána nová makra, aby se rozšířily funkce PROP_ENTRY_TYPE a PROP_ENTRY_TYPE_EX. PROP_ENTRY_INTERFACE a PROP_ENTRY_INTERFACE_EX umožňují přidat seznam platných identifikátorů CLSI. PROP_ENTRY_INTERFACE_CALLBACK a PROP_ENTRY_INTERFACE_CALLBACK_EX umožňují zadat funkci zpětného volání, která určuje, jestli je CLSID platný.

/analyze Warnings

Většina /analyze upozornění (Analýza podnikového kódu) byla odebrána z knihoven C Runtime (CRT), MFC a ATL.

Podpora animací a D2D

MFC teď podporuje animaci a grafiku Direct2D. Knihovna MFC má několik nových tříd a funkcí MFC, které tuto funkci podporují. Existují také dva nové názorné postupy, které ukazují, jak přidat objekt D2D a animační objekt do projektu. Tyto názorné postupy jsou návody: Přidání objektu D2D do projektu MFC a návod: Přidání animace do projektu MFC.

IDE

Vylepšená technologie IntelliSense Technologie IntelliSense pro Visual C++ byla zcela přepracovaná tak, aby byla rychlejší, přesnější a schopná zpracovávat větší projekty. Aby bylo toto vylepšení dosaženo, integrované vývojové prostředí (IDE) rozlišuje způsob zobrazení a úpravy zdrojového kódu a způsob, jakým integrované vývojové prostředí (IDE) používá ke sestavení řešení zdrojový kód a nastavení projektu. Z důvodu tohoto oddělení povinností se funkce procházení, jako je zobrazení třídy a nové dialogové okno Přejít do , zpracovává systém založený na novém souboru desktopové databáze SQL Serveru (.sdf), který nahrazuje starý soubor procházení kompilace (.ncb). Funkce IntelliSense, jako jsou rychlé informace, automatické dokončování a nápověda k analýze jednotek překladu pouze v případě potřeby. Hybridní funkce, jako je například nové okno Hierarchie volání, používají kombinaci funkcí procházení a technologie IntelliSense. Vzhledem k tomu, že IntelliSense zpracovává pouze informace, které v tuto chvíli potřebujete, je integrované vývojové prostředí (IDE) responzivní. Vzhledem k tomu, že informace jsou aktuální, jsou zobrazení ide a okna přesnější. A konečně, protože infrastruktura IDE je lépe uspořádaná, schopnější a škálovatelnější, dokáže zpracovávat větší projekty.

Vylepšené chyby IntelliSense Integrované vývojové prostředí (IDE) lépe rozpozná chyby, které by mohly způsobit ztrátu technologie IntelliSense, a pod nimi zobrazí červené vlnovky. Integrované vývojové prostředí (IDE) navíc hlásí chyby IntelliSense do okna se seznamem chyb. Chcete-li zobrazit kód, který způsobuje problém, poklikejte na chybu v okně Seznam chyb.

#include funkci automatického dokončování. Integrované vývojové prostředí (IDE) podporuje automatické dokončování pro #include klíčové slovo. Při psaní #includevytvoří integrované vývojové prostředí (IDE) rozevírací seznam platných souborů hlaviček. Pokud budete pokračovat zadáním názvu souboru, integrované vývojové prostředí filtruje seznam podle vaší položky. V libovolném okamžiku můžete ze seznamu vybrat soubor, který chcete zahrnout. Díky tomu můžete rychle zahrnout soubory bez znalosti přesného názvu souboru.

Přejděte na. Dialogové okno Přejít na umožňuje vyhledat všechny symboly a soubory v projektu, které odpovídají zadanému řetězci. Výsledky hledání se okamžitě revidují, jakmile do vyhledávacího řetězce zadáte další znaky. Pole Zpětné vazby výsledků vám řekne počet nalezených položek a pomůže vám rozhodnout, jestli se má hledání omezit. Pole Typu/Rozsah, Umístění a Náhled zpětné vazby pomáhají nejednoznačným způsobem identifikovat položky, které mají podobné názvy. Kromě toho můžete tuto funkci rozšířit tak, aby podporovala další programovací jazyky.

Paralelní ladění a profilace Ladicí program sady Visual Studio je informován o modulu Concurrency Runtime a pomáhá řešit potíže s paralelním zpracováním aplikací. Pomocí nového nástroje concurrency profiler můžete vizualizovat celkové chování aplikace. Můžete také použít nová okna nástrojů k vizualizaci stavu úloh a jejich zásobníků volání.

Návrhář pásu karet Návrhář pásu karet je grafický editor, který umožňuje vytvářet a upravovat uživatelské rozhraní pásu karet MFC. Konečné uživatelské rozhraní pásu karet je reprezentováno souborem prostředků založeným na jazyce XML (.mfcribbon-ms). U existujících aplikací můžete zachytit aktuální uživatelské rozhraní pásu karet tak, že dočasně přidáte několik řádků kódu a pak vyvoláte Návrhář pásu karet. Po vytvoření souboru prostředků pásu karet můžete kód uživatelského rozhraní na pásu karet nahradit několika příkazy, které načtou prostředek pásu karet.

Volat hierarchii Okno Hierarchie volání umožňuje přejít na všechny funkce, které jsou volány konkrétní funkcí, nebo ke všem funkcím, které volají určitou funkci.

Nástroje

Průvodce třídou MFC. Visual C++ 2010 vrací dobře známý nástroj Průvodce třídou MFC. Průvodce třídou MFC je pohodlný způsob, jak do projektu přidat třídy, zprávy a proměnné, aniž byste museli ručně upravovat sady zdrojových souborů.

Průvodce ovládacími prvky ATL. Průvodce ovládacími prvky ATL už pole automaticky nevyplní ProgID . Pokud ovládací prvek ATL nemá ProgID, nemusí s ním pracovat jiné nástroje. Jedním z příkladů nástroje, který vyžaduje, aby ovládací prvky měly ProgID ovládací prvky, je dialogové okno Vložit aktivní ovládací prvek . Další informace o dialogovém okně naleznete v části Vložit technologie ActiveX ovládací prvky.

Microsoft Macro Assembler – referenční dokumentace

Přidání datového typu YMMWORD podporuje 256bitové multimediální operandy, které jsou zahrnuty v pokynech Intel Advanced Vector Extensions (AVX).

Novinky v jazyce C++ v sadě Visual Studio 2008

Integrované vývojové prostředí (IDE) visual C++

Dialogová okna vytvořená v aplikacích ATL, MFC a Win32 nyní odpovídají pokynům pro styl systému Windows Vista. Když vytvoříte nový projekt pomocí sady Visual Studio 2008, budou všechna dialogová okna, která vložíte do aplikace, odpovídat pokynům pro styl systému Windows Vista. Pokud znovu zkompilujete projekt, který jste vytvořili pomocí starší verze sady Visual Studio, budou všechna existující dialogová okna udržovat stejný vzhled, který už měl. Další informace o tom, jak vložit dialogová okna do aplikace, naleznete v tématu Editor dialogů.
Průvodce projektem ATL teď nabízí možnost registrovat komponenty pro všechny uživatele. Počínaje sadou Visual Studio 2008 jsou komponenty modelu COM a knihovny typů vytvořené průvodcem projektu ATL registrovány v HKEY_CURRENT_USER uzlu registru, pokud nevyberete možnost Zaregistrovat součást pro všechny uživatele.
Průvodce projektem ATL již neposkytuje možnost vytvářet přiřazené projekty ATL. Počínaje sadou Visual Studio 2008 nemá průvodce projektem ATL možnost změnit stav atributu nového projektu. Všechny nové projekty ATL, které průvodce vytvoří, jsou nyní bez tlačítka.
Zápis do registru je možné přesměrovat. Při zavedení systému Windows Vista vyžaduje zápis do určitých oblastí registru program pro spuštění v režimu se zvýšenými oprávněními. Není žádoucí vždy spouštět Visual Studio v režimu se zvýšenými oprávněními. Přesměrování pro jednotlivé uživatele automaticky přesměruje zápisy registru z HKEY_CLASSES_ROOT do HKEY_CURRENT_USER bez jakýchkoli programovacích změn.
Návrhář tříd teď má omezenou podporu nativního kódu C++. V dřívějších verzích sady Visual Studio pracoval Návrhář tříd pouze s Visual C# a Visual Basicem. Uživatelé jazyka C++ teď můžou používat Návrhář tříd, ale pouze v režimu jen pro čtení. Další informace o tom, jak používat Návrhář tříd s C++, naleznete v tématu Práce s visual C++ Code v Návrháři tříd.
Průvodce projektem už nemá možnost vytvořit projekt SQL Serveru C++. Počínaje sadou Visual Studio 2008 nemá průvodce novým projektem možnost vytvořit projekt SQL Serveru C++. Projekty SQL Serveru vytvořené pomocí starší verze sady Visual Studio budou stále kompilovat a fungovat správně.

Knihovny jazyka Visual C++

OBECNÉ

Aplikace mohou být vázány na konkrétní verze knihoven Visual C++. Někdy aplikace závisí na aktualizacích provedených v knihovnách Visual C++ po vydání. V takovém případě může spuštění aplikace na počítači, který má starší verze knihoven, způsobit neočekávané chování. Teď můžete vytvořit vazbu aplikace na konkrétní verzi knihoven, aby se nespustí na počítači, který má starší verzi knihoven.

STL/CLR – knihovna

Visual C++ teď obsahuje knihovnu STL/CLR. Knihovna STL/CLR je balení standardní knihovny šablon (STL), podmnožina knihovny C++ standardu pro použití s C++ a modulem CLR (Common Language Runtime). Pomocí STL/CLR teď můžete ve spravovaném prostředí používat všechny kontejnery, iterátory a algoritmy STL.

Knihovna MFC

Systém Windows Vista podporuje běžné ovládací prvky. Bylo přidáno více než 150 metod v 18 nových nebo existujících třídách pro podporu funkcí v systému Windows Vista nebo ke zlepšení funkcí v aktuálních třídách MFC.
Nová CNetAddressCtrl třída umožňuje zadat a ověřit adresy IPv4 a IPv6 nebo názvy DNS.
Nová CPagerCtrl třída zjednodušuje použití ovládacího prvku Windows Pager.
Nová CSplitButton třída zjednodušuje použití ovládacího prvku Windows splitbutton k výběru výchozí nebo volitelné akce.

Knihovna podpory C++

Jazyk C++ zavádí zařazování knihovny. Knihovna zařazování poskytuje snadný a optimalizovaný způsob zařazování dat mezi nativními a spravovanými prostředími. Knihovna je alternativou k složitějším a méně efektivním přístupům, jako je použití PInvoke. Další informace najdete v tématu Přehled zařazování v jazyce C++ .

ATL Server

ATL Server se vydává jako sdílený zdrojový projekt.
Většina základu kódu serveru ATL byla vydána jako sdílený zdrojový projekt v CodePlex a není nainstalována jako součást sady Visual Studio 2008. Několik souborů přidružených k ATL Serveru již není součástí sady Visual Studio. Seznam odebraných souborů najdete v tématu Odebrané soubory serveru ATL.
Třídy kódování a dekódování dat z atlenc.h a utility functions a tříd z atlutil.h a atlpath.h jsou nyní součástí knihovny ATL.
Společnost Microsoft bude nadále podporovat verze ATL Serveru, které jsou součástí dřívějších verzí sady Visual Studio, pokud jsou tyto verze sady Visual Studio podporovány. CodePlex bude pokračovat ve vývoji kódu ATL Serveru jako komunitního projektu. Společnost Microsoft nepodporuje verzi CodePlex serveru ATL.

Kompilátor a linker jazyka Visual C++

Změny kompilátoru

Kompilátor podporuje spravované přírůstkové sestavení. Při zadání této možnosti kompilátor při změně odkazovaného sestavení nepřekompiluje kód. Místo toho provede přírůstkové sestavení. Soubory se překompilují jenom v případě, že změny ovlivňují závislý kód.
Atributy související se serverem ATL se už nepodporují. Kompilátor již nepodporuje několik atributů, které byly přímo spojené se serverem ATL. Úplný seznam odebraných atributů najdete v tématu Zásadní změny.
Kompilátor podporuje mikroarchitecture Intel Core. Kompilátor obsahuje ladění pro mikroarchitecture Intel Core během generování kódu. Ve výchozím nastavení je toto ladění zapnuté a nelze jej zakázat, protože také pomáhá Procesory Pentium 4 a další procesory.
Vnitřní funkce podporují novější procesory AMD a Intel. Několik nových vnitřních instrukcí podporuje větší funkčnost v novějších procesorech AMD a Intel. Další informace o nových vnitřních objektech naleznete v doplňku Streaming SIMD Extensions 3 Pokyny, Streaming SIMD Extensions 4 Pokyny, SSE4A a Advanced Bit Manipulační vnitřní funkce, AES vnitřních objektů, _mm_clmulepi64_si128 a __rdtscp.
Funkce __cpuid se aktualizuje. Funkce __cpuidnyní __cpuidex podporují několik nových funkcí z nejnovějších revizí procesorů AMD a Intel. Vnitřní __cpuidex objekt je nový a shromažďuje další informace z nedávných procesorů.
Možnost kompilátoru /MP zkracuje celkový čas sestavení. Tato /MP možnost může výrazně zkrátit celkovou dobu kompilace několika zdrojových souborů vytvořením několika procesů, které kompilují soubory současně. Tato možnost je užitečná zejména v počítačích, které podporují hyperthreading, více procesorů nebo více jader.
Možnost kompilátoru /Wp64 a __w64 klíčové slovo jsou zastaralé. Možnost kompilátoru /Wp64 a __w64 klíčové slovo, které detekuje problémy s 64bitovou přenositelností, jsou zastaralé a budou odebrány v budoucí verzi kompilátoru. Místo této možnosti kompilátoru a klíčového slova použijte MSVC, který cílí na 64bitovou platformu.
/Qfast_transcendentals generuje vložený kód pro generované generované funkce.
/Qimprecise_fwaits odebere interní příkazy fwait k vyzkoušení bloků při použití možnosti kompilátoru /fp:except .

Změny linkeru

Informace o řízení uživatelských účtů jsou nyní vloženy do souborů manifestu pro spustitelné soubory pomocí linkeru Visual C++ (link.exe). Tato funkce je ve výchozím nastavení povolena. Další informace o zakázání této funkce nebo o tom, jak změnit výchozí chování, najdete v tématu /MANIFESTUAC (Vložení informací o řízení uživatelských účtů v manifestu).
Linker má nyní /DYNAMICBASE možnost povolit funkci randomizace rozložení adresního prostoru systému Windows Vista. Tato možnost upraví hlavičku spustitelného souboru tak, aby indikovala, jestli má být aplikace náhodně znovu načítána.

Co je nového v jazyce C++ v sadě Visual Studio 2005

V sadě Visual C++ 2005 Service Pack 1 byly nové následující funkce:

Vnitřní prvky pro x86 a x64

__halt
__lidt
__nop
__readcr8
__sidt
__svm_clgi
__svm_invlpga
__svm_skinit
__svm_stgi
__svm_vmload
__svm_vmrun
__svm_vmsave
__ud2
__vmx_off
__vmx_vmptrst
__writecr8

Vnitřní prvky pouze pro platformu x64

__vmx_on
__vmx_vmclear
__vmx_vmlaunch
__vmx_vmptrld
__vmx_vmread
__vmx_vmresume
__vmx_vmwrite

Klíčová slova nového jazyka

__sptr, __uptr

Nové funkce kompilátoru

Kompilátor má v této verzi zásadní změny.

64bitové nativní a křížové kompilátory.
/analyze Byla přidána možnost kompilátoru (Analýza podnikového kódu).
/bigobj Byla přidána možnost kompilátoru.
/clr:pure/clr:oldSyntax a /clr:safebyly přidány. (Později je v sadě Visual Studio 2015 zastaralé a odebráno v sadě Visual Studio 2017.)
Zastaralé možnosti kompilátoru: Řada možností kompilátoru byla v této verzi zastaralá; Další informace najdete v tématu Zastaralé možnosti kompilátoru.
Dvojité převody v kódu se zmenší. Další informace najdete v /clr tématu Double Thunking (C++).
/EH (Model zpracování výjimek) nebo /EHs již nelze použít k zachycení výjimky, která je vyvolána jiným než vyvolání; použijte /EHa.
/errorReport Byla přidána možnost kompilátoru (Ohlásit vnitřní chyby kompilátoru).
/favor (Optimalizace pro 64) Byla přidána možnost kompilátoru.
/FAByla přidána možnost kompilátoru ( /Fa Výpis souboru).
/FC Byla přidána možnost kompilátoru úplná cesta k souboru zdrojového kódu v diagnostice.
/fp Byla přidána možnost kompilátoru zadat chování s plovoucí desetinou čárkou.
/G (Optimalizace pro procesor) Byla přidána možnost kompilátoru možností.
/G (Optimalizace pro procesor) Byla přidána možnost kompilátoru možností.
/G3Byly odebrány možnosti , /G4, /G5, /G6, /G7a /GB kompilátoru. Kompilátor teď používá "smíšený model", který se pokusí vytvořit nejlepší výstupní soubor pro všechny architektury.
/Gf byla odebrána. Místo toho použijte /GF (eliminujte duplicitní řetězce).
/GL(Kdo le Program Optimization) je nyní kompatibilní s /CLRHEADER.
/GR je teď ve výchozím nastavení zapnutá.
/GS (Kontrola zabezpečení vyrovnávací paměti) nyní poskytuje ochranu zabezpečení pro ohrožené parametry ukazatele. /GS je teď ve výchozím nastavení zapnutá. /GS nyní také funguje na funkcích zkompilovaných do jazyka MSIL s /clr kompilací (Common Language Runtime Compile).
/homeparams Byla přidána možnost kompilátoru kopírovat parametry registru do zásobníku.
/hotpatch Byla přidána možnost kompilátoru (Create Hotpatchable Image).
Heuristika vložené funkce byla aktualizována; další informace najdete v tématu inline, __forceinline__inlinea inline_depth
Bylo přidáno mnoho nových vnitřních funkcí a mnoho dříve nezdokumentovaných vnitřních objektů je nyní zdokumentováno.
Ve výchozím nastavení vyvolá jakékoli volání nového, které selže, výjimku.
/ML a /MLd možnosti kompilátoru byly odebrány. Visual C++ už nepodporuje podporu knihovny CRT s jedním vláknem.
Kompilátor implementoval optimalizaci pojmenované návratové hodnoty, která je povolena při kompilaci s /O1, /O2 (minimalizovat velikost, maximalizovat rychlost), /Og (globální optimalizace) a /Ox (úplná optimalizace).
/Oa Možnost kompilátoru byla odebrána, ale bude bezobslužně ignorována; noalias pomocí modifikátorů restrict__declspec určete, jak kompilátor aliasuje.
/Op Byla odebrána možnost kompilátoru. Místo toho použijte /fp (zadejte chování s plovoucí desetinou čárkou).
OpenMP teď podporuje Visual C++.
/openmp Byla přidána možnost kompilátoru povolit podporu OpenMP 2.0.
/Ow Možnost kompilátoru byla odebrána, ale bude bezobslužně ignorována. noalias Pomocí modifikátorů restrict__declspec můžete určit, jak kompilátor aliasuje.

Optimalizace na základě profilu

/QI0f byla odebrána.
/QIfdiv byla odebrána.
/QIPF_B Byla přidána možnost kompilátoru (Errata for B CPU Stepping).
/QIPF_C Byla přidána možnost kompilátoru (Errata for C CPU Stepping).
/QIPF_fr32 Byla přidána možnost kompilátoru (Nepoužívat horní 96 registrů s plovoucí desetinou čárkou).
/QIPF_noPIC Byla přidána možnost kompilátoru generovat závislý kód pozice.
/QIPF_restrict_plabels (Předpokládejme, že byla přidána možnost kompilátoru bez vytvořených funkcí za běhu.

Podpora kódování Unicode v kompilátoru a linkeru

/vd (Zakázat posunutí konstrukce) teď umožňuje použít operátor dynamic_cast na objektu, který je vytvořen (/vd2).
/YX Byla odebrána možnost kompilátoru. Použijte /Yc (vytvořit předkompilovaný hlavičkový soubor) nebo /Yu (místo toho použijte předkompilovaný hlavičkový soubor). Pokud z konfigurací sestavení odeberete /YX a nenahradíte ho nic, může to vést k rychlejším sestavením.
/Zc:forScope je teď ve výchozím nastavení zapnutá.
/Zc:wchar_t je teď ve výchozím nastavení zapnutá.
/Zd Byla odebrána možnost kompilátoru. Informace o ladění pouze na řádku se už nepodporují. Další informace najdete /Zi v tématu /Z7, /Zi, /ZI (formát informací o ladění).
/Zg je nyní platný pouze pro soubory zdrojového kódu jazyka C, a ne pro soubory zdrojového kódu jazyka C++.
/Zx Byla přidána možnost kompilátoru Debug Optimized Itanium Code.

Nové funkce jazyka

Atributattribute je teď zastaralý.
appdomain__declspec byl přidán modifikátor.
__clrcall Byla přidána konvence volání.
modifikátor deprecated (C++) teď umožňuje určit řetězec, který se zobrazí v době kompilace, když se uživatel pokusí získat přístup k zastaralé třídě nebo funkci.
dynamic_cast Operátor má zásadní změny.
Nativní výčty teď umožňují zadat základní typ.
jitintrinsicdeclspec byl přidán modifikátor.
noaliasdeclspec byl přidán modifikátor.
process__declspec byl přidán modifikátor.
abstraktní, přepsání a zapečetěné jsou platné pro nativní kompilace.
__restrict byla přidána klíčová slova.
restrictdeclspec byl přidán modifikátor.
__thiscall je teď klíčové slovo.
__unaligned klíčové slovo je nyní dokumentováno.
volatile (C++) aktualizoval chování s ohledem na optimalizace.

Nové funkce preprocesoru

__CLR_VER přidáno předdefinované makro.
Direktiva pragma komentáře (C/C++) teď přijímá /MANIFESTDEPENDENCY jako komentář linkeru. Možnost exestr pro komentář je nyní zastaralá.
embedded_idl atribut (Direktiva #import ) nyní přebírá volitelný parametr.
fenv_access Pragma
float_control Pragma
fp_contract Pragma
Globální proměnné nebudou inicializovány v pořadí, v jakém jsou deklarovány, pokud máte globální proměnné ve spravovaných, nespravovaných a nespravovaných oddílech. Jedná se o potenciální zásadní změnu, pokud se například nespravovaná globální proměnná inicializuje se spravovanými globálními proměnnými a vyžaduje se plně vytvořený spravovaný objekt.
Oddíly zadané init_seg jsou teď jen pro čtení a ne pro čtení a zápis jako v předchozích verzích.
inline_depth výchozí hodnota je teď 16. Výchozí hodnota 16 byla také v sadě Visual C++ .NET 2003.
_INTEGRAL_MAX_BITS předdefinované makro přidáno, viz předdefinovaná makra.
_M_CEE, _M_CEE_PURE a _M_CEE_SAFE předdefinovaných maker, viz předdefinovaná makra.
_M_IX86_FP předdefinované makro bylo přidáno.
_M_X64 předdefinované makro bylo přidáno.
make_public Pragma
managed, unmanaged aktualizována syntaxe direktivy pragma (nyní má push a pop)
knihovna mscorlib.dll je nyní implicitně odkazována direktivou #using ve všech /clr kompilacích.
_OPENMP přidáno předdefinované makro.
byla aktualizována direktiva optimize pragma a w již nejsou platné parametry.
byl přidán atribut no_registry#import.
region, endregion přidány direktivy pragmas
_VC_NODEFAULTLIB předdefinované makro bylo přidáno.
Variadická makra jsou nyní implementována.
vtordisp je zastaralý a bude odebrán v budoucí verzi Visual C++.
Direktiva warning pragma má nyní specifikátor potlačení.

Nové funkce linkeru

Moduly (výstupní soubory MSIL bez sestavení) jsou nyní povoleny jako vstup do linkeru.
/ALLOWISOLATION Byla přidána možnost linkeru (Vyhledávání manifestu).
/ASSEMBLYRESOURCE (Vložení spravovaného prostředku) bylo aktualizováno, abyste teď umožnili zadat název prostředku v sestavení a určit, že je prostředek v sestavení soukromý.
/CLRIMAGETYPE (Byla přidána možnost linkeru zadat typ image CLR.
/CLRSUPPORTLASTERROR Byla přidána možnost linkeru Zachovat poslední kód chyby pro volání PInvoke.
/CLRTHREADATTRIBUTE Byla přidána možnost linkeru nastavit atribut vlákna CLR.
/CLRUNMANAGEDCODECHECK Byla přidána možnost linkeru Add SuppressUnmanagedCodeSecurityAttribute.
/ERRORREPORT Byla přidána možnost linkeru (Ohlásit vnitřní chyby linkeru).
/EXETYPE Možnost linkeru byla odebrána. Linker už nepodporuje vytváření ovladačů zařízení s Windows 95 a Windows 98. K vytvoření těchto ovladačů zařízení použijte odpovídající sadu DDK. Klíčové slovo EXETYPE již není platné pro definiční soubory modulu.
/FUNCTIONPADMIN Byla přidána možnost linkeru Vytvořit hotpatchable Image.
/LTCG Možnost linkeru je nyní podporována v modulech zkompilovaných pomocí /clr. /LTCG byla také aktualizována tak, aby podporovala optimalizace s asistencí profilu.
/MANIFEST Byla přidána možnost linkeru vytvořit manifest sestavení vedle sebe.
/MANIFESTDEPENDENCY (Byla přidána možnost linkeru Zadat závislosti manifestu.
/MANIFESTFILE Byla přidána možnost linkeru (Name Manifest File) (Název souboru manifestu).
/MAPINFO:LINES Možnost linkeru byla odebrána.
/NXCOMPAT Byla přidána možnost linkeru kompatibilní s zabráněním spuštění dat.
/PGD (Byla přidána možnost linkeru Určit databázi pro optimalizace s asistencí profilu.
/PROFILE Byla přidána možnost linkeru (Profiler nástrojů výkonu).
/SECTION (Zadejte atributy oddílu) Možnost linkeru teď podporuje negaci atributů a už nepodporuje atributy L nebo D (VxD).
Podpora kódování Unicode v kompilátoru a linkeru
/VERBOSE (Vytisknout zprávy průběhu) Možnost linkeru nyní také přijímá ICF a ODKAZ.
/VXD Možnost linkeru byla odebrána. Linker už nepodporuje vytváření ovladačů zařízení s Windows 95 a Windows 98. K vytvoření těchto ovladačů zařízení použijte odpovídající sadu DDK. Klíčové slovo VXD už není platné pro soubory definic modulů.
/WS Možnost linkeru byla odebrána. /WSbyla použita k úpravě obrázků cílených na systém Windows NT 4.0. IMAGECFG.exe -R název souboru lze použít místo /WS. IMAGECFG.exe lze najít na systém Windows NT 4.0 CD-ROM v SUPPORT\DEBUG\I386\IMAGECFG.EXE.
/WX (Zacházet s upozorněními linkeru jako s chybami) je teď zdokumentovaná možnost linkeru.

Nové funkce linkeru

/ALLOWISOLATION Byla přidána možnost editbin.
Příkaz souboru definice modulu DESCRIPTION se odebere. Linker už nepodporuje vytváření ovladačů virtuálních zařízení.
/ERRORREPORT byla přidána možnost bscmake.exe, dumpbin.exe, editbin.exe a lib.exe.
/LTCG Byla přidána možnost lib.
/NXCOMPAT Byla přidána možnost editbin.
/RANGE Byla přidána možnost dumpbin.
/TLS Byla přidána možnost dumpbin.
/WS Byla odebrána možnost editbin. /WSbyla použita k úpravě obrázků cílených na systém Windows NT 4.0. IMAGECFG.exe -R název souboru lze použít místo /WS. IMAGECFG.exe lze najít na systém Windows NT 4.0 CD-ROM v SUPPORT\DEBUG\I386\IMAGECFG.EXE.
Byla přidána možnost knihovny /WX[:NO].

Nové funkce nástroje NMAKE

/ERRORREPORT byla přidána.
/G byla přidána.
Předdefinovaná pravidla byla aktualizována.
Makro $(MAKE), které je dokumentováno v rekurzních makrech, nyní poskytuje úplnou cestu k nmake.exe.

Nové funkce MASM

Výrazy MASM jsou nyní 64bitové hodnoty. V předchozích verzích byly výrazy MASM 32bitové hodnoty.
Instrukce __asm int 3 teď způsobí, že se funkce zkompiluje do nativního nastavení.
Alias (MASM) je teď zdokumentovaný.
/ERRORREPORT Je přidána možnost ml.exe a ml64.exe.
. FPO je teď zdokumentovaný.
H2INC.exe se nedoručí v sadě Visual C++ 2005. Pokud potřebujete nadále používat H2INC, použijte H2INC.exe z předchozí verze Visual C++.
Byl přidán operátor IMAGEREL.
byl přidán operátor HIGH32.
byl přidán operátor LOW32.
ml64.exe je verze MASM pro architekturu x64. Sestaví soubory .asm x64 do souborů objektů x64. Vložený jazyk sestavení není podporován v kompilátoru x64. Pro ml64.exe (x64) byly přidány následující direktivy MASM:
.ALLOCSTACK
.ENDPROLOG
.PUSHFRAME
.PUSHREG
.SAVEREG
.SAVEXMM128
. Kromě toho byla direktiva PROC aktualizována syntaxí jen pro64.
Byla přidána direktiva MMWORD.
/omf (ML.exe možnost příkazového řádku) nyní implikuje /c. ML.exe nepodporuje propojení objektů formátu OMF.
Direktiva SEGMENT teď podporuje další atributy.
byl přidán operátor SECTIONREL.
Byla přidána direktiva XMMWORD.

Nové funkce CRT

Byly přidány zabezpečené verze několika funkcí. Tyto funkce zpracovávají chyby lepším způsobem a vynucují přísnější kontroly vyrovnávacích pamětí, aby se zabránilo běžným chybám zabezpečení. Nové zabezpečené verze jsou identifikovány příponou _s .
Stávající méně zabezpečené verze mnoha funkcí jsou zastaralé. Pokud chcete upozornění vyřazení zakázat, definujte _CRT_SECURE_NO_WARNINGS.
Mnoho existujících funkcí teď ověřuje své parametry a volá neplatnou obslužnou rutinu parametrů, když je předán neplatný parametr.
Mnoho existujících funkcí teď nastavil errno tam, kde předtím nebyly.
Byl přidán typedef errno_t s typem integer. errno_t se používá při každém návratovém typu nebo parametru funkce řeší kódy chyb z errno. errno_terrcodenahrazuje .
Funkce závislé na národním prostředí teď mají verze, které přebírají národní prostředí jako parametr místo použití aktuálního národního prostředí. Tyto nové funkce mají příponu _l . Bylo přidáno několik nových funkcí pro práci s objekty národního prostředí. Nové funkce zahrnují _get_current_localea _create_locale_free_locale.
Byly přidány nové funkce, které podporují uzamykání a odemykání popisovačů souborů.
Řada _spawn funkcí se při úspěchu resetuje na nulu, stejně jako v předchozích verzích.
printf Verze řady funkcí, které umožňují určit pořadí, ve kterém jsou argumenty použity, jsou k dispozici.
Unicode je teď podporovaný textový formát. Funkce _open podporuje atributy _O_TEXTW, _O_UTF8 a _O_UTF16. Funkce fopen podporuje metodu ccs=ENCODING určující formát Unicode.
Nyní je k dispozici nová verze knihoven CRT integrovaných ve spravovaném kódu (MSIL) a používá se při kompilaci pomocí /clr možnosti (Common Language Runtime Compilation).
_fileinfo byla odebrána.
Výchozí velikost je time_t teď 64 bitů, což rozšiřuje rozsah time_t časových funkcí a několik časových funkcí na rok 3000.
CRT teď podporuje nastavení národního prostředí pro každé vlákno. Funkce _configthreadlocale byla přidána pro podporu této funkce.
__control87_2 Byly _statusfp2 přidány funkce, které umožňují přístup k řídicímu slovu s plovoucí desetinou čárkou a řízení na procesoru x87 i SSE2 s plovoucí desetinou čárkou.
Byly _mkgmtime přidány funkce _mkgmtime64 , které poskytují podporu pro převod časů (tm struktury) na Greenwich Mean Time (GMT).
Změny byly provedeny a swprintfvswprintf lépe v souladu se standardem.
Nový hlavičkový soubor INTRIN. H, poskytuje prototypy pro některé vnitřní funkce.
Funkce fopen teď má atribut N.
Funkce _open teď má atribut _O_NOINHERIT.
Funkce atoi teď vrací INT_MAX a nastaví errno se na ERANGE při přetečení. V předchozích verzích se chování přetečení nedefinovalo.
Řada printf funkcí podporuje šestnáctkový výstup s plovoucí desetinou čárkou implementovaný podle standardu ANSI C99 pomocí specifikátorů typu formátu %a %A.
Rodina printf teď podporuje předponu "ll" (long).
Funkce _controlfp je optimalizovaná pro lepší výkon.
Byly přidány ladicí verze některých funkcí.
Přidání _chgsignl a _cpysignl (dlouhé dvojité verze)
Přidání _locale_t typu do tabulky typů
Přidání nového makra _countof pro výpočetní počet prvků v poli
V každém tématu funkce byla přidána část o ekvivalentech rozhraní .NET Framework.
Některé řetězcové funkce nyní mají možnost zkrátit řetězce místo selhání, pokud jsou výstupní vyrovnávací paměti příliš malé; viz _TRUNCATE.
_set_se_translator nyní vyžaduje použití možnosti kompilátoru /EHa .
fpos_t je nyní __int64 ve složce /Za (pro kód jazyka C) a když je služba STDC nastavená ručně (pro kód jazyka C++). Bývalo to .struct
_CRT_DISABLE_PERFCRIT_LOCKS může zlepšit výkon vstupně-výstupních operací u programů s jedním vláknem.
Názvy POSIX byly vyřazeny ve prospěch odpovídajících názvů ISO C++ (například místo _getchgetch).
Nové možnosti odkazů jsou k dispozici pro čistý režim.
_recalloc kombinuje funkce a realloccalloc.

Co je nového pro C++ v sadě Visual Studio 2003

Compiler

Informace o tom, jak spustit aplikaci Spravovaná rozšíření jazyka C++ sestavenou pomocí kompilátoru aktuální verze na předchozí verzi modulu runtime.
Spravovaná rozšíření jazyka C++ nejčastější dotazy.
Byl přidán návod, který ukazuje, jak portovat existující nativní aplikaci pro použití Spravovaná rozšíření jazyka C++: Návod: Portování existující nativní aplikace C++ pro spolupráci s komponentami rozhraní .NET Framework.
Teď můžete vytvořit delegáta pro metodu typu hodnoty.
Pro Visual C++ .NET 2003 se výrazně zlepšila shoda kompilátoru se standardem C++.
/arch Přidá se možnost kompilátoru.
/Gf je zastaralá a bude odebrána v další verzi Visual C++.
/G7 Přidá se možnost kompilátoru.
Vylepšili jsme možnost kompilátoru /GS , která pomáhá chránit místní proměnné před přetečením přímé vyrovnávací paměti.
Byla /noBool odebrána možnost kompilátoru. Kompilátor teď umožňuje bool , aby se v souboru zdrojového kódu jazyka C++ zobrazoval pouze jako klíčové slovo (nikoli identifikátor).
Typ long long je nyní k dispozici jako typedef poznámka __int64 , že v CRT ještě není podporována long long .
Možnost /Zm kompilátoru teď určuje předkompilovaný limit přidělení paměti hlavičky.
_InterlockedCompareExchange teď zdokumentováno vnitřní.
_InterlockedDecrement teď zdokumentováno vnitřní.
_InterlockedExchange teď zdokumentováno vnitřní.
_InterlockedExchangeAdd teď zdokumentováno vnitřní.
_InterlockedIncrement teď zdokumentováno vnitřní.
_ReadWriteBarrier vnitřní přidaný.

Atributy

implements atribut je nyní zdokumentován.

Funkce linkeru

Byly přidány následující přepínače linkeru:

/ASSEMBLYDEBUG
/ASSEMBLYLINKRESOURCE
DELAYSIGN
/KEYFILE
/KEYCONTAINER
/SAFESEH

MASM

Tá. Byla přidána direktiva SAFESEH a /safeseh ml.exe možnost.

Viz také

Průvodce přenosem a upgradem Visual C++