Visual C++ co je'2003 až 2015 nového

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

Poznámka

Informace o aktuální verzi nástroje Visual Studio najdete v tématu Co je nového pro Visual C++ v Visual Studio a vylepšeních shody v Visual C++ v Visual Studio.

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

V Visual Studio 2015 a novějších verzích může průběžná vylepšení shody kompilátoru někdy změnit způsob, jakým kompilátor rozumí vašemu stávajícímu zdrojovému kódu. Když k tomu dojde, můžete během sestavení narazit na nové nebo odlišné chyby nebo dokonce rozdíly v chování v kódu, který se dříve sestaví a zdá se, že funguje správně.

Naštěstí tyto rozdíly mají malý nebo žádný vliv na většinu zdrojového kódu a když je ke řešení těchto rozdílů potřeba zdrojový kód nebo jiné změny, jsou opravy obvykle malé a přímočaré. Zahrnuli jsme řadu příkladů dříve přijatelného zdrojového kódu, který může být potřeba změnit (dříve), a opravy, které je opraví (po).

I když tyto rozdíly mohou ovlivnit zdrojový kód nebo jiné artefakty sestavení, neovlivňuje binární kompatibilitu mezi aktualizacemi Visual C++ verzemi. Závažnější druh změny, která způsobuje chyby, může mít vliv na binární kompatibilitu, ale k těmto typům přerušení binární kompatibility dochází pouze mezi hlavními verzemi Visual C++. Například mezi Visual C++ 2013 a Visual C++ 2015. Informace o změnách, ke kterým došlo mezi Visual C++ 2013 a Visual C++ 2015, najdete v historii změn Visual C++ 2003–2015.

Vylepšení shody ve Visual Studio 2015

  • /Zc:forScope- možnost

    Možnost /Zc:forScope- kompilátoru je zastaralá a v budoucí verzi bude odebrána.

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

    Možnost se obvykle použila k povolení nestandardních kódů, který používá proměnné smyčky po bodu, kde by podle standardu měly být mimo rozsah. Bylo to nutné pouze v případě, že kompilaci s možností , protože bez , použití proměnné smyčky for po dokončení smyčky /Za /Za je vždy povoleno. Pokud vám nevyhovují standardy (například pokud váš kód není určen k přenosu do jiných kompilátorů), můžete tuto možnost vypnout (nebo nastavit vlastnost Zakázat jazyková rozšíření na /Za Ne). Pokud se staráte o psaní přenosného kódu kompatibilního se standardy, měli byste kód přepsat tak, aby odpovídal standardu přesunutím deklarace takových proměnných do bodu mimo smyčku.

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

    Možnost /Zg kompilátoru (Generování prototypů funkcí) už není dostupná. Tato možnost kompilátoru byla dříve zastaralá.

  • Testy jednotek pomocí C++/CLI už není možné spouštět z příkazového řádku s mstest.exe. Místo toho použijte vstest.console.exe

  • Mutable – klíčové slovo.

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

    Představte si například následující kód:

      struct S {
          mutable int &r;
      };
    

    Předchozí verze kompilátoru Microsoft C++ to přijaly, ale teď kompilátor zobrazí následující chybu:

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

    Pokud chcete tuto chybu opravit, stačí odebrat redundantní klíčové mutable slovo .

  • char_16_t a char32_t

    V definici typedef už není možné používat nebo jako aliasy, protože tyto typy jsou nyní považovány char16_t char32_t za předdefinované. Bylo běžné, že uživatelé a autoři knihoven definují a jako aliasy a char16_t v char32_t uvedeném uint16_t uint32_t 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;
      }
    

    Pokud chcete kód aktualizovat, odeberte deklarace a typedef přejmenujte všechny ostatní identifikátory, které koliduje s těmito názvy.

  • Parametry šablony bez typu

    Určitý kód, který zahrnuje parametry šablony bez typu, je nyní při zadání explicitních argumentů šablony správně zkontrolován z důvodu kompatibility typů. Například následující kód se zkompiloval bez chyby v předchozích verzích Visual C++.

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

    Aktuální kompilátor správně vrátí 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'
    

    Pokud chcete tuto chybu řešte v kódu, ujistěte se, že typ argumentu šablony, který použijete, odpovídá deklarovaným typům parametru šablony.

  • __declspec(align)

    Kompilátor už funkce __declspec(align) nepřijímá. To bylo vždy ignorováno, ale teď se vygeneruje chyba kompilátoru.

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

    Pokud chcete tento problém vyřešit, __declspec(align) odeberte ho z deklarace funkce. Vzhledem k tomu, že to nemá žádný vliv, jeho odebrání nic nezmění.

  • Zpracování výjimek

    Zpracování výjimek má několik změn. Nejprve musí být objekty výjimky buď kopírovatelné, nebo vyměnitelné. Následující kód je zkompilován v Visual Studio 2013, ale nezkompiluje se v Visual Studio 2015:

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

    Problém je v tom, že kopírovací konstruktor je soukromý, takže objekt nelze zkopírovat, protože k tomu dochází v běžném průběhu zpracování výjimky. Totéž platí, když je konstruktor kopírování explicit deklarován.

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

    Pokud chcete aktualizovat kód, ujistěte se, že kopírovací konstruktor pro váš objekt výjimky je veřejný a není označený explicit jako .

    Zachycení výjimky podle hodnoty také vyžaduje, aby byl objekt výjimky kopírovatelný. Následující kód je zkompilován v Visual Studio 2013, ale nezkompiluje se 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 můžete vyřešit změnou typu parametru pro catch na odkaz.

      catch(D& d)
      {
      }
    
  • Řetězcové literály následované makremi

    Kompilátor teď podporuje uživatelsky definované literály. V důsledku toho jsou řetězcové literály následované makru bez jakýchkoli intervenovaných prázdných znaků interpretovány jako literály definované uživatelem, což může způsobit chyby nebo neočekávané výsledky. Například v předchozích kompilátorech se následující kód úspěšně zkompiloval:

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

    Kompilátor to interpretoval jako řetězcový literál "hello" následovaný makru, které je rozbalené "there" a pak byly dva řetězcové literály zřetězovány do jednoho. V Visual Studio 2015 interpretuje kompilátor tento literál jako literál definovaný uživatelem, ale vzhledem k tomu, že neexistuje žádný odpovídající _x definovaný literál, 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?
    
    

    Pokud chcete tento problém vyřešit, přidejte mezeru mezi řetězcový literál a makro.

  • Sousední řetězcové literály

    Podobně jako v předchozím případě se kvůli souvisejícím změnám v parsování řetězců sousední řetězcové literály (buď široké nebo úzké znakové řetězcové literály) bez prázdných znaků interpretují v předchozích verzích visaul C++ jako jeden zřetězovaný řetězec. V Visual Studio 2015 teď musíte mezi tyto dva řetězce přidat prázdné znaky. Například následující kód musí být změněn:

      char * str = "abc""def";
    

    Jednoduše mezi tyto dva řetězce přidejte mezeru.

      char * str = "abc" "def";
    
  • Umístění nové a odstranění

    Operátor se změnil, aby byl v souladu se delete standardem C++14. Podrobnosti o změně standardů najdete na adrese C++ Sized Deallocation. Změny přidávají formu globálního delete operátoru, který přebírá parametr velikosti. Změna narušuje chybu v tom, že pokud jste dříve používali operátor se stejným podpisem (aby odpovídal operátoru umístění new), zobrazí se chyba kompilátoru delete (C2956, ke které dochází v místě, kde se používá nové umístění, protože to je pozice v kódu, kde se kompilátor pokouší identifikovat odpovídající delete operátor).

    Funkce byla void operator delete(void *, size_t) operátorem pro odstranění umístění, který odpovídá nové funkci umístění v void * operator new(size_t, size_t) jazyce C++11. U navracení s velikostí C++14 je teď tato funkce obvyklou funkcí delete navracení (globální delete operátor). Standard vyžaduje, aby v případě, že použití nového umístění vyhledá odpovídající funkci a najde obvyklou funkci delete navracení, bude program špatně formátovaný.

    Předpokládejme například, že váš kód definuje nové umístění i odstranění umístění:

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

    K tomuto problému dochází kvůli shodě v signaturách funkce mezi operátorem odstranění umístění, který jste definovali, a novým operátorem globální delete velikosti. Zvažte, zda lze použít jiný typ než pro jakékoli umístění nové a size_t delete operátory. Všimněte si, že size_t typedef typ je závislý na kompilátoru; je typedef to pro v unsigned int Visual C++. Dobrým řešením je použít výčtový typ, například:

      enum class my_type : size_t {};
    

    Pak změňte definici umístění a na použití tohoto typu jako new delete druhého argumentu místo size_t . Budete také muset aktualizovat volání do umístění new, aby bylo možné předat nový typ (například pomocí metody k převodu z celočíselné hodnoty) a aktualizovat definici a tak, aby se přetypová pro přetypování zpět na celočíselný static_cast<my_type> new delete typ. Pro tento typ není nutné používat ; bude fungovat také typ třídy s enum size_t členem.

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

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

  • Datové členy sjednocené sjednocené

    Datové členy sjednocené typy už nemají odkazové typy. Následující kód se úspěšně zkompiloval v Visual Studio 2013, ale v roce 2015 Visual Studio chybu.

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

    Předchozí kód vyprodukuje následující chyby:

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

    Pokud chcete tento problém vyřešit, změňte odkazové typy buď na ukazatel, nebo na hodnotu. Změna typu na ukazatel vyžaduje změny v kódu, který používá sjednocené pole. Změna kódu na hodnotu by změnila data uložená v sjednocené sjednocené paměti, což má vliv na ostatní pole, protože pole v typech sjednocené paměti 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 private virtual 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;
      }
    

    -ani

      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 new delete 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 typu operá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 typename 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 pouze /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 /Wall /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 /Wall /WX )

    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 psaný tímto způsobem je citlivý na změny v #include pořadí. Pokud je to možné, doporučujeme, aby soubory zdrojového kódu spravovaly stav upozornění v samostatném způsobu.

  • Upozornění na neshodné #pragma (push) (týká se jenom /Wall /WX )

    Předchozí verze kompilátoru nezjistily neshodné #pragma warning(push) změny stavu na konci 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 C5032 v umístění nespárované #pragma warning(push) , pokud je povoleno. Toto upozornění je vystaveno 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)
    
  • Další upozornění můžou být vystavena v důsledku vylepšení sledování stavu upozornění #pragma

    Předchozí verze sledovaných #pragma warning stavů kompilátoru nedostatečně dobře vydávaly všechna zamýšlená upozornění. Toto chování vytvořilo riziko, že určitá upozornění budou efektivně potlačena v jiných případech, než je programátor zamýšlen. Kompilátor teď sleduje #pragma warning stav robustnější – zejména v souvislosti se #pragma warning změnami stavu uvnitř šablon – a volitelně vydá nová upozornění C5031 a C5032, které mají pomáhat programátorovi najít nezamýšlené použití #pragma warning(push) a #pragma warning(pop) .

    V důsledku vylepšeného #pragma warning sledování změn stavu se teď můžou vydávat upozornění, která se dřív nesprávně potlačila, nebo upozornění související s dříve nezjištěnými problémy.

  • Vylepšená identifikace nedosažitelného kódu

    Změny v knihovně C++ Standard a vylepšená možnost volání vložených funkcí v předchozích verzích kompilátoru může povolit, aby kompilátor prokázal, že je nyní nedosažitelný určitý kód. Toto nové chování může mít za následek nové a více často vydaných instancí 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 vložit více volání funkce, eliminovat redundantní kód nebo jinak určit, že určitý kód je nedosažitelný. Zjistili jsme, že v blocích try/catch se často objevily nové instance varovných C4720, 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í pow(T, int) optimalizace obnovení

    Předchozí verze standardní knihovny jazyka C++ definovaly pow(T, int) šablonu funkce, která by zrušila pow volání funkce do řady násobných operací. Tato technika by v důsledku povahy operací s plovoucí desetinnou čárkou narostla velké množství nepřesnosti, což způsobí, že konečné výsledky budou výrazně nepřesné. v Visual Studio 2015 Update 1 se toto chování odebralo, aby se zabránilo neúmyslné ztrátě přesnosti při použití pow funkce. Nicméně tato verze nástroje pow byla mnohem rychlejší než správný výpočet. Pokud tato změna způsobí významné regrese výkonu a váš projekt nevyžaduje přesné výsledky plovoucí desetinné čárky (například projekt již kompiluje pomocí/FP: Fast), zvažte nahrazení volání pow pomocí této funkce alternativního řešení:

    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 shodná s tím, co bylo zahrnuto v předchozích verzích Visual Studio.

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

  • Další upozornění a chyby mohou být vydány v důsledku částečné podpory pro Expression SFINAE

    Předchozí verze kompilátoru neanalyzovaly určité druhy výrazů uvnitř decltype specifikátorů z důvodu nedostatku podpory pro Expression SFINAE. Toto staré chování bylo nesprávné a nevyhovuje standardu C++. Kompilátor nyní analyzuje tyto výrazy a má částečnou podporu pro Expression SFINAE z důvodu probíhajících vylepšení dodržování shody. V důsledku toho kompilátor nyní vydá upozornění a chyby nalezené ve výrazech, které předchozí verze kompilátoru neanalyzovaly.

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

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

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

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

    Příklad 1 (za)

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

    Když toto nové chování analyzuje decltype výraz, ve kterém chybí nezbytné použití typename klíčového slova k určení, že se jedná o typ závislého názvu, kompilátor vyvolá upozornění kompilátoru C4346 spolu s chybou kompilátoru C2923.

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

    Příklad 2: závislý název není typu (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>()));
      };
    
  • **volatile**členské proměnné zabraňují implicitně definovaným konstruktorům a operátorům přiřazení . Předchozí verze kompilátoru povolily třídu, která má volatile členské proměnné, aby měly výchozí konstruktory Copy/Move a výchozí operátory pro kopírování a přesun se automaticky vygenerovaly. Toto staré chování bylo nesprávné a nevyhovuje standardu C++. Kompilátor nyní považuje třídu, která má nestálé členské proměnné, aby měly operátory a přiřazení bez triviálního konstrukce, které brání automatickému generování výchozích implementací těchto operátorů. Když je taková třída členem sjednocení (nebo anonymního sjednocení uvnitř třídy), konstruktory Copy/Move a operátory přiřazení kopírování a přesunu (nebo třídy obsahující unonymous sjednocení) se implicitně definují jako odstraněné. Pokus o sestavení nebo zkopírování sjednocení (nebo třídy obsahující anonymní sjednocení) bez explicitního definování je chyba a kompilátor vyvolá chybu kompilátoru C2280, která je výsledkem.

      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 povoleny statických členských funkcí, které mají kvalifikátory cv. K tomuto chování dochází v důsledku regrese v Visual C++ 2015 a Visual C++ 2015 Update 1. Tímto způsobem Visual C++ 2013 a předchozí verze Visual C++ zamítnout kód. Chování Visual C++ 2015 a Visual C++ 2015 Update 1 je nesprávné a nevyhovuje standardu C++. Visual Studio 2015 Update 2 odmítne kód napsaný tímto způsobem a místo toho vydá chybu kompilátoru C2511.

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

    Příklad (před)

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

    Příklad (po)

      struct A
      {
        static void func();
      };
    
      void A::func() {}  // removed const
    
  • Dopředná deklarace výčtu není povolená v kódu WinRT (týká se /ZW jenom).

    kód kompilovaný pro prostředí Windows Runtime (WinRT) neumožňuje enum deklaraci typů, podobně jako při kompilaci spravovaného kódu C++ pro rozhraní .net Framework pomocí /clr přepínače kompilátoru. Díky tomuto chování je zajištěno, že velikost výčtu je vždy známá a lze jej správně promítnout do systému typů WinRT. Kompilátor odmítne kód napsaný tímto způsobem a vydá chybu kompilátoru C2599 spolu 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 nečlenu New a operátor delete se nedá deklarovat jako inline (úroveň 1 ( /W1 ) on-ve výchozím nastavení.)

    Předchozí verze kompilátoru nevydá upozornění, když je nečlenský operátor New a funkce Delete operátora jsou deklarovány jako inline. Kód napsaný tímto způsobem je nesprávně vytvořen (bez diagnostiky není vyžadován) a může způsobit problémy s pamětí způsobenými neodpovídajícími operátory New a Delete (zejména při použití společně s velikostí dealokace), které mohou být obtížné diagnostikovat. Kompilátor nyní vydává upozornění kompilátoru C4595, aby mohl 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 napsán tímto způsobem, může vyžadovat, aby definice operátora byly přesunuty ze souboru hlaviček a do odpovídajícího zdrojového souboru.

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

  • std:: is_convertable nyní detekuje vlastní přiřazení (standardní knihovna) předchozí verze typu. vlastnost std::is_convertable -Type nerozpoznala správně vlastní přiřazení typu třídy, pokud je jeho kopírovací konstruktor odstraněný nebo soukromý. Nyní std::is_convertable<>::value je správně nastaven na hodnotu false při použití pro typ třídy s odstraněným nebo soukromým kopírovacím konstruktorem.

    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 ve spodní části tohoto příkladu Pass, protože std::is_convertable<>::value byla nesprávně nastavena na true . Nyní std::is_convertable<>::value je správně nastaven na false , což způsobí selhání statických kontrolních výrazů.

  • Přednastavené nebo odstraněné konstruktory triviálního kopírování a přesunu respektují specifikátory přístupu.

    Předchozí verze kompilátoru nekontrolovaly specifikátor přístupu u výchozích nebo odstraněných konstruktorů triviální kopie a přemístění, než je povolí volání. Toto staré chování bylo nesprávné a nevyhovuje standardu C++. V některých případech toto staré chování vytvořilo riziko tichého chybného generování kódu, což vede k nepředvídatelnému chování za běhu. Kompilátor nyní kontroluje specifikátor přístupu u výchozích nebo odstraněných konstruktorů triviální kopie a přesunutí, aby bylo možné určit, zda je lze volat, a pokud ne, vystaví se v důsledku 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);
      }
    
  • Vyřazení podpory kódu ATL s atributy (úroveň 1 ( /W1 ) po výchozím nastavení)

    Předchozí verze kompilátoru podporovaly atribut ATL kódu. Jako další fáze odebrání podpory pro kód ATL s atributy, který začal v Visual C++ 2008, kód ATL atributu se již nepoužívá. Kompilátor nyní vydává upozornění kompilátoru C4467, aby mohl 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 není podpora odebrána od kompilátoru, můžete toto upozornění zakázat předáním /Wv:18 /wd4467 argumentů nebo příkazového řádku kompilátoru nebo přidáním #pragma warning(disable:4467) do zdrojového kódu.

    Příklad 1 (před)

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

    Příklad 1 (za)

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

    Někdy možná budete potřebovat nebo chcete vytvořit soubor IDL, abyste se vyhnuli použití 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; soubor. idl generovaný vc140. idl lze použít k získání * souboru IDL obsahujícího rozhraní a poznámky.

    Dále přidejte do sestavení krok MIDL, abyste se ujistili, že jsou vygenerová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 implementačním souboru, jako v následujícím příkladu kódu.

    Příklad 2 implementace (za)

      #include <idl.header.h>
      #include <atlbase.h>
    
      class ATL_NO_VTABLE CFooImpl :
          public ICustom,
          public ATL::CComObjectRootEx<CComMultiThreadModel>
      {
      public:
          BEGIN_COM_MAP(CFooImpl)
          COM_INTERFACE_ENTRY(ICustom)
          END_COM_MAP()
      };
    
  • Soubory předkompilovaných hlaviček (PCH) a neodpovídající direktivy #include (týká se pouze /Wall /WX )

    Předchozí verze kompilátoru přijaly neshodné #include direktivy ve zdrojových souborech mezi -Yc a -Yu kompilacemi při použití souborů PŘEDKOMPILOVANÉ hlavičky (PCH). Kód napsaný tímto způsobem již není kompilátorem přijat. Kompilátor nyní vydává upozornění kompilátoru CC4598, aby při použití souborů PCH mohla identifikovat neshodné #include direktivy.

      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 /Wall /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 pro adresář zahrnutí -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 neshodné argumenty 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 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í při nezadáte-li tuto možnost, 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 těchto funkcí C++14:

  • "Transparentní funktory operátorů"<>, větší<> a<>, 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> obdrželi velkou stabilizaci a opravy kódu.

Zásadní změny

Tato vylepšená podpora standardů ISO C/C++ může vyžadovat změny existují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 Podpora textury je vylepšená. Teď obsahuje podporu pro mipmapy a nové režimy 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 v mikro architektuře platformy ARM a Atomu
  • __vectorcall je přidána konvence volání. Argumenty typu vektoru předejte pomocí konvence volání __vectorcall 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í

Windows Podpora vývoje běhových 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 mohou být rovna nullptr hodnotě .

  • Bohatší informace o výjimce.

    C++/CX podporuje nový model chyb Windows, který umožňuje zachytávání a šíření bohatých informací o výjimce 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 další vylepšení v Visual Studio také můžou 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 Kategorie. 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. Teď můžete v XAML 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é alfa formát DDS.
  • Editor obrázků používá pro vykreslení interně předem vynásobený alfa a tím se vyhne artefaktům vykreslování, jako jsou tmavé halóly.
  • 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.

Filtrování seznamu členů založeného na kontextu. 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 CTRL + J 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: <atomic> , <chrono> , <condition_variable> , <filesystem> , <future> ,, a <mutex> <ratio> <thread> .
  • 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
    

Windows Podpora vývoje aplikace za běhu

  • 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. Windows Běhové 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. Šířka nabídky teď zahrnuje:

  • Bohatý programovací model založený na úlohách, který podporuje asynchronii a pokračování.
  • Paralelní algoritmy, které podporují paralelismu rozvětvení (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 STD datových struktur pro přístup z více vláken, například priority_queue, fronta, vektor a mapa.
  • 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 Podpora šablon K vytváření šablon projektů a položek jazyka C++ teď můžete Visual Studio šablony šablon projektů a položek.

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. Navíc pokud váš kód obsahuje 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ů. Při psaní kódu do editoru kódu se automaticky zobrazí rozevírací seznam Členové seznamu. Výsledky se filtrují tak, 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ý editor > C/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 Ctrl Shift š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ý editor > C/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ěné 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 ve vícevláknových programech C/C++ používáte správné obory uzamykání. 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.
  • Pomocí sad pravidel můžete určit pravidla jazyka C++, která chcete použít pro spuštění analýzy kódu.
  • 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 testování částí jazyka C++. Přidejte do stávajícího řešení C++ nový projekt testů jednotek tak, že šablonu C++ Unit Test Project v kategorii Visual C++ v dialogovém okně Nový Project testování. 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, který chcete, zvolte Spustit > > vybraný test. Po dokončení testovacího běhu můžete zobrazit výsledky testu 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 Architektura Generovat 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 pro soubor zdrojového kódu .cpp nebo soubor hlaviček .h možnost Vygenerovat Graph * * souborů k zahrnutí.

Průzkumník architektury

Pomocí Průzkumníka architektury můžete prozkoumat prostředky v řešení, projektech nebo souborech jazyka C++. V řádku nabídek zvolte Architecture > (Architektura) Windows > Architecture 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 bylo aktualizováno 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 vyhledat testy ve vašem řešení. Pokud chcete spustit testy jednotek a shromáždit pro ně data pokrytí kódu, v Průzkumníku testů 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 Test a > Windows > vý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. Pomocí výchozího významu klíčového slova deklarujte proměnnou, 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. Například kombinaci použijte k deklaraci funkce š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 žádný 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 jiných static_assert kontrolních mechanismů, které testují za běhu. Pokud se kontrolní výraz nezdařil, kompilace se nezdařila a je vydána zadaná chybová zpráva.

Klíčová slova nullptr a __nullptr. MSVC umožňuje použití nullptr klíčového slova s nativním kódem nebo se spravovaným kódem. nullptr Klíčové slovo označuje, že popisovač objektu, vnitřní ukazatel nebo nativní typ ukazatele neodkazuje na objekt. Kompilátor interpretuje nullptr jako spravovaný kód při použití /clr Možnosti kompilátoru a nativní kód, pokud nepoužijete /clr možnost. Klíčové slovo __nullptr specifické pro společnost Microsoft má stejný význam jako nullptr , ale platí pouze pro nativní kód. Pokud kompilujete nativní kód C/C++ pomocí /clr Možnosti kompilátoru, kompilátor nemůže určit, zda nullptr je klíčové slovo nativní nebo spravované období. Chcete-li záměr vyjasnit pro kompilátor, použijte klíčové slovo nullptr pro 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 pro trigraphs zakázaná. /Zc:trigraphs Pro povolení podpory trigraphs použijte možnost kompilátoru. Trigraph se skládá ze dvou po sobě jdoucích otazníků (??) následovaných jedinečným třetím znakem. Kompilátor nahradí trigraph odpovídajícím znakem interpunkce. Například kompilátor nahradí?? = trigraph se znakem # (čísla znaku). Použijte trigraphs ve zdrojových souborech jazyka C, které používají znakovou sadu, která neobsahuje určité znaky interpunkce.

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

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

Detect_mismatch nové direktivy pragma. Direktiva pragma detect_mismatch umožňuje do souborů vložit značku, která je porovnána s jinými značkami, které mají stejný název. Pokud je pro stejný název k dispozici více hodnot, linker vydá chybu.

Vnitřní objekty XOP, vnitřní objekty FMA4 a vnitřní objekty LWP. byly přidány nové vnitřní funkce pro podporu vnitřních objektů XOP přidaných pro Visual Studio 2010 SP1, vnitřních objektů FMA4 přidaných pro Visual Studio 2010 sp1 a LWP vnitřníchy přidaných pro technologie procesoru Visual Studio 2010 sp1. Pomocí __cpuid __cpuidex určit, které technologie procesoru jsou v konkrétním počítači podporovány.

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

MSBuild. Visual C++ řešení a projekty se teď vytvářejí 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žívají jiné jazyky Visual Studio a typy projektů. z důvodu této změny Visual Studio soubory projektu jazyka C++ nyní používají formát souboru XML a mají příponu názvu. vcxproj. Visual Studio soubory projektu C++ z dřívějších verzí Visual Studio jsou automaticky převedeny do nového formátu souboru.

Adresáře VC + +. Nastavení adresáře VC + + se teď nachází na dvou místech. Pomocí stránky vlastností projektu můžete nastavit hodnoty pro jednotlivé projekty pro adresáře VC + +. Použijte Správce vlastností a seznam vlastností k nastavení globálních hodnot podle konfigurace pro adresáře VC + +.

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

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

Knihovny jazyka Visual C++

Knihovny Concurrency Runtime. Rozhraní Concurrency Runtime Framework podporuje aplikace a komponenty, které běží souběžně, a je rozhraní pro programování souběžných aplikací v Visual C++. Aby bylo možné podporovat programování souběžných aplikací, knihovna paralelních vzorů (PPL) poskytuje obecné kontejnery a algoritmy pro provádění jemně odstupňovaného paralelismu. Knihovna asynchronních agentů poskytuje programovací model založený na objektech actor a rozhraní pro předávání zpráv pro hrubý úlohy toku dat a úloh.

Standardní knihovna C++. Následující seznam popisuje mnoho změn, které byly provedeny ve standardní knihovně C++.

  • Nová funkce jazyka C++ Reference rvalue byla použita k implementaci sémantiky přesunutí a dokonalého předávání pro mnoho funkcí v knihovně Standard Template Library. Přesunutí sémantik a dokonalého předávání významně vylepšit výkon operací, které přidělují nebo přiřazují proměnné nebo parametry.
  • Odkazy rvalue slouží také k implementaci nové unique_ptr třídy, což je bezpečnější typ inteligentního ukazatele než auto_ptr Třída. unique_ptrTřída je přesunutá, ale nedá se kopírovat, implementuje striktní sémantiku vlastnictví bez ovlivnění bezpečnosti a funguje dobře s kontejnery, které jsou na odkazech rvalue vědět. auto_ptrTřída je zastaralá.
  • Patnáct nových funkcí, například,, find_if_not copy_if a is_sorted , byly přidány do <algorithm> záhlaví.
  • V <memory> záhlaví je nová funkce make_shared pohodlný, robustní a efektivní způsob, jak vytvořit sdílený ukazatel na objekt v okamžiku konstrukce objektu.
  • V záhlaví jsou podporovány jednotlivě propojené seznamy <forward_list> .
  • Nové cbegin cend crbegin členské funkce,, a crend poskytují objekt const_iterator , který se přesune dopředu nebo dozadu prostřednictvím kontejneru.
  • <system_error>Záhlaví a související šablony podporují zpracování systémových chyb nízké úrovně. Členy exception_ptr třídy lze použít k přenosu výjimek mezi vlákny.
  • <codecvt>Hlavička podporuje převod různých kódování znaků Unicode na jiné kódování.
  • <allocators>Hlavička definuje několik šablon, které pomůžou přidělit a uvolnit bloky paměti pro kontejnery založené na uzlech.
  • Hlavička obsahuje mnoho aktualizací <random> .

Knihovna Microsoft Foundation Class (MFC)

funkce Windows 7. knihovna MFC podporuje mnoho funkcí Windows 7, například uživatelské rozhraní (UI) pásu karet, hlavní panel, seznamy odkazů, miniatury s kartami, náhledy miniatur, indikátor průběhu, překryvná ikona a indexování vyhledávání. vzhledem k tomu, že knihovna MFC automaticky podporuje mnoho funkcí Windows 7, možná nebudete muset upravovat existující aplikaci. Pro podporu dalších funkcí v nových aplikacích použijte Průvodce aplikací knihovny MFC k určení funkce, které chcete použít.

Povědomí s více dotykovými. MFC podporuje aplikace s uživatelským rozhraním s více dotykovými aplikacemi, například aplikace, které jsou napsané pro operační systém Microsoft Surface. aplikace s více dotykovými aplikacemi může zpracovávat zprávy Windows touch a gesta, což jsou kombinace dotykové zprávy. Stačí zaregistrovat aplikaci pro události dotykové ovládání a gesta a operační systém bude směrovat události s více dotykovémi událostmi do obslužných rutin událostí.

Povědomí o vysokém rozlišení DPI. Ve výchozím nastavení jsou aplikace MFC nyní podporující vysoké rozlišení DPI. Pokud je aplikace s vysokým ROZLIŠENÍm (s vysokými body na palec), může operační systém škálovat Windows, text a jiné prvky uživatelského rozhraní na aktuální rozlišení obrazovky. To znamená, že obrázek s měřítkem je pravděpodobně správně rozložen a není oříznut nebo pixelated.

Správce restartování. Správce restartování automaticky uloží dokumenty a restartuje aplikaci, pokud se neočekávaně zavře nebo restartuje. Můžete například použít správce restartování k zahájení aplikace po jejím uzavření automatickou aktualizací. Další informace o tom, jak nakonfigurovat aplikaci tak, aby používala správce restartování, najdete v tématu Postup: Přidání podpory správce restartování.

Objektu CTaskDialog. CTaskDialogTřídu lze použít místo standardního AfxMessageBox okna se zprávou. CTaskDialogTřída zobrazuje a shromažďuje více informací, než je standardní okno se zprávou.

SafeInt – knihovna

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

Nová makra knihovny ATL (Active Template Library)

Do knihovny 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žní přidat seznam platných identifikátorů CLSID. PROP_ENTRY_INTERFACE_CALLBACK a PROP_ENTRY_INTERFACE_CALLBACK_EX umožňují zadat funkci zpětného volání k určení, zda je identifikátor CLSID platný.

Upozornění/Analyze

/analyze z knihoven C Run-Time (CRT), MFC a ATL se odebrala většina (Enterprise Code Analysis) upozornění.

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 Vložit aktivní ovládací prvek . 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ď vyhovují pravidlům stylu Windows Vista. když vytvoříte nový projekt pomocí Visual Studio 2008, všechna dialogová okna, která vložíte do vaší aplikace, budou vyhovovat zásadá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ých oken.

  • 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 Systém 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_si128 a __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 Double dvojitý (C++) .
  • /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_depth .
  • 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 tiše ignorována; použijte noalias restrict__declspec modifikátory nebo pro určení způsobu, jakým kompilátor dělá aliasing.
  • /Op možnost kompilátoru byla odebrána. /fpMísto toho použijte (určete Floating-Point chování).
  • Direktiva OpenMP je nyní podporována nástrojem Visual C++.
  • /openmp (Povolení podpory OpenMP 2,0) byla přidána možnost kompilátoru.
  • /Ow možnost kompilátoru se odebrala, ale bezobslužně se ignoruje. Použijte noalias restrict__declspec modifikátory nebo pro určení způsobu, jakým kompilátor dělá aliasing.

Optimalizace na základě profilu

  • /QI0f bylo odebráno.
  • /QIfdiv bylo odebráno.
  • /QIPF_B (Seznam chyb for B CPU Stepping) byla přidána možnost kompilátoru.
  • /QIPF_C (Seznam chyb for C CPU Stepping) byla přidána možnost kompilátoru.
  • /QIPF_fr32 (Nepoužívejte horní 96 Registry plovoucí desetinné čárky) byla přidána možnost kompilátoru.
  • /QIPF_noPIC (Generování kódu závislého na pozici) byla přidána možnost kompilátoru.
  • /QIPF_restrict_plabels (Za běhu nedošlo k vytvoření funkcí). byla přidána možnost kompilátoru.

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

  • /vd (Zakázat posunutí konstrukcí) teď umožňuje použít operátor dynamic_cast u objektu, který je vytvořený (/VD2).
  • /YX možnost kompilátoru byla odebrána. Použijte /Yc (Vytvořit předkompilovaný hlavičkový soubor) nebo /Yu (použijte soubor předkompilované hlavičky) místo toho. Pokud odeberete /YX z konfigurací sestavení a nahradíte je bez Nothing, může to vést k rychlejším sestavením.
  • /Zc:forScope je teď ve výchozím nastavení zapnuté.
  • /Zc:wchar_t je teď ve výchozím nastavení zapnuté.
  • /Zd možnost kompilátoru byla odebrána. Informace o ladění se už nepodporují jenom na číslo řádku. /ZiMísto toho použijte (viz /Z7,/ZI,/Zi (formát ladicích informací) , kde najdete další informace.
  • /Zg je nyní platný pouze v souborech zdrojového kódu jazyka C, nikoli v souborech zdrojového kódu jazyka C++.
  • /Zx (Ladění optimalizovaného kódu Itanium) byla přidána možnost kompilátoru.

Nové funkce jazyka

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

Nové funkce preprocesoru

  • Bylo přidáno předdefinované makro __CLR_VER.
  • Direktiva pragma (C/C++) pragma se teď přijímá /MANIFESTDEPENDENCY jako komentář linkeru. Možnost exestr pro komentář je nyní zastaralá.
  • embedded_idl atribut ( #import direktiva) nyní používá volitelný parametr.
  • fenv_access pragma
  • float_control pragma
  • fp_contract pragma
  • Globální proměnné nebudou inicializovány v pořadí, ve kterém jsou deklarovány, pokud máte globální proměnné v direktivách pragma managed, unmanaged a unmanaged. Jedná se o potenciální zásadní změnu, pokud je například inicializována nespravované globální proměnné se spravovanými globálními proměnnými a vyžaduje se plně vytvořený spravovaný objekt.
  • Oddíly zadané pomocí init_seg jsou nyní jen pro čtení a nikoli pro čtení a zápis jako v předchozích verzích.
  • inline_depth výchozí hodnota je nyní 16. V Visual C++ .NET 2003 platí také výchozí hodnota 16.
  • Bylo přidáno _INTEGRAL_MAX_BITS předdefinované makro, viz Předdefinovaná makra.
  • Přidaná makra _M_CEE, _M_CEE_PURE a _M_CEE_SAFE předdefinovaná, viz Předdefinovaná makra.
  • Bylo přidáno předdefinované makro _M_IX86_FP.
  • Bylo přidáno předdefinované makro _M_X64.
  • make_public pragma
  • managed, unmanaged syntaxe direktivy pragma se aktualizovala (teď má push a pop ).
  • Na mscorlib.dll se teď implicitně odkazuje #using direktiva ve všech /clr kompilacích.
  • Bylo přidáno předdefinované makro _OPENMP.
  • Direktiva pragma optimize se aktualizovala, a a w už neplatné parametry.
  • byl přidán no_registry # import Attribute.
  • region, endregion přidány direktivy pragma
  • Bylo přidáno předdefinované makro _VC_NODEFAULTLIB.
  • Makra variadické jsou nyní implementována.
  • vtordisp je zastaralá a v budoucí verzi Visual C++ bude odebrána.
  • warningDirektiva pragma nyní obsahuje specifikátor potlačení.

Nové funkce linkeru

  • Moduly (výstupní soubory MSIL bez sestavení) jsou teď povolené jako vstup linkeru.
  • /ALLOWISOLATION (Vyhledávání v manifestu) byla přidána možnost linkeru.
  • /ASSEMBLYRESOURCE (Vložení spravovaného prostředku) bylo aktualizováno na nyní, aby bylo možné zadat název prostředku v sestavení a určit, zda je prostředek v sestavení privátní.
  • /CLRIMAGETYPE (Zadejte typ image CLR) možnost linkeru se přidala.
  • /CLRSUPPORTLASTERROR (Zachovat kód poslední chyby pro volání PInvoke) možnost linkeru byla přidána.
  • /CLRTHREADATTRIBUTE (Nastavení atributu vlákna modulu CLR) byla přidána možnost linkeru.
  • /CLRUNMANAGEDCODECHECK (Přidání SuppressUnmanagedCodeSecurityAttribute) možnost linkeru se přidala.
  • /ERRORREPORT (Nahlásit interní chyby linkeru) možnost linkeru se přidala.
  • /EXETYPE možnost linkeru byla odebrána. linker již nepodporuje vytváření Windows 95 a ovladačů zařízení Windows 98. K vytvoření těchto ovladačů zařízení použijte odpovídající sadu DDK. Klíčové slovo EXETYPE již není platné pro soubory definice modulu.
  • /FUNCTIONPADMIN (Vytvoření image opravitelnou za provozu) – přidala se možnost linkeru.
  • /LTCG možnost linkeru je nyní podporována v modulech kompilovaných pomocí /clr . /LTCG aktualizovala se také podpora optimalizace na základě profilu.
  • /MANIFEST (Vytvoření manifestu souběžného sestavení) byla přidána možnost linkeru.
  • /MANIFESTDEPENDENCY (Určete závislosti manifestu) možnost linkeru byla přidána.
  • /MANIFESTFILE (Název souboru manifestu) byla přidána možnost linkeru.
  • /MAPINFO:LINES možnost linkeru byla odebrána.
  • /NXCOMPAT (Kompatibilní s zabráněním spuštění dat) byla přidána možnost linkeru.
  • /PGD (Určení databáze pro optimalizace Profile-Guided) možnost linkeru se přidala.
  • /PROFILE (Profiler nástrojů pro sledování výkonu) – byla přidána možnost linkeru.
  • /SECTION (Určete atributy oddílu) možnost linkeru teď podporuje negaci atributu a už nepodporuje atributy L a D (související s ovladačem VxD).
  • Podpora kódování Unicode v kompilátoru a linkeru
  • /VERBOSE (Tisk zpráv o průběhu): možnost linkeru teď taky přijímá bránu ICF a REF.
  • /VXD možnost linkeru byla odebrána. linker již nepodporuje vytváření Windows 95 a ovladačů zařízení Windows 98. K vytvoření těchto ovladačů zařízení použijte odpovídající sadu DDK. Klíčové slovo VXD již není platné pro soubory definice modulu.
  • /WS možnost linkeru byla odebrána. /WSbyl použit pro úpravu imagí cílených na systém Windows NT 4,0. Místo je možné použít název souboru IMAGECFG.exe R /WS . IMAGECFG.exe najdete na disku CD-rom systém Windows NT 4,0 v SUPPORT\DEBUG\I386\IMAGECFG.EXE.
  • /WX (Zpracovávání upozornění linkeru jako chyb) je teď dokumentována možnost linkeru.

Nové funkce nástroje linker

  • /ALLOWISOLATION byla přidána možnost nástroje Editbin.
  • Je odebraný příkaz definičního souboru modulu popisu. Linker již 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 nástroje Editbin.
  • /RANGE byla přidána možnost DUMPBIN.
  • /TLS byla přidána možnost DUMPBIN.
  • /WS možnost nástroje EDITBIN byla odebrána. /WSbyl použit pro úpravu imagí cílených na systém Windows NT 4,0. Místo je možné použít název souboru IMAGECFG.exe R /WS . 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/WX [: NO] lib.

Nové funkce nástroje NMAKE

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

Nové funkce MASM

  • Výrazy MASM jsou teď 64 hodnoty bitů. V předchozích verzích MASM výrazy byly 32 hodnoty.
  • Instrukce __asm int 3 nyní způsobí, že se funkce zkompiluje do nativního režimu.
  • ALIAS (MASM) je nyní zdokumentován.
  • /ERRORREPORT Je přidána možnost ml.exe a ml64.exe.
  • . ! Je nyní dokumentován.
  • H2INC.exe nebude dodán v Visual C++ 2005. Pokud potřebujete i nadále používat H2INC, použijte H2INC.exe z předchozí verze Visual C++.
  • byl přidán operátor IMAGEREL.
  • byl přidán operátor HIGH32 –.
  • byl přidán operátor LOW32 –.
  • ml64.exe je verze MASM pro architekturu x64. Sestaví soubory x64. asm do souborů objektů x64. Jazyk vloženého sestavení není podporován v kompilátoru x64. Pro ml64.exe (x64) se přidaly tyto direktivy MASM:
  • .ALLOCSTACK
  • .ENDPROLOG
  • .PUSHFRAME
  • .PUSHREG
  • .SAVEREG
  • .SAVEXMM128
  • . Direktiva PROC se navíc aktualizovala syntaxí jenom pro 64bitovou verzi (SETFRAME).
  • Přidala se direktiva MMWORD.
  • /omf (Možnost 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 –.
  • Přidala se direktiva XMMWORD.

Nové funkce CRT

  • Byly přidány zabezpečené verze několika funkcí. Tyto funkce zpracovávají chyby lepším způsobem a vysazují přísnější ovládací prvky pro vyrovnávací paměti, aby se předešlo běžným chybám zabezpečení. Nové zabezpečené verze jsou identifikovány příponou _s .
  • Existující méně zabezpečené verze mnoha funkcí jsou zastaralé. Pokud chcete zakázat upozornění na vyřazení, definujte _CRT_SECURE_NO_WARNINGS.
  • Mnoho existujících funkcí nyní ověřuje jejich parametry a vyvolá obslužnou rutinu neplatného parametru, pokud je předán neplatný parametr.
  • Mnoho existujících funkcí je nyní nastaveno na errno místo, kde předtím.
  • errno_tByl přidán typ typedef s typem Integer. errno_t se používá vždy, když se návratový typ funkce nebo parametr zabývá kódy chyb z errno . errno_t nahrazuje errcode .
  • Funkce závislé na národním prostředí teď mají verze, které místo použití aktuálního národního prostředí přebírají národní prostředí jako parametr. Tyto nové funkce mají příponu _l . Bylo přidáno několik nových funkcí pro práci s objekty národního prostředí. Nové funkce zahrnují _get_current_locale _create_locale a _free_locale .
  • Přidaly se nové funkce, které podporují uzamykání a odemykání popisovačů souborů.
  • _spawnRodina funkcí neresetuje errno na hodnotu nula, stejně jako v předchozích verzích.
  • Verze printf rodiny funkcí, které umožňují určit pořadí, ve kterém jsou argumenty použity, jsou k dispozici.
  • Unicode je teď podporovaný formát textu. Funkce _open podporuje atributy _O_TEXTW, _O_UTF8 a _O_UTF16. fopenFunkce podporuje metodu "CCS = Encoding", která určuje formát Unicode.
  • K dispozici je nová verze knihoven CRT sestavených ve spravovaném kódu (MSIL), která se používá při kompilování s /clr možností (modul CLR (Common Language Runtime Compilation)).
  • _fileinfo byla odebrána.
  • Výchozí velikost pro time_t je nyní 64 bitů, čímž se rozšíří rozsah time_t a několik časových funkcí na rok 3000.
  • CRT teď podporuje nastavení národního prostředí na základě jednotlivých vláken. Funkce _configthreadlocale byla přidána pro podporu této funkce.
  • _statusfp2 __control87_2 Byly přidány funkce a, které umožňují přístup k ovládacímu slovu s plovoucí desetinnou čárkou a jejich řízení v procesoru s plovoucí desetinnou čárkou X87 i SSE2.
  • _mkgmtime _mkgmtime64 Přidaly se funkce a, které poskytují podporu pro převod časů (struct tm) na Greenwichský střední čas (GMT).
  • Byly provedeny změny swprintf v a, vswprintf aby lépe vyhovovaly standardu.
  • Nový hlavičkový soubor INTRIN. H, poskytuje prototypy pro některé vnitřní funkce.
  • fopenFunkce teď má atribut N.
  • _openFunkce teď má atribut _O_NOINHERIT.
  • atoiFunkce nyní vrací INT_MAX a NASTAVUJE errno ERANGE při přetečení. V předchozích verzích bylo nedefinované chování přetečení.
  • printfRodina funkcí podporuje výstup v šestnáctkové soustavě s plovoucí desetinnou čárkou, který je implementován podle standardu ANSI C99 pomocí specifikátoru typu formátu% a a% a.
  • printfRodina teď podporuje předponu "LL" (dlouhý dlouhý) velikost.
  • _controlfpFunkce byla optimalizována pro lepší výkon.
  • Byly přidány ladicí verze některých funkcí.
  • Přidány _chgsignl a _cpysignl (dlouhé dvojitých verzí).
  • _locale_tDo tabulky typů byl přidán typ.
  • Bylo _countof přidáno nové makro makra pro výpočet počtu prvků v poli.
  • v každém tématu funkce byla přidána část .NET Framework ekvivalenty.
  • Několik řetězcových funkcí nyní má možnost zkrátit řetězce, nikoli neúspěšné, pokud výstupní vyrovnávací paměť je příliš malá. viz _TRUNCATE.
  • _set_se_translator nyní vyžaduje použití /EHa Možnosti kompilátoru.
  • fpos_t je nyní __int64 pod /Za (pro kód jazyka C) a pokud je STDC nastavena ručně (pro kód jazyka C++). Používá se k struct .
  • _CRT_DISABLE_PERFCRIT_LOCKS může vylepšit výkon vstupně-výstupních programů v jednom vlákně.
  • Názvy POSIX se nepoužívají jako nepoužívané názvy vyhovující normám ISO C++ (například _getch místo getch ).
  • Nové možnosti propojení soubory. obj jsou k dispozici pro režim Pure.
  • _recalloc kombinuje funkce realloc a calloc .

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

Compiler

  • Informace o tom, jak Spravovaná rozšíření jazyka C++ aplikace sestavené 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 bool (a ne jako identifikátor) v souboru zdrojového kódu jazyka C++.
  • Typ je nyní k dispozici jako poznámka, že v long long typedef __int64 long long CRT ještě není dostupná podpora pro .
  • 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 byl 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++