Novinky ve Visual C++ 2003–2015

Článek
12/01/2021
75 min ke čtení

tato stránka shromažďuje všechny stránky "co je nového" pro všechny verze Visual C++ od Visual Studio 2015 zpátky do 2003. Tyto informace se poskytují jako pohodlí pro případ, že může být užitečné při upgradu z dřívějších verzí Visual Studio.

Poznámka

informace o aktuální verzi Visual Studio najdete v tématu co je nového pro Visual C++ v Visual Studio a vylepšeních dodržování shody v Visual C++ v Visual Studio.

co je nového v jazyce C++ v Visual Studio 2015

v Visual Studio 2015 a novějším, pokračující vylepšení shody kompilátoru může někdy změnit způsob, jakým kompilátor rozumí vašemu existujícímu zdrojovému kódu. V takovém případě se můžete setkat s novými nebo různými chybami v průběhu sestavení, nebo dokonce i rozdíly v kódu, které dříve vytvořili a zdály se pracovat správně.

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

I když tyto rozdíly mohou ovlivnit váš zdrojový kód nebo jiné artefakty sestavení, nemají vliv na binární kompatibilitu mezi aktualizacemi Visual C++ verzí. U složitějších typů změn může zásadní Změna ovlivnit binární kompatibilitu, ale k těmto typům binárních rozbalení dochází pouze mezi hlavními verzemi Visual C++. Například mezi Visual C++ 2013 a Visual C++ 2015. Informace o nejnovějších změnách, ke kterým došlo mezi Visual C++ 2013 a Visual C++ 2015, najdete v článku o Visual C++ historii změn 2003-2015.

vylepšení shody v Visual Studio 2015
vylepšení dodržování shody v Visual Studio 2015 Update 1
vylepšení dodržování shody v Visual Studio 2015 Update 2
vylepšení dodržování shody v Visual Studio 2015 Update 3

vylepšení shody v Visual Studio 2015

/Zc: forScope-Option

Možnost kompilátoru /Zc:forScope- je zastaralá a v budoucí verzi se odebere.
```
  Command line warning  D9035: option 'Zc:forScope-' has been deprecated and will be removed in a future release
```
Možnost byla obvykle použita, aby povolovala nestandardní kód, který používá proměnné smyčky za bodem, kde, podle standardu, by měl být mimo rozsah. Bylo nutné pouze v případě, že kompilujete s /Za možností, od bez /Za použití proměnné for Loop po konci smyčky, která je vždy povolena. Pokud si nejste jisti dodržováním standardů (například pokud váš kód není určen pro přenos do jiných kompilátorů), můžete vypnout /Za možnost (nebo nastavit vlastnost /Za na hodnotu ne). Pokud se postará o zápis přenosného kódu, který vyhovuje předpisům, měli byste přepsat kód tak, aby splňoval Standard, 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
  }
```
ZG – – možnost kompilátoru

/ZgMožnost kompilátoru (generovat prototypy funkce) už není dostupná. Tato možnost kompilátoru byla dřív zastaralá.
Nemůžete již spouštět testy jednotek pomocí jazyka C++/CLI z příkazového řádku s mstest.exe. Místo toho použijte vstest.console.exe
mutable – klíčové slovo

mutableSpecifikátor třídy úložiště již není povolen v místech, kde byla dříve zkompilována bez chyby. Nyní kompilátor poskytuje chybu C2071 (neplatná třída úložiště). Podle standardu může být proměnlivý specifikátor použit pouze pro názvy datových členů třídy a nelze jej použít na názvy deklarované jako const nebo static a nelze jej použít pro členy odkazu.

Zvažte například následující kód:
```
  struct S {
      mutable int &r;
  };
```
Předchozí verze kompilátoru Microsoft C++ tento kód přijaly, ale teď kompilátor poskytuje následující chybu:
```
  error C2071: 'S::r': illegal storage class
```
Chcete-li chybu opravit, jednoduše odeberte nadbytečné mutable klíčové slovo.
char_16_t a char32_t

V definici TypeDef už nemůžete používat char16_t nebo char32_t jako aliasy, protože tyto typy se teď považují za předdefinované. Bylo běžné, že uživatelé a autoři knihoven mají definovat char16_t a char32_t jako aliasy uint16_t a v uint32_t 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

Určitý kód, který zahrnuje parametry šablony bez typu, je nyní správně zkontrolován na kompatibilitu typu při zadání explicitních argumentů šablony. Například následující kód byl zkompilován 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ě poskytuje chybu, protože typ parametru šablony neodpovídá argumentu šablony (parametr je ukazatel na konstantní člen, 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'
```
Chcete-li vyřešit tuto chybu ve vašem kódu, ujistěte se, že typ argumentu šablony, který použijete, odpovídá deklarovanému typu parametru šablony.
__declspec(align)

Kompilátor již nepřijímá __declspec(align) funkce. To se vždycky ignoruje, ale teď vytvoří 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 nedošlo k žádnému vlivu, odebrání nemění nic.
Zpracování výjimek

Zpracovávání výjimek je několik změn. Nejprve objekty výjimky musí být buď kopírovací, nebo pohyblivý. následující kód byl zkompilován v Visual Studio 2013, ale není zkompilován v Visual Studio 2015:
```
  struct S {
  public:
      S();
  private:
      S(const S &);
  };

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

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

Zachycení výjimky podle hodnoty také vyžaduje zkopírování objektu výjimky. následující kód byl zkompilován v Visual Studio 2013, ale není zkompilován v 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 lze vyřešit změnou typu parametru pro catch odkaz.
```
  catch(D& d)
  {
  }
```
Řetězcové literály následované makry

Kompilátor teď podporuje uživatelsky definované literály. V důsledku toho jsou řetězcové literály následované makry bez použití mezer interpretovány jako uživatelsky definované literály, což může způsobit chyby nebo neočekávané výsledky. Například v předchozích kompilátorech byl následující kód úspěšně zkompilován:
```
  #define _x "there"
  char* func() {
      return "hello"_x;
  }
  int main()
  {
      char * p = func();
      return 0;
  }
```
Kompilátor tuto hodnotu interpretoval jako řetězcový literál "Hello" následovaný makrem, které rozbalí "tam" a pak dva řetězcové literály byly zřetězeny do jednoho. v Visual Studio 2015 kompilátor interpretuje toto jako literál definovaný uživatelem, ale vzhledem k tomu, že nejsou definovány žádné vyhovující uživatelsky definované literály _x definované, dojde k chybě.
```
  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.
Sousedící řetězcové literály

Podobně jako v předchozím případě v důsledku souvisejících změn v analýze řetězců, sousedících řetězcových literálů (buď v rámci velkých nebo úzkých řetězcových literálů) bez prázdných znaků byly interpretovány jako jeden zřetězený řetězec v předchozích verzích Visaul C++. v Visual Studio 2015 musíte nyní mezi dvěma řetězci přidat prázdné znaky. Například následující kód musí být změněn:
```
  char * str = "abc""def";
```
Jednoduše přidejte mezeru mezi dva řetězce.
```
  char * str = "abc" "def";
```
Umístění – nové a odstranit

U operátoru se provedla změna, delete aby se získal soulad s normou c++ 14 Standard. Podrobnosti o změně standardů najdete v části dealokace v jazyce C++. Změny přidají formulář globálního delete operátoru, který přijímá parametr velikosti. Zásadní změna znamená, že pokud jste dřív používali operátor delete se stejnou signaturou (aby odpovídal delete operátoru umístění), obdržíte chybu kompilátoru (C2956, ke které dojde v místě, kde se používá umístění New ), protože to je pozice v kódu, kde se kompilátor pokusí identifikovat příslušný odpovídající operátor.

Funkce void operator delete(void *, size_t) byla umístění operátoru void operator delete(void *, size_t) odpovídajícím funkci umístění New v c++ 11. Při dealokaci velikosti C++ 14 je tato delete funkce teď delete (globální delete operátor). Standardně se vyžaduje, aby při použití umístění nové vyhledala odpovídající funkce a vyhledala obvyklou funkci zrušení přidělení, ale program je nesprávně vytvořen.

Předpokládejme například, že váš kód definuje umístění nové a odstranění umístění:
```
  void * operator new(std::size_t, std::size_t);
  void operator delete(void*, std::size_t) noexcept;
```
K tomuto problému dochází z důvodu shody v signaturách funkcí mezi uživatelem definovaným operátorem pro odstranění umístění a novým operátorem globální velikosti. Zvažte, zda můžete použít jiný typ než size_t pro jakékoli size_t a delete operátory. Všimněte si, že typ size_ttypedef je závislý na kompilátoru, je typedef pro unsigned int v Visual C++. Dobrým řešením je použít Výčtový typ, jako je například:
```
  enum class my_type : size_t {};
```
Pak 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í do umístění New pro předání nového typu (například pomocí funkce pro převod z celočíselné hodnoty) a aktualizace definice new a delete k přetypování zpět na celočíselný typ. Pro tuto třídu nemusíte používat. enum typ třídy s size_t členem by taky fungoval.

Alternativním řešením je, že možná budete moct zcela úplně odstranit nové umístění . Pokud váš kód používá nové umístění k implementaci fondu paměti, kde argument umístění je velikost objektu, který je přidělen nebo smazán, může být funkce navrácení prostředků vhodná k nahrazení vlastního kódu vlastního fondu paměti a můžete se zbavit funkcí umístění a stačí použít vlastní operátor dvou argumentů namísto funkcí umístění.

Pokud nechcete kód hned aktualizovat, můžete se vrátit k původnímu chování pomocí možnosti kompilátoru /Zc:sizedDealloc- . Použijete-li tuto možnost, funkce dvou argumentů delete neexistují a nezpůsobí konflikt s operátorem delete .
Sjednocení datových členů

Datové členy sjednocení již nemohou mít odkazové typy. následující kód byl úspěšně zkompilován v Visual Studio 2013, ale v Visual Studio 2015 vytvoří chybu.
```
  union U1 {
      const int i;
  };
  union U2 {
     int &i;
  };
  union U3 {
      struct {int &i;};
  };
```
Předchozí kód vytvoří 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
```
Chcete-li tento problém vyřešit, změňte typ odkazu buď na ukazatel, nebo na hodnotu. Změna typu na ukazatel vyžaduje změny v kódu, který používá pole Union. Změna kódu na hodnotu by změnila data uložená ve sjednocení, která mají vliv na ostatní pole, protože pole v typech sjednocení sdílejí stejnou paměť. V závislosti na velikosti hodnoty může také dojít ke změně velikosti sjednocení.

Anonymní sjednocení

jsou nyní více vyhovující standardu. Předchozí verze kompilátoru vygenerovala explicitní konstruktor a destruktor pro anonymní sjednocení. ty se odstraní v Visual Studio 2015.

struct S {
    S();
};

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

předchozí kód generuje následující chybu v Visual Studio 2015:

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

Chcete-li vyřešit tento problém, 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é v souladu se standardem, bylo chování modulu runtime změněno pro členy anonymních struktur ve sjednoceních. Konstruktor pro členy anonymní struktury ve sjednocení již není implicitně volán při vytvoření takového sjednocení. Také destruktor pro členy anonymní struktury ve sjednocení již není implicitně volán, když se sjednocení dostanou mimo rozsah. Vezměte v úvahu následující kód, ve kterém sjednocení U obsahuje anonymní strukturu, která obsahuje člena, který je pojmenovaný strukturou S destruktorem.

  #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 Visual Studio 2013 konstruktor pro s je volán při vytvoření sjednocení a destruktor pro s je volán, když je vyčištěn zásobník funkce f. ale v Visual Studio 2015 nejsou volány konstruktor a destruktor. Kompilátor poskytuje 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í, zadejte název anonymní struktury. Běhové chování 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ě můžete zkusit přesunout konstruktor a kód destruktoru 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;
  }

Řešení šablony

Byly provedeny změny překladu názvů pro šablony. V jazyce C++ se při zvažování kandidátů na rozlišení názvu může jednat o případ, že jeden nebo více názvů, které se považují za možné shody, vytvoří neplatnou instanci šablony. Tyto neplatné instance běžně nezpůsobují chyby kompilátoru – princip, který se označuje jako SFINAE (Chyba při nahrazování není chyba).

Pokud nyní SFINAE vyžaduje, aby kompilátor vytvořil instanci specializace šablony třídy, pak všechny chyby, ke kterým dojde během tohoto procesu, jsou chyby kompilátoru. V předchozích verzích kompilátor by tyto chyby ignoroval. Zvažte 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, že v bodě prvního vyvolání is_base_of třída 'D ještě nebyla definována.

V takovém případě oprava nepoužije tyto vlastnosti typu, dokud není definována třída. Pokud přesunete definice B a D na začátek souboru kódu, dojde k vyřešení chyby. Pokud jsou definice v hlavičkových souborech, zkontrolujte pořadí příkazů include pro hlavičkové soubory, abyste se ujistili, že všechny definice tříd jsou kompilovány před použitím problematických šablon.
Kopírovací konstruktory

v Visual Studio 2013 i Visual Studio 2015 kompilátor generuje kopírovací konstruktor pro třídu, pokud tato třída má uživatelsky definovaný konstruktor přesunu, ale neexistuje uživatelsky definovaný kopírovací konstruktor. V Dev14 je tento implicitně vygenerovaný kopírovací konstruktor označený také "= Delete".

vylepšení dodržování shody v Visual Studio 2015 Update 1

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

Předchozí verze kompilátoru povolily odvozenou třídu pro volání členských funkcí svých nepřímo odvozených základních tříd. Toto staré chování bylo nesprávné a nevyhovuje standardu C++. Kompilátor již 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 (po)

  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 a operátor delete

Předchozí verze kompilátoru povolují nečlenský operátor New a nečlenský operátor delete , aby byly deklarované jako statické a deklarované v oborech názvů kromě globálního oboru názvů. Toto staré chování vytvořilo riziko, že program nevolal newdelete implementaci operátoru nebo, kterou programátor zamýšlel, a výsledkem je tiché chybné chování za běhu. Kompilátor již nepřijímá kód napsaný tímto způsobem a namísto toho vydá 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 (po)
```
  void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // removed 'static inline'
```
Kromě toho, i když kompilátor neposkytuje konkrétní diagnostiku, je včleněný operátor New považován za nesprávně vytvořený.
Volání operátoru ' Type() ' (uživatelem definovaný převod) pro typy bez třídy , které jsou předchozími verzemi typuoperátor () povoleno, aby byly volány na typy bez třídy, zatímco jsou tiše ignorovány. Toto staré chování vytvořilo riziko tichého chybného generování kódu, což vede k nepředvídatelnému chování za běhu. Kompilátor již nepřijímá kód napsaný tímto způsobem a namísto toho vydá 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 (po)
```
  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í TypeName v propracované specifikátorech typu Předchozí verze kompilátoru jsou povoleny ve vypracovaném specifikátoru typu; kód zapsaný tímto způsobem je sémanticky nesprávným. Kompilátor již nepřijímá kód napsaný tímto způsobem a namísto toho vydá 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 (po)
```
  template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case
  class container;
```

Typ srážek polí ze seznamu inicializátorů Předchozí verze kompilátoru nepodporovaly typ srážek polí ze seznamu inicializátorů. Kompilátor teď podporuje tento typ odvození typu, a proto volání šablon funkcí pomocí seznamů inicializátorů teď může být dvojznačné nebo jiné přetížení může být zvolené než v předchozích verzích kompilátoru. Aby bylo možné tyto problémy vyřešit, musí nyní program explicitně určit přetížení, které programátor zamýšlel.

V případě, že toto nové chování způsobí, že řešení přetížení považuje další kandidáta, který je stejně vhodný jako historický kandidát, volání se nejednoznační a kompilátor vyvolá chybu kompilátoru C2668.

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

Příklad 1: dvojznačné volání funkce přetížení (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 (po)

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

V případě, že toto nové chování způsobí, že při přetěžování dojde k zvážení dalšího kandidáta, který je lepší, než historický kandidát, volání se jednoznačně vyřeší na novém kandidáta, což způsobí změnu chování programu, která je pravděpodobně odlišná od zamýšleného programátora.

Příklad 2: Změna v řeš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 v řeš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řív existující upozornění související s switch příkazy. Tato upozornění se teď obnovila. Kompilátor nyní vydá obnovená upozornění a upozornění související s konkrétními případy (včetně výchozího případu) jsou nyní vydány na řádku obsahujícím problematický případ, nikoli na posledním řádku příkazu switch. V důsledku toho, že teď tato upozornění vydávají na různých řádcích než v minulosti, už se upozornění, která jste předtím potlačili, už nebudou potlačit #pragma warning(disable:####) . Chcete-li potlačit tato upozornění jako zamýšlená, může být nutné přesunout #pragma warning(disable:####) direktivu na řádek nad první potenciálně problematický případ. V následujícím seznamu 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 dokumentaci.

#include: použití specifikátoru nadřazeného adresáře '.. ' v cestě (týká se jenom /Wall/WX )

Předchozí verze kompilátoru nerozpoznaly použití specifikátoru nadřazeného adresáře... v cestě k #include direktivám. Kód psaný tímto způsobem je obvykle určen pro zahrnutí hlaviček, které existují mimo projekt, pomocí nesprávného použití relativních cest projektu. Toto staré chování vytvořilo riziko, že program může být zkompilován zahrnutím jiného zdrojového souboru, než je programátor zamýšlen, nebo zda tyto relativní cesty nebudou přenosné do jiných prostředí pro sestavení. Kompilátor nyní detekuje a upozorňuje programátora kódu napsaného tímto způsobem a vydá volitelné C4464 upozornění kompilátoru, pokud je povoleno.

warning C4464: relative include path contains '..'

Příklad (před)

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

Příklad (po)

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

I když kompilátor neposkytuje konkrétní diagnostiku, doporučujeme také, aby se pro určení adresáře include projektu použil specifikátor nadřazeného adresáře "..".
#pragma optimize () rozšiřuje poslední konec souboru hlaviček (týká se jenom /WX ).

Předchozí verze kompilátoru nerozpoznaly změny nastavení příznaku optimalizace, které řídí hlavičkový soubor zahrnutý do jednotky překladu. Kompilátor nyní detekuje a upozorňuje programátora kódu napsaného tímto způsobem a vydá volitelné upozornění kompilátoru C4426 v umístění problematické #include , pokud je povoleno. Toto upozornění je vystaveno pouze v případě, že změny jsou v konfliktu s příznaky optimalizace nastavenými argumenty příkazového řádku pro kompilátor.
```
  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 (po)
```
  // 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 upozornění (push) a upozornění #pragma (pop) (týká se jenom )

Předchozí verze kompilátoru nerozpoznaly #pragma warning(push) změny stavu spárované se #pragma warning(pop) změnami stavu v jiném zdrojovém souboru, což je zřídka zamýšlené. Toto staré chování vytvořilo riziko, že program bude zkompilován s jinou sadou upozornění, než je zamýšlený programátor, což může vést k tichému chybnému chování za běhu. Kompilátor nyní detekuje a upozorňuje 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) , pokud je povoleno. Toto upozornění obsahuje poznámku odkazující na umístění odpovídající #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 (po)

  // 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 neobvyklá, kód napsaný tímto způsobem je někdy úmyslné. Kód napsaný tímto způsobem je citlivý na změny v pořadí. Pokud je to možné, doporučujeme, aby soubory zdrojového kódu spravují stav upozornění #include samostatným způsobem.

Nekommatované #pragma warning(push) (ovlivňuje pouze /WX )

Předchozí verze kompilátoru nezjistnala na konci jednotky překladu nepřekonané #pragma warning(push) změny stavu. Kompilátor teď detekuje a upozorní programátora na kód napsaný tímto způsobem a vydá volitelné upozornění kompilátoru C5032 v umístění nepochycené , pokud je #pragma warning(push) povoleno. Toto upozornění se zobrazí 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 (po)

  // 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í se můžou #pragma upozornění.

Předchozí verze kompilátoru sledovaly změny #pragma warning stavu nedostatečně dobře pro vydání všech zamýšlených upozornění. Toto chování vytvořilo riziko, že určitá upozornění by byla efektivně potlačena za jiných okolností, než zamýšlel programátor. Kompilátor teď sleduje stav robustnější – zejména v souvislosti se změnami stavu uvnitř šablon – a volitelně vydává nová upozornění #pragma warning#pragma warning C5031 a C5032, která mají programátorům pomoci najít nezamýšlená použití a #pragma warning(push)#pragma warning(pop) .

V důsledku vylepšeného sledování změn stavu se teď můžou zobrazit upozornění dříve nesprávně potlačena nebo upozornění související s problémy dříve chybná #pragma warning diagnostika.
Vylepšená identifikace nedosažitelného kódu

Změny standardní knihovny C++ a vylepšená schopnost vkládacích volání funkcí přes předchozí verze kompilátoru mohou 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ěji vystaveným instancím upozornění C4720.
```
  warning C4720: unreachable code
```
V mnoha případech může být toto upozornění vystaveno pouze při kompilaci s povolenými optimalizacemi, protože optimalizace mohou obsahovat více volání funkcí, eliminovat redundantní kód nebo jinak zajistit, aby byl určitý kód nedostupný. Zjistili jsme, že k novým instancím upozornění C4720 často dochází v blocích try/catch, zejména ve vztahu k použití std::find.

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

Předchozí verze standardní knihovny C++ definovali šablonu funkce, která by zrušení zápisu volání funkce do řady operací pow(T, int)pow násobení. Vzhledem k povaze operací s plovoucí desetinnou čárkou by tato technika narostla velké množství nepřesnosti, což by způsobilo, že by koncové výsledky mohly být výrazně nepřesné. V Visual Studio 2015 Update 1 bylo toto chování odebráno, aby se zabránilo neúmyslné ztrátě přesnosti při pow použití funkce. Tato verze nástroje ale pow byla mnohem rychlejší než správný výpočet. Pokud tato změna způsobí výraznou regresi výkonu a váš projekt nevyžaduje přesné výsledky s plovoucí desetinnou čárkou (například projekt se už zkompiluje pomocí /fp:fast), zvažte nahrazení volání touto alternativní pow 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 stejná jako v předchozích verzích Visual Studio.

Vylepšení shody ve Visual Studio 2015 Update 2

V důsledku částečné podpory výrazu SFINAE se můžou zobrazit další upozornění a chyby.

Předchozí verze kompilátoru neparsely určité druhy výrazů uvnitř specifikátoru kvůli chybějící podpoře decltype 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 pro výraz SFINAE kvůli průběžným vylepšením shody. V důsledku toho teď kompilátor vydává upozornění a chyby nalezené ve výrazech, které předchozí verze kompilátoru neparsely.

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

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

Příklad 1: Použití nedeklarované typu (před)

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

    template<typename>
    struct s2 {};
  }

Příklad 1 (po)

  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í parsuje výraz, pro který chybí nezbytné použití klíčového 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 decltypetypename 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 (po)

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

volatilevolatile Předchozí verze kompilátoru umožnily třídu, která má členské proměnné, mít výchozí konstruktory kopírování/přesunutí a automaticky vygenerované výchozí operátory přiřazení volatile kopírování/přesunu. 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é, za ne triviální konstrukce a operátory 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ého (nebo anonymního sjednoceného spojení uvnitř třídy), konstruktory kopírování/přesunutí a operátory přiřazení kopírování/přesunutí sjednoceného sjednoceného (nebo třídy obsahující neonymní sjednocené) budou implicitně definovány jako odstraněné. Pokus o vytvoření nebo zkopírování sjednocené verze (nebo třídy obsahující anonymní sjednocené připojení) bez explicitního definování je chybou a kompilátor v důsledku toho vygeneruje chybu kompilátoru C2280.
```
  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 (po)
```
  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 umožnily statickým členských funkcím používat kvalifikátory cv. Toto chování je způsobené regresí v Visual C++ 2015 a Visual C++ 2015 Update 1. Visual C++ 2013 a předchozí verze Visual C++ tímto způsobem odmítají kód. Chování aktualizací 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 vygeneruje 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 (po)
```
  struct A
  {
    static void func();
  };

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

Dopředná deklarace výčtu není v kódu WinRT povolená (ovlivňuje pouze )

Kód zkompilovaný pro Windows Runtime (WinRT) neumožňuje předávání typů deklarovaných podobně jako při kompilaci spravovaného kódu C++ pro rozhraní .NET Framework pomocí přepínače enum/clr kompilátoru. Toto chování zajišťuje, že velikost výčtu je vždy známá a lze ji správně promítovat do systému typů WinRT. Kompilátor odmítne kód napsaný tímto způsobem a vygeneruje 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 (po)

            // 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 členu new a delete operátoru není možné deklarovat jako vložený (úroveň 1 ( ) ve výchozím nastavení je on-by-default).

Předchozí verze kompilátoru nevydá upozornění, pokud jsou funkce new a delete operátoru deklarovány jako vložené. Kód napsaný tímto způsobem je chybně formátovaný (nevyžaduje se žádná diagnostika) a může způsobit problémy s pamětí způsobené neshodou nových a odstraněných operátorů (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á upozornění kompilátoru C4595, které vám pomůže 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 (po)
```
  void* operator new(size_t sz)  // removed inline
  {
    ...
  }
```
Oprava kódu, který je napsaný tímto způsobem, může vyžadovat přesunutí definic operátorů ze souboru hlaviček a do odpovídajícího zdrojového souboru.

Vylepšení shody ve Visual Studio 2015 Update 3

std::is_convertable teď detekuje vlastní přiřazení (standardní knihovna) Předchozí verze typu vlastnosti nezjistly správně vlastní přiřazení typu třídy při odstranění nebo privátním konstruktoru kopírování. Nyní je správně nastavena na při použití na std::is_convertable<>::value typ třídy s false odstraněný nebo soukromý kopírovací konstruktor.

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 projdou, protože byly std::is_convertable<>::value nesprávně nastaveny na true . Teď je std::is_convertable<>::value správně nastavená na false , což způsobuje selhání statických kontrolních výrazů.
Výchozí nebo odstraněné triviální kopírovací a přesouvací konstruktory respektují specifikátory přístupu.

Předchozí verze kompilátoru neschytili specifikátor přístupu výchozího nebo odstraněného triviálního konstruktoru kopírování a přesunutí, než je bylo možné volat. Toto staré chování bylo nesprávné a neodpovídá standardu C++. V některých případech toto staré chování vedlo k riziku tichého špatného generování kódu, což vedlo k nepředvídatelným chováním modulu runtime. Kompilátor teď zkontroluje specifikátor přístupu výchozího nebo odstraněného triviálního konstruktoru kopírování a přesunutí, aby zjistil, jestli se může volat, a pokud ne, vydá upozornění kompilátoru C2248.
```
  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 (po)
```
  class S {
  public:
     S() = default;
  private:
      S(const S&) = default;
  };

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

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

Vyrušování podpory kódu ATL s atributy (úroveň 1 ( ) ve výchozím nastavení

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

  warning C4467: Usage of ATL attributes is deprecated

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

Příklad 1 (před)

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

Příklad 1 (po)

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

Někdy můžete potřebovat nebo vytvořit soubor IDL, abyste se vyhnuli používání zastaralých atributů ATL, jako v následujícím příkladu kódu.

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 se ujistili, že jsou generovány definice rozhraní jazyka C++.

Příklad 2 – IDL (po)

  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 souboru implementace, jako v příkladu kódu níže.

Příklad 2 Implementace (po)

  #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 neshoda #include direktiv (ovlivňuje pouze /WX )

Předchozí verze kompilátoru při použití předkompilovaných souborů hlaviček (PCH) přijímané neshodné direktivy ve zdrojových souborech mezi a #include-Yc-Yu kompilacemi. Takto napsaný kód už kompilátor nepřijímá. Kompilátor teď vydá upozornění kompilátoru CC4598, které vám pomůže identifikovat neshodné direktivy #include 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 (po)

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 neodpovídající adresáře zahrnutí (mají vliv pouze na /WX )

Předchozí verze kompilátoru při použití předkompilovaných souborů hlaviček -I-Yc (PCH) přijímaly neshodu argumentů příkazového řádku include adresáře -Yu ( ). Takto napsaný kód už kompilátor nepřijímá. Kompilátor teď vydá upozornění kompilátoru CC4599, které vám pomůže identifikovat neshodu argumentů příkazového řádku adresáře include ( -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 (po)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h -I.. Z.cpp
```

Co je nového pro C++ v Visual Studio 2013

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

Compiler

MSVC podporuje tyto funkce jazyka ISO C++11:

Výchozí argumenty šablony pro šablony funkcí.
Delegování konstruktorů
Explicitní operátory převodu.
Seznamy inicializátorů a jednotná inicializace.
Nezpracované řetězcové literály.
Variadické šablony.
Šablony aliasů.
Odstraněné funkce.
Inicializátory nestatické datového členu (NSDMI).
Výchozí funkce. *
Podporuje tyto funkce jazyka ISO C99:
_Bool
Složené literály.
Určené inicializátory.
Kombinace deklarací s kódem.
Převod řetězcového literálu na upravitelné hodnoty lze zakázat pomocí nové možnosti kompilátoru /Zc:strictStrings . V jazyce C++98 byl převod z řetězcových literálů na (a širokých řetězcových literálů na char*wchar_t* ) zastaralý. V jazyce C++11 byl převod zcela odebrán. Přestože kompilátor může striktně odpovídat standardu, místo toho poskytuje možnost , abyste /Zc:strictStrings mohli řídit převod. Ve výchozím nastavení je tato možnost vypnutá. Upozorňujeme, že pokud používáte tuto možnost v režimu ladění, STL se nezkompiluje.
Referenční přetypování rvalue/lvalue U odkazů rvalue dokáže jazyk C++11 jasně rozlišovat mezi l-hodnotami a hodnotami rvalue. Dříve kompilátor tuto možnost neposkytl v konkrétních scénářích přetypování. Byla přidána nová možnost kompilátoru , aby kompilátor odpovídal pracovnímu dokumentu jazyka /Zc:rvalueCast C++ (viz část 5.4, [expr.cast]/1). Výchozí chování, pokud tato možnost není zadaná, je stejné jako v Visual Studio 2012.

Poznámka

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

Knihovny C99

Deklarace a implementace se přidávají 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řidané jsou také nové hlavičky complex.h, stdbool.h, fenv.h a inttypes.h a implementace pro všechny funkce deklarované v nich. Aktualizují se nové hlavičky obálky C++ (ccomplex, cfenv,jemettypes, ctgmath) a řada dalších (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar a cwctype).

Standardní šablona knihovny

Podpora explicitních operátorů převodu, seznamů inicializátorů, výčtů s vymezeným oborem a variadických šablon jazyka C++11. Všechny kontejnery teď podporují jemně odsoudené požadavky na elementy C++11. Podpora pro tyto funkce C++14:

"Transparentní funktory operátorů" menší <> , větší , plus , <><> vynásobí <> atd.
make_unique T <> (args...) a make_unique < T[] > (n)
cbegin()/cend(), rbegin()/rend() a crbegin()/crend() ne členské funkce.
<atomic > získala řadu vylepšení výkonu.
<type_traits se > velká stabilizace 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ídal C++11 a správně se zkompiluje v Visual C++ v Visual Studio 2013.

vylepšení Visual C++ knihoven

Byla přidána sada C++ REST SDK. Má moderní implementaci služeb REST v jazyce C++.
C++ AMP textury je vylepšená. Teď obsahuje podporu mipmap a nových režimů vzorkování.
Úlohy PPL podporují různé technologie plánování a asynchronní ladění. Nová rozhraní API umožňují vytváření úloh PPL pro normální výsledky i podmínky výjimek.

Výkon aplikace C++

Automatická vektorizér teď rozpoznává a optimalizuje více vzorů C++, aby byl váš kód rychlejší.
Vylepšení kvality kódu platformy ARM a kódu mikro architektury Atom
__vectorcall je přidána konvence volání. Předání argumentů typu vektoru pomocí __vectorcall konvence volání pro použití registrů vektorů.
Nové možnosti linkeru. Přepínače /Gw (kompilátor) a /Gy (assembler) umožňují optimalizaci linkeru, aby se vytvářely menší binární soubory.
C++ AMP sdílení paměti pro omezení nebo eliminaci kopírování dat mezi procesorem a GPU.

Vylepšení optimalizace na základě profilu (PGO)

Zvýšení výkonu snížením pracovní sady aplikací, které jsou optimalizované pomocí PGO
Nové PGO pro vývoj Windows runtime aplikací

podpora Windows runtime aplikací

Podpora pro boxované typy ve strukturách hodnot.

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

C++/CX podporuje nový model chyb Windows, který umožňuje zachytávání Windows šíř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í.

ToString teď můžete přepsat v uživatelem definovaných typech Windows Runtime.
Podpora zastaralých rozhraní API

Rozhraní API public Windows Runtime je teď možné označit jako zastaralá a zobrazit vlastní zprávu, která se zobrazí jako upozornění sestavení a může poskytovat pokyny k migraci.
Vylepšení ladicího programu.

Podpora nativního ladění a ladění zprostředkovatele komunikace JavaScriptu, diagnostiky výjimek modulu Windows Runtime a ladění asynchronního kódu (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 Visual Studio také pomoct s lepším psaním Windows Runtime.

Vylepšení diagnostiky

Vylepšení ladicího programu. Podpora asynchronního ladění a Pouze můj kód ladění
Code Analysis kategorií. Nyní můžete zobrazit kategorizovaný výstup z Analyzátoru kódu, který vám pomůže najít a opravit chyby kódu.
Diagnostika XAML. V XAML teď můžete diagnostikovat problémy s odezvou uživatelského rozhraní a vybíjení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é C++ AMP a ladění procesoru.
Vylepšená C++ AMP runtime.
Ladění trasování shaderu výpočetního shaderu HLSL

Vylepšení 3D grafiky

Podpora kanálu obsahu obrázku pro předem vynásobený formát Alpha DDS.
Editor obrázků používá interně předem vynásobený alfa pro vykreslování a brání tak vykreslování artefaktů, jako jsou tmavé olemování.
Editory obrázků a modelů. Vytvoření uživatelem definovaného filtru je nyní podporováno v Návrháři shaderu v editoru obrázků a editoru modelů.

Prostředí IDE a produktivita

Vylepšené formátování kódu. Můžete použít další nastavení formátování pro kód jazyka C++. Pomocí těchto nastavení můžete řídit nové umístění složených závorek a klíčových slov, odsazení, mezery a zalomení řádků. Kód je automaticky zformátován při dokončování příkazů a bloků a při vložení kódu do souboru.

Dokončování složených závorek Kód jazyka C++ nyní automaticky dokončí uzavírací znaky, které odpovídají těmto znakům otevření:

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

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

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

Najít všechny odkazy teď automaticky vyřeší a filtruje odkazy na pozadí po zobrazení seznamu textových shod.

Context-Based filtrování seznamu členů. Nepřístupné členy jsou filtrovány ze seznamů členů technologie IntelliSense. Například soukromé členy nejsou zobrazeny v seznamu členů, pokud neupravujete kód, který implementuje daný typ. Když je seznam členů otevřený, můžete stisknutím kombinace kláves CTRL + odebrat jednu úroveň filtrování (platí pouze pro aktuální okno seznamu členů). Stisknutím kombinace kláves CTRLJ můžete odebrat filtrování textu a zobrazit každého člena.

Posouvání parametru help. Podpis zobrazované funkce v popisku parametru nápovědy se teď změní na základě počtu parametrů, které jste skutečně napsali, a ne pouhým zobrazením libovolného podpisu a jeho aktualizace na základě aktuálního kontextu. Parametr help také správně funguje při zobrazení ve vnořených funkcích.

Přepnout hlavičku/soubor kódu. Nyní můžete přepínat mezi hlavičkou a odpovídajícím souborem kódu pomocí příkazu v místní nabídce nebo klávesové zkratky.

okno vlastností Project C++ s možností změny velikosti

Automatické generování kódu obslužné rutiny události v jazyce 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 generovat instanci delegáta a definici obslužné rutiny události. Okno popisu se zobrazí, když je možné automaticky generovat kód obslužné rutiny události.

Vylepšení povědomí DPI. Nastavení sledování DPI pro soubory manifestu aplikace teď podporuje nastavení "pro monitorování s vysokým rozlišením DPI".

Rychlejší přepínání konfigurace. U rozsáhlých aplikací se přepínáním konfigurací – zejména následných operací přepínání – provede mnohem víc rychleji.

Efektivita při sestavování Mnohé optimalizace a využití vícejádrových jader urychlují vytváření sestavení, zejména u velkých projektů. Přírůstková sestavení pro aplikace C++, které mají odkazy na aplikaci C++ WinMD, jsou také mnohem rychlejší.

co je nového v jazyce C++ v Visual Studio 2012

Vylepšená podpora standardů C++ 11

Standardní šablona knihovny

Podpora nových hlaviček STL: < Atom > , < Chrono > , < condition_variable > , < systém souborů > , < budoucí > , < mutex > , < poměr > a < vlákno > .
Pro optimalizaci využití prostředků paměti jsou kontejnery teď menší. například v režimu vydání x86 s výchozími nastaveními se std::vector zmenšila hodnota 16 bajtů v Visual Studio 2010 až 12 bajtů v Visual Studio 2012 a v std::map Visual Studio 2010 až 8 bajtů v Visual Studio 2012.
Jak je povoleno, ale není vyžadováno standardem C++ 11, byly implementovány iterátory SCARY.

Další vylepšení pro C++ 11

Smyčky for na základě rozsahu. můžete napsat robustnější smyčky, které pracují s poli, kontejnery STL a kolekcemi prostředí Windows Runtime ve formě pro (for-range-declaration: expression). Toto je součást základní jazykové podpory.
Výrazy lambda bez stavů, které jsou bloky kódu, které začínají prázdným příznakem lambda [] a zachytit žádné místní proměnné, jsou nyní implicitně převoditelné na ukazatele funkcí, jak jsou vyžadovány standardem C++ 11.
Podpora vymezených výčtů. Klíč výčtu třídy výčtu jazyka C++ je nyní podporován. Následující kód ukazuje, jak se tento výčet 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 prostředí Windows Runtime aplikací

Nativní model uživatelského rozhraní založeného na jazyce XAML pro prostředí Windows Runtime aplikace můžete použít nový nativní model uživatelského rozhraní založeného na jazyce XAML.
Rozšíření Visual C++ komponent. tato rozšíření zjednodušují spotřebu prostředí Windows Runtime objektů, což je nezbytná součást prostředí Windows Runtimech aplikací. další informace najdete v tématu průvodce pro prostředí Windows Runtime aplikace pomocí jazyka c++ a referenční informace k jazyku Visual C++ (c++/cx) .
Hry DirectX. můžete vyvíjet poutavé hry pomocí nové podpory rozhraní DirectX pro aplikace prostředí Windows Runtime.
Spolupráce XAML/DirectX. prostředí Windows Runtime aplikace, které používají XAML i DirectX, teď fungují efektivně.
prostředí Windows Runtime vývoj knihoven DLL komponent. vývoj komponent knihovny DLL zpřístupňuje prostředí Windows Runtime prostředí.

Kompilátor a linker

Auto-vektorizace. Kompilátor analyzuje smyčky v kódu a tam, kde je to možné, vygeneruje pokyny, které používají vektorové registry a pokyny, které jsou přítomny ve všech moderních procesorech. Díky tomu se smyčky rychleji spouštějí. (Instrukce procesoru se označují jako SSE, pro Streaming SIMD Extensions). Tuto optimalizaci není nutné povolit ani vyžadovat, protože se používá automaticky.
Auto-paralelizace. Kompilátor může analyzovat smyčky v kódu a generovat pokyny, které rozšíří výpočty napříč více jádry nebo procesory. 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á začlenit do #pragma loop(hint_parallel(N)) kódu hned před smyčkami, které chcete paralelně použít.
Automatické vektorizace a auto-paralelizace mohou fungovat společně, aby výpočty byly rozloženy mezi více jader a kód v každém jádru používá své vektorové Registry.

novinka ve Visual Studio 2012 Update 1

cílový Windows XP při sestavování kódu v jazyce C++. můžete použít kompilátor a knihovny Microsoft C++ k cílení na Windows XP a Windows serveru 2003.

Podpora paralelního programování

C++ Accelerated Massive Parallelism (AMP)

C++ AMP zrychlí provádění kódu jazyka C++ využitím hardwaru dat, který je obvykle přítomen jako GPU na samostatné grafické kartě. C++ AMP programovací model zahrnuje multidimenzionální pole, indexování, přenos paměti, dělení a knihovnu matematické funkce. pomocí C++ AMP jazykové rozšíření a omezení kompilátoru můžete řídit, jak se data přesunou z procesoru do GPU a zpátky.

Tém. prostředí ladění pro aplikace, které používají C++ AMP k cílení na GPU, je stejně jako ladění pro jiné aplikace v jazyce C++. To zahrnuje nové přidané paralelní ladění, které bylo zmíněno dříve.

Profilace. nyní podporuje profilaci aktivity GPU založené na C++ AMP a dalších programovacích modelech založených na rozhraní Direct3D.

Vylepšení obecného paralelního programování

Díky přesunu hardwaru do architektur s více jádry a mnoha jádry už vývojáři nemůžou spoléhat na neustále rostoucí hodiny od jednoduchých jader. Podpora paralelního programování v Concurrency Runtime umožňuje vývojářům využít tyto nové architektury. v Visual Studio 2010 byly představeny výkonné knihovny paralelního zpracování v jazyce C++, jako je knihovna paralelních vzorů, společně s funkcemi pro využití souběžnosti tím, že vyjadřují sofistikované kanály toku dat. v Visual Studio 2012 byly tyto knihovny rozšířeny tak, aby poskytovaly lepší výkon, větší kontrolu a bohatou podporu paralelních vzorů, které vývojáři potřebují nejvíc. Nabídka teď zahrnuje:

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

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

Kromě okna Paralelní úlohy a paralelních zásobníků nabízí Visual Studio 2012 nové okno Paralelní sledování, abyste mohli prozkoumat 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 využít výhod nové podpory více procesů ve všech oknech nástrojů.

IDE – integrované vývojové prostředí

Visual Studio šablony. Nyní můžete použít technologii šablon Visual Studio k vytváření šablon projektů a položek jazyka C++.

Asynchronní načtení řešení. Projekty se teď načítá asynchronně – nejprve 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 Visual C++ zjednodušili. 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, Seznam členů a Automatické dokončování, teď fungují pro C++/CLI. Kromě toho další 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í pro C++ IntelliSense teď zobrazují bohatší informace o stylu komentářů v dokumentaci XML. Pokud používáte rozhraní API z knihovny ( například C++ AMP ), která obsahuje dokumentační komentáře XML, pak popis technologie IntelliSense zobrazí více informací než jen deklaraci. Pokud má váš kód komentáře dokumentace XML, popisy IntelliSense zobrazí bohatší informace.

Konstrukce kódu jazyka C++. Skeleton code je k dispozici pro switch, if-else, for loop a další základní konstruktory kódu v rozevíracím seznamu Seznam členů. Ze seznamu vyberte část kódu, která ho vloží 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í seznamu členů. Rozevírací seznam Seznam členů se zobrazí automaticky při psaní kódu do editoru kódu. Výsledky se filtrují, aby se při psaní zobrazují jenom relevantní členové. Druh logiky filtrování používaný seznamem členů můžete řídit v dialogovém okně Možnosti v části Textový editorC/C++Upřesnit.

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

Zvýraznění odkazu. Výběrem symbolu se teď zvýrazní všechny výskyty symbolu v aktuálním souboru. Stisknutím kláves CtrlShift šipka nahoru nebo Ctrl Shift šipka dolů se přesunete mezi zvýrazněné odkazy. Tuto funkci můžete vypnout v dialogovém okně Možnosti v části Textový editorC/C++Upřesnit.

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

Statické Code Analysis

Statická analýza pro jazyk C++ byla aktualizována tak, aby poskytovala podrobnější informace o kontextu chyb, více pravidel analýzy a lepší výsledky analýzy. V novém okně Code Analysis můžete filtrovat zprávy podle klíčového slova, projektu a závažnosti. Když v okně vyberete zprávu, v editoru kódu se zvýrazní řádek v kódu, kde byla zpráva aktivována. Pro určitá upozornění jazyka C++ je ve zprávě uveden seznam zdrojových řádků, které zobrazují cestu provádění, která vede k upozornění. Jsou zvýrazněny rozhodovací body a důvody pro přijetí této konkrétní cesty. Analýza kódu je součástí většiny edicí Visual Studio 2012. V edicích Professional, Premium a Ultimate jsou zahrnuta všechna pravidla. V edicích Express pro Windows 8 a Windows Phone jsou zahrnuta jenom 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 se ujistíte, že používáte správné obory uzamykání ve vícevláknových programech C/C++. Analyzátor detekuje potenciální konflikty časování, inverze pořadí zámků, volající/volaný uzamyká porušení smlouvy, neshodné 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 Code Analysis můžete do zdrojového kódu vložit direktivu pragma, která potlačí vybrané upozornění.
Přesnost a úplnost analýzy statického kódu můžete zvýšit pomocí nové verze jazyka anotace zdrojového kódu (SAL) společnosti Microsoft, která popisuje, jak funkce používá své parametry, předpoklady, které o nich vytváří, a záruk, které bude mít po dokončení.
Podpora 64bitových projektů C++.

Aktualizovaná rozhraní pro testování částí

K zápisu testů jednotek C++ použijte novou Visual Studio C++ pro testování částí v jazyce C++. Do stávajícího řešení C++ přidejte nový projekt testů jednotek tak, že šablonu C++ Unit Test Project v kategorii Visual C++ v dialogovém okně Nový Project souboru. Začněte psát testy jednotek ve vygenerované zástupné TEST_METHOD kódu 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 jiné Windows Průzkumníka testů jednotek a pak v místní nabídce pro testovací případ zvolte Spustit vybraný test. Po dokončení testovacího běhu můžete zobrazit výsledky testů a další informace o trasování zásobníku ve stejném okně.

Grafy závislostí architektury

Pokud chcete lépe porozumět kódu, můžete teď generovat grafy závislostí pro binární, třídu, obor názvů a zahrnout soubory v řešení. V řádku nabídek zvolte ArchitekturaGenerovat závislost Graph a pak Pro řešení nebo Pro Zahrnout soubor a vygeneruje se graf závislostí. Po dokončení generování grafu ho můžete prozkoumat rozbalením jednotlivých uzlů, seznámením se vztahy závislostí přesunutím mezi uzly a procházením zdrojového kódu výběrem možnosti Zobrazit obsah v místní nabídce uzlu. Pokud chcete vygenerovat graf závislostí pro zahrnuté soubory, zvolte v místní nabídce souboru zdrojového kódu *.cpp nebo hlavičkového souboru *.h možnost Generovat Graph souborů k zahrnutí.

Průzkumník architektury

Pomocí Průzkumníka architekturymůžete prozkoumat prostředky v řešení, projektech nebo souborech jazyka C++. V řádku nabídek zvolte Architecture (Architektura) WindowsArchitecture Explorer (Průzkumník architektury). Můžete vybrat uzel, který vás zajímá, například Zobrazení tříd. V tomto případě je pravá strana okna nástroje rozbalená se seznamem oborů názvů. Pokud vyberete obor názvů, nový sloupec zobrazí seznam tříd, struktur a výčtů v tomto oboru názvů. Můžete pokračovat v prozkoumávání těchto prostředků nebo se vrátit ke sloupci na levé straně a spustit další dotaz. Viz Vyhledání kódu pomocí Průzkumníka architektury.

Pokrytí kódu

Pokrytí kódu se aktualizovalo tak, aby dynamicky instrumentuje binární soubory za běhu. Tím se sníží režijní náklady na konfiguraci a zlepší se 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 pro ně data pokrytí kódu, v Průzkumníkutestů jednotek zvolte Analyzovat pokrytí kódu. Výsledky pokrytí kódu můžete prozkoumat v okně Výsledky pokrytí kódu – na řádku nabídek zvolte Testa Windowsvýsledky pokrytí kódu.

Co je nového pro C++ v Visual Studio 2010

Kompilátor a linker jazyka C++

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

decltype – specifikátor typu. Specifikátor decltype typu vrátí typ zadaného výrazu. Pomocí decltype specifikátoru typu v kombinaci s klíčovým slovem deklarujte typ, který je buď složitý, nebo známý auto 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 pak vrátí návratový typ vvané funkce.

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

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

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

nullptr a __nullptr keywords. MSVC umožňuje použít klíčové nullptr slovo s nativním kódem nebo se spravovaným kódem. Klíčové slovo označuje, že popisovač objektu, vnitřní ukazatel nebo nativní typ ukazatele nullptr neodkašl na objekt. Kompilátor interpretuje jako spravovaný kód, pokud použijete možnost kompilátoru, a nativní kód, pokud tuto možnost nullptr/clr/clr nevyu ídáte. Klíčové slovo specifické pro __nullptr společnosti Microsoft má stejný význam jako , ale vztahuje se pouze na nativní kód. Pokud kompilujete nativní kód C/C++ pomocí možnosti kompilátoru, kompilátor nemůže určit, zda je klíčové slovo nativní /clrnullptr nebo spravovaný termín. Aby byl váš záměr kompilátoru jasný, 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á. K povolení /Zc:trigraphs podpory trigrafů použijte možnost kompilátoru. 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 znakem interpunkce. Kompilátor například nahradí ?? = trigraph se znakem # (znak čísla). Ve zdrojových souborech jazyka C použijte trigrafy, které používají znakovou sadu, která neobsahuje určité interpunkční znaky.

Nová Profile-Guided optimalizace. PogoSafeMode je nová možnost optimalizace na základě profilu, která umožňuje určit, jestli se má při optimalizaci aplikace použít bezpečný nebo rychlý režim. Sejf je bezpečný pro vlákno, ale je pomalejší než rychlý režim. Výchozím chováním je rychlý režim.

New Common Language Runtime (CLR) Option /clr:nostdlib. Přidá se nová možnost pro /clr kompilaci modulu Common Language Runtime. Pokud jsou zahrnuty různé verze stejných knihoven, dojde k chybě kompilace. Nová možnost umožňuje vyloučit výchozí knihovny CLR, aby program mohl používat zadanou verzi.

Nová direktiva pragma detect_mismatch. Direktiva pragma detect_mismatch umožňuje umístit do souborů značku, která je porovnána s jinými značkami, které mají stejný název. Pokud je pro stejný název více hodnot, linker zobrazí chybu.

Vnitřní funkce XOP, vnitřní funkce FMA4 a vnitřní funkce LWP. Byly přidány nové vnitřní funkce pro podporu vnitřních funkcí XOP přidaných pro Visual Studio 2010 SP1, FMA4 Intrinsics Added for Visual Studio 2010 SP1 a LWP Intrinsics Added for Visual Studio 2010 SP1 processor technologies. Pomocí __cpuid __cpuidex můžete určit, které technologie procesoru jsou v určitém počítači podporovány.

Visual Studio projektů jazyka C++ a systému sestavení

MSBuild. Visual C++ řešení a projekty se teď sestaví pomocí MSBuild.exe, který nahrazuje VCBuild.exe. MSBuild je stejný flexibilní a rozšiřitelný nástroj sestavení založený na jazyce XML, který používá Visual Studio jazyky a typy projektů. Z důvodu této změny teď Visual Studio soubory projektu C++ používají formát souboru XML a mají příponu názvu souboru .vcxproj. Visual Studio soubory projektu C++ z dřívějších verzí 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 pro každý projekt pro adresáře VC++. Pomocí Správce vlastností a seznamu vlastností můžete nastavit globální hodnoty podle konfigurace pro adresáře VC++.

Project mezi Project závislostmi. V dřívějších verzích byly definované závislosti mezi projekty uloženy v souboru řešení. Když se tato řešení převedou na nový formát souboru projektu, závislosti se převedou na odkazy mezi projekty. Tato změna může mít vliv na aplikace, protože koncepty závislostí řešení a odkazů mezi projekty se liší.

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

Knihovny jazyka Visual C++

Concurrency Runtime knihovny. Rozhraní Concurrency Runtime podporuje aplikace a komponenty, které běží současně, a je to rozhraní pro programování souběžných aplikací v 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ě odsouválého paralelismu. Knihovna asynchronních agentů poskytuje programovací model založený na objektu actor a rozhraní pro předávání zpráv pro úlohy hrubého toku dat a kanálu.

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

Nová referenční funkce rvalue jazyka C++ se používá k implementaci sémantiky přesunu a dokonalého předávání pro mnoho funkcí ve standardní knihovně šablon. Sémantika přesunu a dokonalé předávání výrazně vylepšují výkon operací, které přidělují nebo přiřazují proměnné nebo parametry.
Odkazy Rvalue se také používají k implementaci nové třídy, což je bezpečnější typ unique_ptr inteligentního ukazatele než auto_ptr třída. Třída je vyměnitelná, ale ne kopírovatelná, implementuje striktní sémantiku vlastnictví bez ovlivnění bezpečnosti a dobře funguje s kontejnery, které jsou si vědomy unique_ptr odkazů rvalue. Třída auto_ptr je zastaralá.
Do záhlaví algoritmu bylo přidáno 15 nových funkcí, například find_if_notcopy_if , a is_sorted<> .
V hlavičce paměti je nová funkce < make_shared pohodlným, robustním a efektivním způsobem, jak vytvořit sdílený ukazatel na objekt ve stejnou dobu, kdy je > objekt vytvořen.
Vlastní propojené seznamy jsou podporovány < hlavičkou forward_list > tabulky.
Nové členské funkce , , a poskytují objekt , cbegincend který se crbegin přesouvá přes kontejner crendconst_iterator dopředu nebo dozadu.
Hlavička system_error a související šablony podporují zpracování systémových chyb < nízké > úrovně. Členy třídy exception_ptr lze použít k přenosu výjimek mezi vlákny.
Hlavička < codecvt > 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ělit a volné bloky <> paměti pro kontejnery založené na uzlech.
Náhodná hlavička obsahuje < mnoho > aktualizací.

Knihovna MFC (Microsoft Foundation Class)

Windows 7 funkcí. MFC podporuje mnoho funkcí Windows 7, například uživatelské rozhraní pásu karet, hlavní panel, seznamy odkazů, miniatury se záložkami, náhledy miniatur, indikátor průběhu, překryv ikon a indexování vyhledávání. Vzhledem k tomu, že knihovna MFC Windows 7 funkcí, možná nebude 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.

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

Sledování vysokého rozlišení DPI. Ve výchozím nastavení jsou teď aplikace MFC s vysokým rozlišením DPI. Pokud aplikace pracuje s vysokým rozlišením DPI (s vysokým rozlišením 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 nebude oříznut ani oříznut.

Restartujte Správce. Správce restartování automaticky ukládá dokumenty a restartuje aplikaci, pokud se neočekávaně zavře nebo restartuje. Správce restartování můžete například použít ke spuštění aplikace po zavření automatickou aktualizací. Další informace o tom, jak nakonfigurovat aplikaci pro používání správce restartování, najdete v tématu Postupy: Přidání podpory správce restartování.

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

SafeInt – knihovna

Nová knihovna SafeInt provádí bezpečné aritmetické operace, které hledí na přetečení celých čísel. Tato knihovna také porovnává různé druhy celých čísel.

Nová makra KNIHOVNY ATL (Active Template Library)

Do ATL byla přidána nová makra, která rozšiřují funkce PROP_ENTRY_TYPE a PROP_ENTRY_TYPE_EX. PROP_ENTRY_INTERFACE a PROP_ENTRY_INTERFACE_EX vám umožňují přidat seznam platných identifikátorů CLSID. PROP_ENTRY_INTERFACE_CALLBACK a PROP_ENTRY_INTERFACE_CALLBACK_EX umožňují určit funkci zpětného volání, která určí, zda je identifikátor CLSID platný.

/analyze Upozornění

Většina (Enterprise Code Analysis) upozornění byla odebrána z knihoven /analyze C Run-Time (CRT), MFC a ATL.

Animace a podpora D2D

MFC teď podporuje animace a Direct2D grafiky. Knihovna MFC má několik nových tříd knihovny MFC a funkcí, které podporují tuto funkci. Existují také dva nové návody k zobrazení, jak přidat objekt D2D a objekt animace do projektu. tyto návody jsou názorné: přidání objektu D2D do knihovny mfc Project a návod: přidání animace do Project knihovny mfc.

IDE – integrované vývojové prostředí

Vylepšená technologie IntelliSense IntelliSense pro Visual C++ byl zcela přepracován, aby byl rychlejší a přesnější a mohl zpracovávat větší projekty. Pro dosažení tohoto vylepšení rozhraní IDE rozlišuje mezi tím, jak vývojář zobrazuje a upravuje zdrojový kód, a jak rozhraní IDE používá zdrojový kód a nastavení projektu k sestavení řešení. vzhledem k tomu, že se jedná o oddělení funkcí, jsou funkce procházení, jako je například Zobrazení tříd a nový dialog přejít na , zpracovávány systémem, který je založen na novém souboru SQL Server desktopové databáze (. sdf), který nahrazuje starý soubor pro procházení sestavení (. ncb). Funkce IntelliSense, jako jsou rychlé informace, automatické dokončování a parametry, analyzují jednotky překladu pouze v případě potřeby. Hybridní funkce, jako je nové okno hierarchie volání , používají kombinaci funkcí Procházet a IntelliSense. Vzhledem k tomu, že technologie IntelliSense zpracovává pouze informace, které požadujete v okamžiku, rozhraní IDE bude lépe reagovat. Vzhledem k tomu, že jsou informace v aktuálním stavu, zobrazení IDE a Windows jsou přesnější. Vzhledem k tomu, že je infrastruktura IDE lépe uspořádaná, podporuje větší škálovatelnost a je škálovatelná, může zpracovávat větší projekty.

Vylepšené chyby technologie IntelliSense. Rozhraní IDE lépe detekuje chyby, které by mohly způsobit ztrátu technologie IntelliSense, a v nich zobrazuje červené vlnovky. Kromě toho rozhraní IDE ohlásí chyby IntelliSense do okna Seznam chyb. Chcete-li zobrazit kód, který je příčinou problému, dvakrát klikněte na chybu v okně Seznam chyb.

Funkce automatického dokončování #include. IDE podporuje automatické dokončování pro #include klíčové slovo. Když zadáte #include , rozhraní IDE vytvoří rozevírací seznam platných hlavičkových souborů. Pokud budete pokračovat zadáním názvu souboru, rozhraní IDE vyfiltruje seznam na základě vaší položky. V libovolném okamžiku můžete vybrat ze seznamu soubor, který chcete zahrnout. To vám umožní rychle zahrnout soubory bez znalosti přesného názvu souboru.

Přejděte na. Dialogové okno Přejít k umožňuje vyhledat všechny symboly a soubory v projektu, které odpovídají zadanému řetězci. Výsledky hledání jsou okamžitě revidovány při psaní dalších znaků v hledaném řetězci. V poli zpětné vazby výsledků se dozvíte, kolik položek se našlo, a pomůže vám rozhodnout se, jestli se má vaše hledání omezit. Pole druh/rozsah, umístěnía Náhled zpětné vazby vám pomůžou určit, které položky mají podobné názvy. Kromě toho můžete tuto funkci rozšířit tak, aby podporovala jiné programovací jazyky.

Paralelní ladění a profilace. ladicí program Visual Studio ví o Concurrency Runtime a pomáhá při odstraňování potíží s aplikacemi pro paralelní zpracování. K vizualizaci celkového chování aplikace můžete použít nový nástroj Concurrency Profiler. 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 vytvořit a upravit uživatelské rozhraní pásu karet MFC. Konečné uživatelské rozhraní pásu karet je reprezentované 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 dočasným přidáním několika řádků kódu a následným vyvoláním Návrháře pásu karet. Po vytvoření souboru prostředků pásu karet můžete ručně nahradit kód uživatelského rozhraní pásu karet několika příkazy, které načítají prostředek pásu karet.

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

nástroje

Průvodce třídou MFC Visual C++ 2010 vrátí do nástroje Průvodce třídou MFC, který se dobře týká. 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ím prvkem ATL. Průvodce ovládacím prvkem ATL již pole automaticky neplní ProgID . Pokud ovládací prvek ATL nemá ProgID , jiné nástroje nemusí s ním fungovat. Jedním z příkladů nástroje, které vyžadují ovládací prvky, ProgID je dialogové okno ProgID . další informace o dialogovém okně naleznete v tématu Insert technologie ActiveX controls.

Microsoft Macro Assembler – referenční dokumentace

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

co je nového v jazyce C++ v Visual Studio 2008

Visual C++ integrované vývojové prostředí (IDE)

dialogová okna, která jsou vytvořená v aplikacích ATL, MFC a Win32, teď odpovídají pokynům pro styl Windows Vista. při vytváření nového projektu pomocí Visual Studio 2008 budou všechna dialogová okna, která vložíte do vaší aplikace, odpovídat pravidlům stylu Windows Vista. pokud znovu zkompilujete projekt, který jste vytvořili v dřívější verzi Visual Studio, všechna existující dialogová okna budou mít stejný vzhled jako dříve. Další informace o tom, jak vložit dialogová okna do aplikace, naleznete v tématu Editor dialogovýchoken.
průvodce Project ATL teď má možnost registrovat komponenty pro všechny uživatele. počínaje Visual Studio 2008 se komponenty modelu COM a knihovny typů, které jsou vytvořeny pomocí průvodce ATL Project , zaregistrují v uzlu HKEY_CURRENT_USER registru, pokud nevyberete možnost registrovat komponentu pro všechny uživatele.
průvodce Project atl již neposkytuje možnost vytvářet projekty ATL s atributy. počínaje Visual Studio 2008 průvodce Project ATL nemá možnost změnit stavový atribut nového projektu. Všechny nové projekty ATL, které průvodce vytvoří, nyní nemají atribut.
Zápis do registru je možné přesměrovat. při zavádění Windows Vista vyžaduje zápis do určitých oblastí registru program, který se spustí v režimu zvýšené úrovně. v režimu zvýšeného oprávnění není třeba vždy spouštět Visual Studio. Přesměrování podle uživatele automaticky přesměruje zápisy registru z HKEY_CLASSES_ROOT na HKEY_CURRENT_USER bez jakýchkoli jakýchkoli programovacích změn.
Návrhář tříd nyní má omezené podpory pro nativní kód jazyka C++. v dřívějších verzích Visual Studio Návrhář tříd pracovala pouze v jazyce Visual C# a Visual Basic. Uživatelé C++ mohou nyní použít Návrhář tříd, ale pouze v režimu jen pro čtení. Další informace o použití Návrhář tříd s C++ naleznete v tématu práce s kódem Visual C++ v Návrhář tříd.
průvodce projektem již nemá možnost vytvořit projekt SQL Server C++. počínaje Visual Studio 2008, průvodce vytvořením nového projektu nemá možnost vytvořit projekt C++ SQL Server. SQL Server projekty vytvořené pomocí starší verze Visual Studio bude stále zkompilován a fungovat správně.

Knihovny jazyka Visual C++

Obecné

Aplikace mohou být vázány na konkrétní verze Visual C++ knihoven. Někdy aplikace závisí na aktualizacích, které byly provedeny v knihovně Visual C++ po vydání verze. 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í. Nyní můžete vytvořit vazby aplikace na konkrétní verzi knihoven, aby se nespouštěla v počítači, který má starší verzi knihoven.

STL/CLR – knihovna

Visual C++ nyní obsahuje knihovnu STL/CLR. knihovna STL/CLR je balíčkem knihovny standard Template library (STL), podmnožinou standardní knihovny jazyka c++ pro použití s jazykem c++ a .NET Framework common language runtime (CLR). Pomocí STL/CLR teď můžete ve spravovaném prostředí použít všechny kontejnery, iterátory a algoritmy STL.

Knihovna MFC

Windows Vista podporuje běžné ovládací prvky. k podpoře funkcí v systému Windows Vista bylo přidáno více než 150 metod v 18 nových nebo existujících třídách, nebo pro zlepšení funkčnosti v aktuálních třídách MFC.
Nová CNetAddressCtrl Třída umožňuje zadávání a ověřování adres IPv4 a IPv6 nebo názvů DNS.
nová CPagerCtrl třída zjednodušuje použití ovládacího prvku Windows stránkování.
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. Zařazovací knihovna poskytuje snadný a optimalizovaný způsob, jak zařazovat data 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 například použití PInvoke. Další informace najdete v tématu Přehled zařazování v jazyce C++ .

Server ATL

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

Visual C++ kompilátor a linker

Změny kompilátoru

Kompilátor podporuje spravovaná přírůstková sestavení. Když zadáte tuto možnost, kompilátor nebude po změně odkazovaného sestavení překompilovat kód. Místo toho provede přírůstkové sestavení. Soubory jsou znovu zkompilovány pouze v případě, že změny mají vliv na závislý kód.
Atributy související se serverem ATL již nejsou podporovány. Kompilátor už nepodporuje několik atributů, které přímo souvisejí s ATL serverem. Úplný seznam odebraných atributů najdete v tématu průlomové změny.
Kompilátor podporuje architekturu Intel Core. Kompilátor obsahuje ladění pro mikroarchitekturu Intel Core během generování kódu. Ve výchozím nastavení je toto ladění zapnuté a nedá se zakázat, protože taky pomáhá procesorům Pentium 4 a dalším procesorům.
Vnitřní objekty 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 najdete v tématu dodatečné streaming SIMD Extensions 3 pokyny, streaming SIMD Extensions 4 pokyny, SSE4A a pokročilá vnitřní manipulace, vnitřní prvky AES, _mm_clmulepi64_si128a __rdtscp.
__cpuidFunkce je aktualizována. __cpuid__cpuidex Funkce teď podporuje několik nových funkcí z nejnovějších revizí procesorů AMD a Intel. __cpuidexVnitřní je nová a shromažďuje další informace z posledních procesorů.
/MPMožnost kompilátoru zkracuje celkový čas sestavení. /MPMožnost může významně zkrátit celkovou dobu pro zkompilování několika zdrojových souborů vytvořením několika procesů, které soubory zkompiluje současně. Tato možnost je užitečná hlavně v počítačích, které podporují multithreading, více procesorů nebo více jader.
/Wp64Možnost kompilátoru a __w64 klíčové slovo jsou zastaralé. /Wp64Možnost kompilátoru a __w64 klíčové slovo, které zjišťují problémy přenositelnosti 64, jsou zastaralé a v budoucí verzi kompilátoru budou odebrány. namísto této možnosti kompilátoru a klíčového slova použijte MSVC, která cílí na 64 platformu.
/Qfast_transcendentals vygeneruje vložený kód pro transcendentní funkce.
/Qimprecise_fwaits Odebere příkazy fwait interní pro try Blocks při použití /fp:except Možnosti kompilátoru.

Linker – změny

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í povolená. Další informace o tom, jak tuto funkci zakázat, nebo jak změnit výchozí chování, najdete v tématu /MANIFESTUAC (vložení informací o nástroji Řízení uživatelských účtů v manifestu).
linker teď má /DYNAMICBASE možnost povolit funkci náhodnosti rozložení adresního prostoru Windows Vista. Tato možnost upraví hlavičku spustitelného souboru, aby označovala, zda by měla být aplikace náhodně založena v době načítání.

co je nového v jazyce C++ v Visual Studio 2005

V Visual C++ 2005 Service Pack 1 byly novinkou následující funkce:

Vnitřní objekty 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í objekty pouze pro platformu x64

__vmx_on
__vmx_vmclear
__vmx_vmlaunch
__vmx_vmptrld
__vmx_vmread
__vmx_vmresume
__vmx_vmwrite

Nová klíčová slova jazyka

__sptr, __uptr

Nové funkce kompilátoru

Kompilátor v této verzi přerušuje změny.

64 bitové nativní a křížové kompilátory.
/analyze(Enterprise Code Analysis) byla přidána možnost kompilátoru.
/bigobj byla přidána možnost kompilátoru.
/clr:purebyly /clr:safe přidány, a /clr:oldSyntax . (později zastaralé v Visual Studio 2015 a odebrané v Visual Studio 2017.)
Zastaralé možnosti kompilátoru: mnoho možností kompilátoru je v této verzi zastaralé; Další informace najdete v tématu zastaralé možnosti kompilátoru .
Dvojitá dvojitý v /clr kódu je zmenšena; Další informace naleznete v tématu /clr .
/EH (Model zpracování výjimek) nebo /EHs již nemůže být použit k zachycení výjimky, která je vyvolána s jinou výjimkou throw; use /EHa .
/errorReport (Sestava vnitřních chyb kompilátoru) byla přidána možnost kompilátoru.
/favor (Optimalizováno pro 64) byla přidána možnost kompilátoru.
/FA, /Fa (Soubor výpisu) – byla přidána možnost kompilátoru.
/FC (Úplná cesta k souboru zdrojového kódu v diagnostice) byla přidána možnost kompilátoru.
/fp (Určení chování Floating-Point) byla přidána možnost kompilátoru.
/G (Optimalizovat pro procesor) Byla přidána možnost kompilátoru Options.
/G (Optimalizovat pro procesor) Byla přidána možnost kompilátoru Options.
/G3byly /G4/G5 odebrány možnosti kompilátoru,,, /G6 , /G7 a /GB . Kompilátor teď používá "smíšený model", který se pokouší vytvořit nejlepší výstupní soubor pro všechny architektury.
/Gf bylo odebráno. /GFMísto toho použijte (Eliminujte duplicitní řetězce).
/GL (Celková optimalizace programu) je teď kompatibilní s /CLRHEADER .
/GR je teď ve výchozím nastavení zapnuté.
/GS (Kontrolu zabezpečení vyrovnávací paměti) nyní poskytuje ochranu zabezpečení pro parametry ukazatele na hrozby. /GS je teď ve výchozím nastavení zapnuté. /GS nyní funguje také u funkcí kompilovaných do jazyka MSIL pomocí /clr (kompilace modulu Common Language Runtime).
/homeparams (Kopírování parametrů registru do zásobníku) byla přidána možnost kompilátoru.
/hotpatch (Vytvoření image opravitelnou za provozu) – byla přidána možnost kompilátoru.
Byly aktualizovány heuristiky vložených funkcí. Další informace najdete v tématech inline , __inline__forceinline a inline .
Přidali jsme mnoho nových vnitřních funkcí a teď jsme si popsali spoustu dříve nedokumentovaných vnitřních objektů.
Ve výchozím nastavení jakékoli volání New, které selže, vyvolá výjimku.
/ML a /MLd Možnosti kompilátoru byly odebrány. Visual C++ už nepodporuje staticky propojenou podporu knihoven CRT s jedním vláknem.
Kompilátor implementoval pojmenovanou optimalizaci pro návratovou hodnotu, která je povolena při kompilování s /O1 , /O2 (minimalizuje velikost, maximální rychlost), /Og (globální optimalizace) a /Ox (úplná optimalizace).
/Oa možnost kompilátoru byla odebrána, ale bude bezobslužně ignorována. Pomocí noaliasrestrict__declspec modifikátorů nebo určete, jak kompilátor aliasy používá.
/Op byla odebrána možnost kompilátoru. Místo /fp toho použijte (Floating-Point chování).
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. noaliasModifikátory nebo použijte k určení restrict__declspec způsobu, jakým kompilátor aliasy používá.

Optimalizace na základě profilu

/QI0f byl odebrán.
/QIfdiv byl odebrán.
/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žívejte registry s plovoucí desetinnou čárkou upper 96.
/QIPF_noPIC Byla přidána možnost kompilátoru (Generovat závislý kód pozice).
/QIPF_restrict_plabels (Předpokládejme, že nebyly přidány žádné funkce vytvořené za běhu).

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

/vd (Zakázat posunutí konstrukcí) teď umožňuje používat dynamic_cast operátor pro vytvořený objekt (/vd2).
/YX Byla odebrána možnost kompilátoru. Místo /Yc toho použijte (Vytvořit předkompilovaný hlavičkový soubor) nebo /Yu (Použít předkompilovaný hlavičkový soubor). Pokud z konfigurací sestavení odeberete a nic nenahradíte, může to způsobit /YX rychlejší sestavení.
/Zc:forScope je nyní ve výchozím nastavení povoleno.
/Zc:wchar_t je nyní ve výchozím nastavení povoleno.
/Zd Byla odebrána možnost kompilátoru. Informace o ladění pouze s čísly řádků se už nepodporují. Místo toho použijte (další informace /Zi najdete v tématu /Zi 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 Ladění optimalizovaného kódu Itanium.

Nové funkce jazyka

Atribut attributeattribute je teď zastaralý.
appdomain__declspec Byl přidán modifikátor .
__clrcall byla přidána konvence volání.
Deprecated (C++) declspec modifikátor teď umožňuje zadat řetězec, který se zobrazí v době kompilace, když se uživatel pokusí o přístup k zastaralé třídě nebo funkci.
dynamic_cast Operátor má rozbíjení změn.
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 .
abstract, overridea sealed jsou platné pro nativní kompilace.
__restrict bylo přidáno klíčové slovo .
restrictdeclspec Byl přidán modifikátor .
__thiscall je teď klíčové slovo.
__unaligned Klíčové slovo je teď zdokumentované.
volatile (C++) má aktualizované chování s ohledem na optimalizace.

Nové funkce preprocesoru

__CLR_VER bylo přidáno předdefinované makro.
Direktiva pragma comment (C/C++) teď přijímá /MANIFESTDEPENDENCY jako komentář linkeru. Možnost exestrovat komentář je teď zastaralá.
embedded_idl Atribut #import (Direktiva) teď přijímá volitelný parametr.
fenv_access Pragma
float_control Pragma
fp_contract Pragma
Globální proměnné nebudou inicializovány v pořadí, v pořadí, ve které jsou deklarovány, pokud máte globální proměnné v oddílech spravovaných, nespravovaných a nespravovaných direktivou pragma. Jedná se o potenciální změnu, která může narušovat, pokud je například nespravovaná globální proměnná inicializována 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 v platnosti také v Visual C++ .NET 2003.
_INTEGRAL_MAX_BITS bylo přidáno předdefinované makro, viz Předdefinovaná makra.
_M_CEE, _M_CEE_PURE a _M_CEE_SAFE předdefinovaná makra najdete v tématu Předdefinovaná makra.
_M_IX86_FP bylo přidáno předdefinované makro.
_M_X64 bylo přidáno předdefinované makro.
make_public Pragma
managed, unmanaged aktualizace syntaxe pragma (teď má a pushpop )
mscorlib.dll je teď implicitně odkazováno #using direktivou Ve všech /clr kompilacích.
_OPENMP bylo přidáno předdefinované makro.
Byla aktualizována direktiva optimize pragma, a w už nejsou platné parametry.
no_registry byl přidán atribut #import.
region, endregion přidané direktivy pragma
_VC_NODEFAULTLIB bylo přidáno předdefinované makro.
Nyní jsou implementována variadická makra.
vtordisp je zastaralý a bude odebrán v budoucí verzi Visual C++.
Direktiva warning pragma má teď specifikátor potlačení.

Nové funkce linkeru

Moduly (výstupní soubory jazyka MSIL, které nejsou sestavením) jsou nyní povoleny jako vstup linkeru.
/ALLOWISOLATION Byla přidána možnost linkeru (Vyhledávání manifestu).
/ASSEMBLYRESOURCE (Vložení spravovaného prostředku) bylo aktualizováno tak, aby teď bylo možné zadat název prostředku v sestavení a určit, že prostředek je v sestavení soukromý.
/CLRIMAGETYPE (Zadat typ clr image) byla přidána možnost linkeru.
/CLRSUPPORTLASTERROR Byla přidána možnost linkeru Preserve Last Error Code for PInvoke Calls (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 Report Internal Linker (Ohlásit vnitřní chyby linkeru).
/EXETYPE byla odebrána možnost linkeru. Linker už nepodporuje vytváření ovladačů zařízení Windows 95 a Windows 98. K vytvoření těchto ovladačů zařízení použijte odpovídající DDK. Klíčové slovo EXETYPE už není platné pro definiční soubory modulu.
/FUNCTIONPADMIN Byla přidána možnost linkeru Create Hotpatchable Image (Vytvořit hotpatchable image).
/LTCG Možnost linkeru se teď podporuje u modulů zkompilovaných pomocí /clr . /LTCG byla také aktualizována tak, aby podporovala optimalizace na základě 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 (Název souboru manifestu).
/MAPINFO:LINES byla odebrána možnost linkeru.
/NXCOMPAT Byla přidána možnost linkeru (Kompatibilní s prevencí spuštění dat).
/PGD (Zadat databázi pro Profile-Guided) byla přidána možnost linkeru.
/PROFILE Byla přidána možnost linkeru (Profiler nástrojů pro výkon).
/SECTION Možnost linkeru (Zadat atributy oddílu) teď podporuje negaci atributů a už nepodporuje atributy L nebo D (související s VxD).
Podpora kódování Unicode v kompilátoru a linkeru
/VERBOSE Možnost linkeru (Print Progress Messages) teď také přijímá ICF a REF.
/VXD byla odebrána možnost linkeru. Linker už nepodporuje vytváření ovladačů zařízení Windows 95 a Windows 98. K vytvoření těchto ovladačů zařízení použijte odpovídající DDK. Klíčové slovo VXD už není platné pro definiční soubory modulu.
/WS byla odebrána možnost linkeru. /WSse používá k úpravě imagí cílených na systém Windows NT 4.0. IMAGECFG.exe -R můžete místo použít název souboru /WS .R. IMAGECFG.exe najdete na disku CD-ROM systém Windows NT 4.0 v SUPPORT\DEBUG\I386\IMAGECFG.EXE.
/WX Možnost linkeru (Zacházet s upozorněními linkeru jako s chybami) je teď zdokumentovaná.

Nové funkce linkeru

/ALLOWISOLATION Byla přidána možnost editbin.
Příkaz definiční souboru modulu DESCRIPTION je odebraný. 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 Možnost editbin byla odebrána. /WSse používá k úpravě imagí cílených na systém Windows NT 4.0. IMAGECFG.exe -R můžete místo použít název souboru /WS .R. IMAGECFG.exe najdete na disku CD-ROM systém Windows NT 4.0 v SUPPORT\DEBUG\I386\IMAGECFG.EXE.
Byla přidána možnost knihovny /WX[:NO].

Nové funkce NMAKE

/ERRORREPORT byla přidána.
/G byla přidána.
Předdefinovaná pravidla se aktualizovala.
Makro $(MAKE), které je zdokumentované v makrech rekurze, teď poskytuje úplnou cestu k nmake.exe.

Nové funkce MASM

Výrazy MASM jsou teď 64bitové hodnoty. V předchozích verzích byly výrazy MASM 32bitové hodnoty.
Instrukce __asm int 3 teď způsobí, že funkce bude zkompilována do nativního režimu.
Alias (MASM) je teď zdokumentovaný.
/ERRORREPORT ml.exe a ml64.exe je přidaná možnost.
. Objekt zásad skupiny je teď zdokumentovaný.
H2INC.exe se do Visual C++ 2005. Pokud potřebujete H2INC dál používat, 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. Kompilátor x64 nepodporuje vložený jazyk sestavení. Následující direktivy MASM byly přidány pro ml64.exe (x64):
.ALLOCSTACK
.ENDPROLOG
.PUSHFRAME
.PUSHREG
.SAVEREG
.SAVEXMM128
. SETFRAME Kromě toho byla direktiva PROC aktualizována syntaxí pouze pro x64.
Byla přidána direktiva MMWORD.
/omf (ML.exe příkazového řádku) teď implikuje /c . ML.exe nepodporuje propojování 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 lépe zvládá chyby a vynucuje přísnější kontroly vyrovnávacích pamětí, aby se předešlo běžným chybám zabezpečení. Nové zabezpečené verze jsou identifikovány příponou _s zabezpečení.
Stávající méně zabezpečené verze mnoha funkcí jsou zastaralé. Pokud chcete zakázat upozornění na vyřadit, definujte _CRT_SECURE_NO_WARNINGS.
Mnoho existujících funkcí teď ověří své parametry a vyvolá obslužnou rutinu neplatného parametru, pokud je předán neplatný parametr.
Mnoho existujících funkcí teď errno nastavuje tam, kde předtím nebyly.
Byla přidána definice typedef errno_t s typem integer. errno_t se používá pokaždé, když návratový typ funkce nebo parametr zminí kódy chyb z errno . errno_t nahradí errcode .
Funkce závislé na národního prostředí teď mají verze, které místo aktuálního národního prostředí používají národní prostředí jako parametr. Tyto nové funkce mají _l příponu. Bylo přidáno několik nových funkcí pro práci s objekty národního prostředí. Mezi nové funkce patří _get_current_locale , _create_locale a _free_locale .
Byly přidány nové funkce pro podporu zamykání a odemykání popisovačů souboru.
U rodiny funkcí se chyba při úspěchu resetuje na nulu, jako tomu bylo v _spawn předchozích verzích.
Verze rodiny funkcí, které umožňují určit pořadí, ve kterém jsou argumenty použity, printf jsou k dispozici.
Unicode je teď podporovaný textový formát. Funkce podporuje _open _O_TEXTW, _O_UTF8 a _O_UTF16 atributy. Funkce fopen podporuje metodu "ccs=ENCODING" určení formátu Unicode.
Nově je k dispozici nová verze knihoven CRT integrovaných ve spravovaném kódu (MSIL), která se používá při kompilaci s možností (Kompilace modulu /clr Common Language Runtime).
_fileinfo se odebrala.
Výchozí velikost pro je teď 64 bitů, což rozšiřuje rozsah a několik časových funkcí až time_ttime_t na rok 3000.
CRT teď podporuje nastavení národního prostředí pro vlákno. Funkce byla _configthreadlocale přidána pro podporu této funkce.
Funkce a byly přidány, aby byl umožněn přístup k řídicímu slovu s plovoucí desetinnou čárkou a řízení v procesoru x87 i SSE2 s plovoucí _statusfp2__control87_2 desetinnou čárkou.
Byly přidány funkce a , které poskytují podporu pro převod časů _mkgmtime_mkgmtime64 (strukturování tm) na gmtský střední čas (GMT).
Změny byly provedeny v swprintf a , aby lépe vswprintf odpovídaly standardu.
Nový soubor hlaviček INTRIN. H poskytuje prototypy některých vnitřních funkcí.
Funkce fopen teď má atribut N.
Funkce _open teď má _O_NOINHERIT atribut.
Funkce atoi teď při přetečení INT_MAX a nastaví na errno ERANGE. V předchozích verzích chování přetečení nebylo definováno.
Rodina funkcí podporuje šestnáctkový výstup s plovoucí desetinnou čárkou implementované podle standardu ANSI C99 pomocí specifikátoru formátu printf %a a %A.
Rodina printf teď podporuje předponu "ll" (dlouhé) velikosti.
Funkce _controlfp byla optimalizována 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ů
Bylo _countof přidáno nové makro pro výpočet počtu prvků v poli.
V každém tématu funkce byla přidána část .NET Framework ekvivalentních hodnot.
Několik řetězcových funkcí teď má možnost zkrátit řetězce, a ne selhává, pokud jsou výstupní vyrovnávací paměti příliš malé. viz _TRUNCATE.
_set_se_translator teď vyžaduje použití možnosti /EHa kompilátoru.
fpos_t je teď __int64 pod /Za (pro kód jazyka C) a když fpos_t nastaveno ručně (pro kód C++). Byla to třída struct .
_CRT_DISABLE_PERFCRIT_LOCKS může zlepšit výkon V/V programů s jedním vláknem.
Názvy POSIX jsou zastaralé ve prospěch názvů vyhovujících standardu ISO C++ (například použijte místo _getchgetch ).
Nové soubory .obj s možnostmi odkazů jsou k dispozici v čistém režimu.
_recalloc kombinuje funkce realloc a calloc .

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

Compiler

Informace o tom, jak spustit Spravovaná rozšíření jazyka C++ sestavenou pomocí kompilátoru aktuální verze v předchozí verzi modulu runtime.
Spravovaná rozšíření jazyka C++ nejčastější dotazy.
Byl přidán názorný postup, který ukazuje, jak portovat existující nativní aplikaci pro použití Spravovaná rozšíření jazyka C++: Návod: Přenos existující nativní aplikace C++ pro spolupráci s komponentami .NET Framework.
Teď můžete vytvořit delegáta pro metodu typu hodnoty.
Shoda kompilátoru se standardem C++ byla výrazně vylepšena pro Visual C++ .NET 2003.
/arch Je přidána možnost kompilátoru.
/Gf je zastaralý a bude odebrán v další verzi Visual C++.
/G7 Je přidána možnost kompilátoru.
Možnost /GS kompilátoru byla vylepšena tak, aby pomáhala chránit místní proměnné před přetečením přímé vyrovnávací paměti.
Možnost /noBool kompilátoru byla odebrána. Kompilátor teď umožňuje zobrazení pouze jako klíčové slovo (a ne jako identifikátor) v souboru bool zdrojového kódu jazyka C++.
Typ long long je teď k dispozici jako typedef__int64 poznámka, že long long crt zatím nepodporuje .
Možnost kompilátoru teď určuje limit přidělení paměti /Zm předkompilované hlavičky.
_InterlockedCompareExchange vnitřní objekt je teď zdokumentovaný.
_InterlockedDecrement vnitřní objekt je teď zdokumentovaný.
_InterlockedExchange vnitřní objekt je teď zdokumentovaný.
_InterlockedExchangeAdd vnitřní objekt je teď zdokumentovaný.
_InterlockedIncrement vnitřní objekt je teď zdokumentovaný.
_ReadWriteBarrier přidán vnitřní objekt .

Atributy

implements Atribut je teď zdokumentovaný.

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 /safeseh ml.exe možnost nastavení.

Viz také

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

Novinky ve Visual C++ 2003–2015

Ohodnoťte vaše zkušenosti

co je nového v jazyce C++ v Visual Studio 2015

vylepšení shody v Visual Studio 2015

vylepšení dodržování shody v Visual Studio 2015 Update 1

Vylepšení shody ve Visual Studio 2015 Update 2

Vylepšení shody ve Visual Studio 2015 Update 3

Co je nového pro C++ v Visual Studio 2013

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

Compiler

Knihovny C99

Standardní šablona knihovny

Zásadní změny

vylepšení Visual C++ knihoven

Výkon aplikace C++

Vylepšení optimalizace na základě profilu (PGO)

podpora Windows runtime aplikací

Vylepšení diagnostiky

Vylepšení 3D grafiky

Prostředí IDE a produktivita

co je nového v jazyce C++ v Visual Studio 2012

Vylepšená podpora standardů C++ 11

Standardní šablona knihovny

Další vylepšení pro C++ 11

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

Kompilátor a linker

novinka ve Visual Studio 2012 Update 1

Podpora paralelního programování

C++ Accelerated Massive Parallelism (AMP)

Vylepšení obecného paralelního programování

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

IDE – integrované vývojové prostředí

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

Statické Code Analysis

Aktualizovaná rozhraní pro testování částí

Grafy závislostí architektury

Průzkumník architektury

Pokrytí kódu

Co je nového pro C++ v Visual Studio 2010

Kompilátor a linker jazyka C++

Visual Studio projektů jazyka C++ a systému sestavení

Knihovny jazyka Visual C++

Knihovna MFC (Microsoft Foundation Class)

SafeInt – knihovna

Nová makra KNIHOVNY ATL (Active Template Library)

/analyze Upozornění

Animace a podpora D2D

IDE – integrované vývojové prostředí

nástroje

Microsoft Macro Assembler – referenční dokumentace

co je nového v jazyce C++ v Visual Studio 2008

Visual C++ integrované vývojové prostředí (IDE)

Knihovny jazyka Visual C++

Obecné

STL/CLR – knihovna

Knihovna MFC

Knihovna podpory C++

Server ATL

Visual C++ kompilátor a linker

Změny kompilátoru

Linker – změny

co je nového v jazyce C++ v Visual Studio 2005

Vnitřní objekty pro x86 a x64

Vnitřní objekty pouze pro platformu x64

Nová klíčová slova jazyka

Nové funkce kompilátoru

Optimalizace na základě profilu

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

Nové funkce jazyka

Nové funkce preprocesoru

Nové funkce linkeru

Nové funkce linkeru

Nové funkce NMAKE

Nové funkce MASM

Nové funkce CRT

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

Compiler

Atributy

Funkce linkeru

MASM