Visual C++ — co nowego od roku 2003 do 2015

Ta strona zbiera wszystkie strony "Co nowego" dla wszystkich wersji Visual C++ od Visual Studio 2015 do 2003. Te informacje są udostępniane jako udogodnienie w przypadku, gdy mogą być przydatne podczas uaktualniania ze starszych wersji Visual Studio.

Uwaga

Aby uzyskać informacje o bieżącej wersji programu Visual Studio, zobacz Co nowego w programie Visual C++ w programie Visual Studio i ulepszenia zgodności w programie Visual C++ w Visual Studio.

Co nowego w języku C++ w Visual Studio 2015 r.

W Visual Studio 2015 r. i nowszych ciągłe ulepszenia zgodności kompilatora mogą czasami zmienić sposób, w jaki kompilator rozumie istniejący kod źródłowy. W takim przypadku podczas kompilacji mogą wystąpić nowe lub różne błędy, a nawet różnice w zachowaniu kodu, który wcześniej skompilował i wydawał się działać poprawnie.

Na szczęście te różnice mają niewielki lub żaden wpływ na większość kodu źródłowego, a gdy kod źródłowy lub inne zmiany są potrzebne do rozwiązania tych różnic, poprawki są zwykle niewielkie i proste. Uwzględniono wiele przykładów akceptowalnego wcześniej kodu źródłowego, które mogą wymagać zmiany (przed ) oraz poprawek w celu ich (po).

Chociaż te różnice mogą mieć wpływ na kod źródłowy lub inne artefakty kompilacji, nie wpływają one na zgodność binarną między aktualizacjami Visual C++ kompilacji. Poważniejsze zmiany mogą mieć wpływ na zgodność binarną, ale tego rodzaju przerwy w zgodności binarnej występują tylko między głównymi wersjami Visual C++. Na przykład między 2013 Visual C++ 2013 Visual C++ 2015 r. Aby uzyskać informacje o przełomowych zmianach, które wystąpiły między Visual C++ 2013 Visual C++ 2015 r., zobacz Visual C++ historia zmian 2003–2015.

Ulepszenia zgodności w Visual Studio 2015 r.

  • /Zc:forScope-, opcja

    Opcja kompilatora /Zc:forScope- jest przestarzała i zostanie usunięta w przyszłej wersji.

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

    Opcja była zwykle używana w celu umożliwienia niestandardowego kodu, który używa zmiennych pętli po punkcie, w którym zgodnie ze standardem powinny one wyjść poza zakres. Było to konieczne tylko podczas /Za kompilowania z opcją , /Zaponieważ bez funkcji użycie zmiennej pętli for po zakończeniu pętli jest zawsze dozwolone. Jeśli nie zależy Ci na zgodności ze standardami (na przykład jeśli kod nie jest przeznaczony do przenośnego do innych kompilatorów), /Za możesz wyłączyć tę opcję (lub ustawić właściwość Wyłącz rozszerzenia języka na Nie). Jeśli zależy Ci na pisaniu przenośnego kodu zgodnego ze standardami, musisz ponownie napisać kod tak, aby był zgodny ze standardem, przenosząc deklarację takich zmiennych do punktu poza pętlą.

      // 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
      }
    
  • Opcja kompilatora Zg.

    Opcja /Zg kompilatora (Generuj prototypy funkcji) nie jest już dostępna. Ta opcja kompilatora była wcześniej przestarzała.

  • Nie można już uruchamiać testów jednostkowych w języku C++/interfejsie wiersza polecenia z wiersza polecenia przy użyciu mstest.exe. Zamiast tego użyj vstest.console.exe

  • modyfikowalne słowo kluczowe.

    Specyfikator mutable klasy magazynu nie jest już dozwolony w miejscach, w których wcześniej został skompilowany bez błędu. Teraz kompilator zwraca błąd C2071 (niedozwolona klasa magazynu). Zgodnie ze standardem modyfikator modyfikowalny może być stosowany tylko do nazw składowych danych klasy i nie może być stosowany do nazw zadeklarowanych jako const lub statycznych i nie może być stosowany do składowych odwołania.

    Rozważmy na przykład następujący kod:

      struct S {
          mutable int &r;
      };
    

    Poprzednie wersje kompilatora języka Microsoft C++ zaakceptowały to, ale teraz kompilator zwraca następujący błąd:

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

    Aby naprawić błąd, po prostu usuń nadmiarowe słowo mutable kluczowe.

  • char_16_t i char32_t

    W pliku char16_tchar32_t typedef nie można już używać aliasów ani jako aliasów, ponieważ te typy są teraz traktowane jako wbudowane. Użytkownicy i autorzy bibliotek często char16_tchar32_t definiowały i jako aliasy uint16_t odpowiednio uint32_ti .

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

    Aby zaktualizować kod, usuń deklaracje typedef i zmień nazwy innych identyfikatorów, które kolidują z tymi nazwami.

  • Parametry szablonu inne niż typ

    Określony kod, który obejmuje parametry szablonu inne niż typ, jest teraz poprawnie sprawdzany pod kątem zgodności typów poaniu jawnych argumentów szablonu. Na przykład poniższy kod skompilowany bez błędu w poprzednich wersjach 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>();
      }
    

    Bieżący kompilator prawidłowo zwraca błąd, ponieważ typ parametru szablonu nie pasuje do argumentu szablonu (parametr jest wskaźnikiem do const, ale funkcja f jest niekonstytucyjna):

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

    Aby rozwiązać ten problem w kodzie, upewnij się, że typ argumentu szablonu, który jest wyświetlany, jest taki, jak zadeklarowany typ parametru szablonu.

  • __declspec(align)

    Kompilator nie akceptuje już funkcji __declspec(align) . Ta wartość była zawsze ignorowana, ale teraz powoduje błąd kompilatora.

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

    Aby rozwiązać ten problem, usuń z __declspec(align) deklaracji funkcji. Ponieważ nie miało to żadnego efektu, usunięcie go nie zmienia niczego.

  • Obsługa wyjątków

    Istnieje kilka zmian obsługi wyjątków. Najpierw obiekty wyjątków muszą być kopiowalne lub wymienne. Poniższy kod skompilowany w Visual Studio 2013, ale nie jest kompilowany Visual Studio 2015:

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

    Problem polega na tym, że konstruktor kopiowania jest prywatny, więc nie można skopiować obiektu, tak jak to się dzieje w normalnym przebiegu obsługi wyjątku. To samo dotyczy, gdy konstruktor kopiowania jest zadeklarowany explicit.

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

    Aby zaktualizować kod, upewnij się, że konstruktor kopiowania dla obiektu wyjątku jest publiczny i nie jest oznaczony jako explicit.

    Przechwytowanie wyjątku według wartości również wymaga, aby obiekt wyjątku był kopiowalny. Poniższy kod skompilowany w Visual Studio 2013, ale nie jest kompilowany Visual Studio 2015:

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

    Ten problem można rozwiązać, zmieniając typ parametru dla odwołania catch .

      catch(D& d)
      {
      }
    
  • Literały ciągu, po których następuje makra

    Kompilator obsługuje teraz literały zdefiniowane przez użytkownika. W związku z tym literały ciągu, po których następuje makra bez żadnych interweniowanych białych znaków, są interpretowane jako literały zdefiniowane przez użytkownika, co może dawać błędy lub nieoczekiwane wyniki. Na przykład w poprzednich kompilatorach następujący kod został skompilowany pomyślnie:

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

    Kompilator zinterpretował to jako literał ciągu "hello", po którym następuje makro, które jest rozwinięte "tam", a następnie dwa literały ciągu zostały zwięzłe w jeden. W Visual Studio 2015 r. kompilator interpretuje to jako literał zdefiniowany przez użytkownika, ale ponieważ nie ma pasującego zdefiniowanego przez użytkownika literału _x, powoduje to błąd.

      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?
    
    

    Aby rozwiązać ten problem, dodaj spację między literału ciągu a makro.

  • Sąsiadujące literały ciągu

    Podobnie jak w poprzedniej, ze względu na powiązane zmiany w analizie ciągów, sąsiadujące literały ciągu (szerokie lub wąskie literały ciągu znaków) bez żadnych odstępów zostały zinterpretowane jako pojedynczy ciąg zespołowy w poprzednich wersjach języka Visual C++. W Visual Studio 2015 r. należy teraz dodać odstęp między dwoma ciągami. Na przykład należy zmienić następujący kod:

      char * str = "abc""def";
    

    Wystarczy dodać spację między dwoma ciągami.

      char * str = "abc" "def";
    
  • Umieszczanie nowych i usuwanie

    W celu zapewnienia zgodności delete z normą C++14 w operatorze w wariancie dokonano zmiany. Szczegółowe informacje o zmianie standardów można znaleźć na stronie Co najmniej jeden przydział dla języka C++. Zmiany dodają postać operatora globalnego delete , który przyjmuje parametr rozmiaru. Zmiana przerywana jest taka, że jeśli wcześniej był używany operator delete z tym samym podpisem (co odpowiada nowemu operatorowi umieszczania), otrzymasz błąd kompilatora (C2956, który występuje w momencie, gdy jest używane nowe umieszczanie, ponieważ jest to pozycja w kodzie, delete w którym kompilator próbuje zidentyfikować odpowiedni operator dopasowania).

    Funkcja była void operator delete(void *, size_t) operatorem usuwania umieszczania odpowiadającym funkcji placement new w void * operator new(size_t, size_t) języku C++11. W przypadku coklokacji o rozmiarze C++14 ta delete funkcja jest teraz zwykłą funkcją deallocation (operator globalny delete ). Standard wymaga, aby delete jeśli użycie nowej funkcji umieszczania wyszukuje odpowiednią funkcję i znajdzie zwykłą funkcję cofania alokacji, program jest źle formowany.

    Załóżmy na przykład, że kod definiuje zarówno nowe umieszczanie , jak i usuwanie umieszczania:

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

    Problem występuje z powodu dopasowania podpisów funkcji między zdefiniowanym operatorem usuwania umieszczania i nowym operatorem o globalnym rozmiarze delete . Zastanów się, czy możesz użyć innego typu niż do size_t umieszczania nowych operatorów i delete . Należy pamiętać, że typ obiektu jest size_ttypedef zależny od kompilatora; jest to typedef typ dla unsigned int w Visual C++. Dobrym rozwiązaniem jest użycie typu wyliczeniowego, takiego jak ten:

      enum class my_type : size_t {};
    

    Następnie zmień definicję umieszczania i newdelete użyj tego typu jako drugiego argumentu zamiast size_t. Należy również zaktualizować wywołania funkcji umieszczania nowe, aby przekazać nowy typ (static_cast<my_type>na przykład przy użyciu funkcji do konwersji z wartości całkowitej) newdelete i zaktualizować definicję i w celu rzutowania z powrotem na typ liczby całkowitej. W tym celu nie trzeba używać klasy . enum Typ klasy z elementem size_t członkowskim również będzie działać.

    Alternatywnym rozwiązaniem jest to, że możesz całkowicie wyeliminować nowe umieszczanie . Jeśli kod używa funkcji umieszczania new do implementowania puli pamięci, w której argumentem umieszczania jest rozmiar przydzielanego lub usuwanego obiektu, funkcja coklokacji o rozmiarze może być odpowiednia do zastąpienia własnego kodu niestandardowej puli pamięci i można pozbyć się funkcji umieszczania i po prostu użyć własnego operatora dwóch argumentów delete zamiast funkcji umieszczania.

    Jeśli nie chcesz natychmiast aktualizować kodu, możesz przywrócić stare zachowanie przy użyciu opcji kompilatora /Zc:sizedDealloc-. Jeśli używasz tej opcji, funkcje z dwoma argumentami delete nie istnieją i nie będą powodować konfliktu z operatorem usuwania umieszczania .

  • Składowe danych unii

    Składowe danych unii nie mogą już mieć typów referencyjnych. Poniższy kod został skompilowany pomyślnie w Visual Studio 2013, ale generuje błąd w Visual Studio 2015.

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

    Powyższy kod generuje następujące błędy:

      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
    

    Aby rozwiązać ten problem, zmień typy referencyjne na wskaźnik lub wartość. Zmiana typu na wskaźnik wymaga zmian w kodzie, który używa pola unii. Zmiana kodu na wartość zmieniłaby dane przechowywane w unii, co wpływa na inne pola, ponieważ pola w typach unii współdzielą tę samą pamięć. W zależności od rozmiaru wartości może również zmienić rozmiar unii.

  • Anonimowe unii

    Są teraz bardziej zgodne ze standardem. Poprzednie wersje kompilatora wygenerowały jawny konstruktor i destruktor dla anonimowych unii. Zostały one usunięte w Visual Studio 2015 r.

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

    Poprzedni kod generuje następujący błąd w Visual Studio 2015 r.:

      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
    

    Aby rozwiązać ten problem, podaj własne definicje konstruktora i/lub destruktora.

      struct S {
         // Provide a default constructor by adding an empty function body.
         S() {}
      };
    
      union {
         struct {
            S s;
         };
      } u;
    
  • Unii z anonimowymi strukturami

    Aby zapewnić zgodność ze standardem, zachowanie środowiska uruchomieniowego zostało zmienione dla elementów członkowskich struktur anonimowych w unii. Konstruktor anonimowych elementów członkowskich struktury w unii nie jest już niejawnie wywoływany podczas tworzenia takiej unii. Ponadto destruktor anonimowych elementów członkowskich struktury w unii nie jest już niejawnie wywoływany, gdy unii wykracza poza zakres. Rozważmy następujący kod, w którym unii U zawiera anonimową strukturę, która zawiera element członkowski, który jest nazwaną strukturą S, która ma destruktor.

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

    W Visual Studio 2013 konstruktor dla funkcji S jest wywoływany podczas tworzenia unii, a destruktor dla S jest wywoływany, gdy stos funkcji f jest czyszczony. Jednak w Visual Studio 2015 konstruktor i destruktor nie są wywoływane. Kompilator generuje ostrzeżenie o tej zmianie zachowania.

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

    Aby przywrócić oryginalne zachowanie, nadaj strukturze anonimowej nazwę. Zachowanie w czasie wykonywania struktur nie anonimowych jest takie samo, niezależnie od wersji kompilatora.

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

    Możesz też spróbować przerzucić kod konstruktora i destruktora do nowych funkcji i dodać wywołania do tych funkcji z konstruktora i destruktora dla unii.

      #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;
      }
    
  • Rozwiązanie szablonu

    W szablonach wnoszono zmiany dotyczące rozpoznawania nazw. W języku C++, rozważając kandydatów do rozpoznawania nazwy, może być tak, że co najmniej jedna rozważana nazwa, ponieważ potencjalne dopasowania powoduje nieprawidłowe wystąpienia szablonu. Te nieprawidłowe wystąpienia zwykle nie powodują błędów kompilatora— jest to zasada znana jako SFINAE (Błąd podstawienia nie jest błędem).

    Teraz, jeśli SFINAE wymaga od kompilatora wystąpienia specjalizacji szablonu klasy, wszystkie błędy występujące podczas tego procesu są błędami kompilatora. W poprzednich wersjach kompilator ignorowałby takie błędy. Rozważmy na przykład następujący kod:

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

    W przypadku kompilacji przy użyciu bieżącego kompilatora występuje następujący błąd:

      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
              ]
    

    Wynika to z tego, że w punkcie pierwszego wywołania klasy is_base_of klasa "D" nie została jeszcze zdefiniowana.

    W takim przypadku poprawka nie ma używać takich cech typu, dopóki klasa nie zostanie zdefiniowana. Jeśli przeniesiesz definicje B i D na początek pliku kodu, błąd zostanie rozwiązany. Jeśli definicje znajdują się w plikach nagłówkowych, sprawdź kolejność instrukcji include dla plików nagłówkowych, aby upewnić się, że definicje klas są kompilowane przed rozpoczęciem pracy z problematycznymi szablonami.

  • Konstruktory kopiowania

    Zarówno w programie Visual Studio 2013, jak i Visual Studio 2015, kompilator generuje konstruktor kopiowania dla klasy, jeśli ta klasa ma zdefiniowany przez użytkownika konstruktor przenoszenia, ale nie ma konstruktora kopiowania zdefiniowanego przez użytkownika. W Dev14 ten niejawnie wygenerowany konstruktor kopii jest również oznaczony jako "= delete".

Ulepszenia zgodności w wersji Visual Studio 2015 Update 1

  • Prywatne wirtualne klasy bazowe i dziedziczenie pośrednie

    Poprzednie wersje kompilatora umożliwiły klasie pochodnej wywołanie funkcji członkowskich jej pośrednio pochodnychprivate virtual klas bazowych. To stare zachowanie było nieprawidłowe i nie jest zgodne ze standardem C++. Kompilator nie akceptuje już kodu napisanego w ten sposób i w związku z tym generuje błąd kompilatora C2280.

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

    Przykład (przed)

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

    Przykład (po)

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

    -lub-

      class base;  // as above
    
      class middle: private virtual base {};
      class top: public virtual middle, private virtual bottom {};
    
      void destroy(top *p)
      {
          delete p;
      }
    
  • Przeciążony operator new i operator delete

    Poprzednie wersje kompilatora zezwoliły na zadeklarowanie statycznego operatora bez elementu członkowskiego i usunięcie operatora bez elementu członkowskiego oraz zadeklarowanie go w przestrzeniach nazw innych niż globalna przestrzeń nazw. To stare zachowanie stworzyło ryzyko, że program new nie wywoła implementacji operatora lub delete zamierzonej przez programistę, co spowoduje dyskretne złe zachowanie środowiska uruchomieniowego. Kompilator nie akceptuje już kodu napisanego w ten sposób i zamiast tego generuje błąd kompilatora 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.
    

    Przykład (przed)

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

    Przykład (po)

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

    Ponadto, mimo że kompilator nie zapewnia określonej diagnostyki, nowy operator wbudowanego jest uznawany za nieumyślne.

  • Wywoływanie funkcji "operator type()" ( konwersja zdefiniowana przez użytkownika) dla typów innych niż klasy Poprzednie wersje kompilatora umożliwiły wywoływanie funkcji "operator type()" dla typów innych niż klasy, ignorując ją w trybie dyskretnym. To stare zachowanie stworzyło ryzyko dyskretnego złego generowania kodu, co z powodu nieprzewidywalnego zachowania środowiska uruchomieniowego. Kompilator nie akceptuje już kodu napisanego w ten sposób i zamiast tego generuje błąd kompilatora C2228.

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

    Przykład (przed)

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

    Przykład (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'
      }
    
  • Nazwa typu nadmiarowego w specyfikatorach typów rozbudowanych Poprzednie wersje kompilatora dozwolone w typename skomplikowanych specyfikatorach typów; kod napisany w ten sposób jest semantycznie niepoprawny. Kompilator nie akceptuje już kodu napisanego w ten sposób i zamiast tego generuje błąd kompilatora C3406.

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

    Przykład (przed)

      template <typename class T>
      class container;
    

    Przykład (po)

      template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case
      class container;
    
  • Wywłaszczanie typów tablic z listy inicjatora Poprzednie wersje kompilatora nie obsługiły wywłaszczania typów tablic z listy inicjatora. Kompilator obsługuje teraz tę formę wniosku typu i w związku z tym wywołania do szablonów funkcji używających list inicjatora mogą być teraz niejednoznaczne lub można wybrać inne przeciążenie niż w poprzednich wersjach kompilatora. Aby rozwiązać te problemy, program musi teraz jawnie określić przeciążenie zamierzone przez programistę.

    Gdy to nowe zachowanie powoduje rozpoznanie przeciążenia w celu uwzględnienia dodatkowego kandydata, który jest równie dobry jak historyczny kandydat, wywołanie staje się niejednoznaczne i w wyniku tego kompilator generuje błąd kompilatora C2668.

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

    Przykład 1: Niejednoznaczne wywołanie przeciążonych funkcji (przed)

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

    Przykład 1: niejednoznaczne wywołanie przeciążonych funkcji (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);
      }
    

    Gdy to nowe zachowanie powoduje rozpoznanie przeciążenia w celu uwzględnienia dodatkowego kandydata, który jest lepszym dopasowaniem niż historyczny kandydat, wywołanie jest jednoznacznie rozstrzygane dla nowego kandydata, co powoduje zmianę zachowania programu, która prawdopodobnie różni się od zamierzonego przez programistę.

    Przykład 2: zmiana w rozwiązywaniu przeciążenia (przed)

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

    Przykład 2: zmiana w rozwiązywaniu przeciążenia (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});
      }
    
  • Przywracanie ostrzeżeń instrukcji switch

    Poprzednia wersja kompilatora usunęła istniejące switch wcześniej ostrzeżenia dotyczące instrukcji . Te ostrzeżenia zostały teraz przywrócone. Kompilator wydaje teraz przywrócone ostrzeżenia, a ostrzeżenia związane z konkretnymi przypadkami (w tym przypadkiem domyślnym) są teraz wydawane w wierszu zawierającym przypadek, a nie w ostatnim wierszu instrukcji switch. W wyniku teraz wydawania tych ostrzeżeń w innych wierszach niż w przeszłości, #pragma warning(disable:####) ostrzeżenia wcześniej pominięte przy użyciu mogą nie być już pomijane zgodnie z przeznaczeniem. Aby pominąć te ostrzeżenia zgodnie z zamierzeniem, #pragma warning(disable:####) może być konieczne przeniesienie dyrektywy do wiersza powyżej pierwszego potencjalnie obrażłego przypadku. Poniżej przedstawiono przywrócone ostrzeżenia.

      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
    

    Przykład C4063 (przed)

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

    Przykład C4063 (po)

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

    Przykłady innych przywróconych ostrzeżeń znajdują się w ich dokumentacji.

  • #include: użycie specyfikatora katalogu nadrzędnego ".". w pathname (dotyczy tylko /Wall/WX)

    Poprzednie wersje kompilatora nie wykryły użycia specyfikatora katalogu nadrzędnego ".". w nazwie ścieżki dyrektyw #include . Kod napisany w ten sposób zwykle jest przeznaczony do dołączania nagłówków, które istnieją poza projektem, niepoprawnie używając ścieżek względnych projektu. To stare zachowanie stworzyło ryzyko, że program może zostać skompilowany przez dojście do pliku źródłowego innego niż zamierzony przez programistę lub że te ścieżki względne nie będą przenośne do innych środowisk kompilacji. Kompilator wykrywa teraz i powiadamia programistę kodu napisanego w ten sposób i generuje opcjonalne ostrzeżenie kompilatora C4464, jeśli jest włączone.

      warning C4464: relative include path contains '..'
    

    Przykład (przed)

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

    Przykład (po)

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

    Ponadto, mimo że kompilator nie zapewnia określonej diagnostyki, zalecamy również użycie specyfikatora katalogu nadrzędnego ".", aby określić katalogi dołączania projektu.

  • #pragma optimize() rozszerza koniec pliku nagłówka (dotyczy tylko /Wall/WX)

    Poprzednie wersje kompilatora nie wykryły zmian ustawień flagi optymalizacji, które ujmą w błąd plik nagłówkowy uwzględniony w jednostce translacji. Kompilator wykrywa teraz i powiadamia programistę kodu napisanego w ten sposób i generuje opcjonalne ostrzeżenie kompilatora C4426 #includew lokalizacji obrażania , jeśli jest włączone. To ostrzeżenie jest wyświetlane tylko wtedy, gdy zmiany są w konflikcie z flagami optymalizacji ustawionymi przez argumenty wiersza polecenia kompilatora.

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

    Przykład (przed)

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

    Przykład (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"
    
  • Niezgodne ostrzeżenie #pragma (wypychanie)i #pragma ostrzeżenie(pop) (dotyczy tylko /Wall/WX)

    Poprzednie wersje kompilatora nie wykryły #pragma warning(push) , że zmiany #pragma warning(pop) stanu są sparowane ze zmianami stanu w innym pliku źródłowym, co jest rzadko zamierzone. To stare zachowanie stworzyło ryzyko, że program zostanie skompilowany z włączonym innym zestawem ostrzeżeń niż zamierzony przez programistę, co prawdopodobnie spowoduje dyskretne złe zachowanie środowiska uruchomieniowego. Kompilator wykrywa teraz i powiadamia programistę kodu napisanego w ten sposób i generuje opcjonalne ostrzeżenie kompilatora C5031 #pragma warning(pop)w lokalizacji pasującego parametru , jeśli jest włączone. To ostrzeżenie zawiera uwagę odwołującą się do lokalizacji odpowiedniego .#pragma warning(push)

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

    Przykład (przed)

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

    Przykład (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"
      ...
    

    Mimo że jest to nietypowe, kod napisany w ten sposób jest czasami zamierzony. Kod napisany w ten sposób jest wrażliwy #include na zmiany w kolejności. Jeśli to możliwe, zaleca się, aby pliki kodu źródłowego zarządzały stanem ostrzeżenia w sposób samodzielny.

  • Niedopasowane ostrzeżenie #pragma (wypychanie) (dotyczy tylko /Wall/WX)

    Poprzednie wersje kompilatora nie wykryły niedopasowanych #pragma warning(push) zmian stanu na końcu jednostki translacji. Kompilator wykrywa teraz i powiadamia programistę kodu napisanego w ten sposób i generuje opcjonalne ostrzeżenie kompilatora C5032 #pragma warning(push)w lokalizacji niedopasowanych , jeśli jest włączone. To ostrzeżenie jest wyświetlane tylko wtedy, gdy w jednostce translacji nie ma błędów kompilacji.

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

    Przykład (przed)

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

    Przykład (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)
    
  • Dodatkowe ostrzeżenia mogą być wyświetlane w wyniku ulepszonego śledzenia stanu #pragma ostrzeżeniem

    Poprzednie wersje kompilatora śledziły zmiany #pragma warning stanu w niewystarczającym zakresie, aby były wyświetlane wszystkie zamierzone ostrzeżenia. To zachowanie stworzyło ryzyko, że niektóre ostrzeżenia zostaną skutecznie pominięte w okolicznościach innych niż zamierzone przez programistę. #pragma warning#pragma warning Kompilator śledzi teraz stan bardziej niezawodnie — szczególnie związany ze zmianami stanu wewnątrz szablonów — i opcjonalnie generuje nowe ostrzeżenia C5031 i C5032, które mają pomóc programisty #pragma warning(push)#pragma warning(pop)zlokalizować niezamierzone zastosowania i .

    W wyniku ulepszonego #pragma warning śledzenia zmian stanu mogą być teraz wyświetlane ostrzeżenia wcześniej nieprawidłowo pominięte lub ostrzeżenia związane z problemami, które wcześniej były nieprawidłowo diagnozowane.

  • Ulepszona identyfikacja nieosiąganego kodu

    Zmiany standardowej biblioteki języka C++ i ulepszona możliwość wykonywania wywołań funkcji w tekście w poprzednich wersjach kompilatora może umożliwić kompilatorowi udowodnienie, że określony kod jest teraz nieosiągalny. To nowe zachowanie może spowodować, że nowe i częściej wystawiane wystąpienia ostrzeżenia C4720.

      warning C4720: unreachable code
    

    W wielu przypadkach to ostrzeżenie może zostać wydane tylko podczas kompilowania z włączonymi optymalizacjami, ponieważ optymalizacje mogą w tekście większej liczby wywołań funkcji, wyeliminować nadmiarowy kod lub w inny sposób określić, że określony kod jest nieosiągalny. Zaobserwowaliśmy, że nowe wystąpienia ostrzeżenia C4720 często występowały w blokach try/catch , szczególnie w odniesieniu do użycia std::find.

    Przykład (przed)

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

    Przykład (po)

      try
      {
          auto iter = std::find(v.begin(), v.end(), 5);
      }
      catch(...)
      {
          do_something();  // warning C4702: unreachable code
      }
    
  • Usuwanie optymalizacji pow(T, int) odwijania

    W poprzednich wersjach standardowej biblioteki pow(T, int) języka C++ zdefiniowano szablon funkcji, który umożliwia odwijanie pow wywołania funkcji w serię operacji mnożenia. Ta technika powodowałaby naliżenie dużej ilości niedokładności ze względu na charakter operacji zmiennoprzecinkach, co powodowało, że wyniki końcowe mogły być znacznie niedokładne. W Visual Studio 2015 Update 1 to zachowanie zostało usunięte, aby uniknąć przypadkowej utraty dokładności podczas korzystania z pow funkcji. Jednak ta wersja programu była pow znacznie szybsza niż poprawne obliczenie. Jeśli ta zmiana powoduje znaczącą regresję wydajności, a projekt nie wymaga dokładnych wyników zmiennoprzecinków (na przykład projekt już kompiluje się z /fp:fast), pow rozważ zastąpienie wywołań metody tą funkcją obejścia:

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

    Ta implementacja jest taka sama jak w poprzednich wersjach Visual Studio.

Ulepszenia zgodności w wersji Visual Studio 2015 Update 2

  • Dodatkowe ostrzeżenia i błędy mogą być wystawiane w wyniku częściowej obsługi wyrażenia SFINAE

    Poprzednie wersje kompilatora nie decltype analizują niektórych rodzajów wyrażeń wewnątrz specyfikatorów ze względu na brak obsługi sfINAE wyrażeń. To stare zachowanie było nieprawidłowe i nie jest zgodne ze standardem C++. Kompilator analizuje teraz te wyrażenia i ma częściową obsługę funkcji SFINAE wyrażeń ze względu na ciągłe ulepszenia zgodności. W związku z tym kompilator generuje teraz ostrzeżenia i błędy znalezione w wyrażeniach, których poprzednie wersje kompilatora nie analizowały.

    Gdy to nowe zachowanie analizuje decltype wyrażenie, które zawiera typ, który nie został jeszcze zadeklarowany, kompilator generuje w wyniku błąd kompilatora C2039.

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

    Przykład 1: użycie niezadeklarowanego typu (przed)

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

    Przykład 1 (po)

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

    decltypetypename Gdy to nowe zachowanie analizuje wyrażenie, w którym brakuje niezbędnego użycia słowa kluczowego w celu określenia, że nazwa zależna jest typem, kompilator generuje ostrzeżenie kompilatora C4346 wraz z błędem kompilatora 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'
    

    Przykład 2: nazwa zależna nie jest typem (przed)

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

    Przykład 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>()));
      };
    
  • volatileZmienne członkowskie uniemożliwiają niejawnie zdefiniowane konstruktory i operatory przypisania Poprzednie wersje kompilatora volatile umożliwiły klasie, która ma zmienne członkowskie, domyślne konstruktory kopiowania/przenoszenia oraz automatyczne generowanie domyślnych operatorów przypisania kopiowania/przenoszenia. To stare zachowanie było nieprawidłowe i nie jest zgodne ze standardem C++. Kompilator uznaje teraz klasę, która ma zmienne nietrwałe, za nietrwałe operatory konstrukcji i przypisania, co uniemożliwia automatyczne generowanie domyślnych implementacji tych operatorów. Gdy taka klasa jest elementem członkowskim unii (lub anonimową unią wewnątrz klasy), konstruktory kopiowania/przenoszenia i operatory przypisania kopiowania/przenoszenia unii (lub klasy zawierającej unie synonimy) zostaną niejawnie zdefiniowane jako usunięte. Próba skonstruowania lub skopiowania unii (lub klasy zawierającej unię anonimową) bez ich jawnego definiowania jest błędem, a w związku z tym kompilator generuje błąd kompilatora C2280.

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

    Przykład (przed)

      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
    

    Przykład (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
    
  • Statyczne funkcje członkowskie nie obsługują kwalifikatorów cv.

    Poprzednie wersje programu Visual C++ 2015 umożliwiły statycznym funkcjam członkowskim mieć kwalifikator cv. To zachowanie jest spowodowane regresją w wersji Visual C++ 2015 i Visual C++ 2015 Update 1; Visual C++ 2013 i poprzednie wersje programu Visual C++ odrzucają kod napisany w ten sposób. Zachowanie wersji Visual C++ 2015 Visual C++ 2015 Update 1 jest nieprawidłowe i nie jest zgodne ze standardem C++. Visual Studio 2015 Update 2 odrzuca kod napisany w ten sposób i zamiast tego generuje błąd kompilatora C2511.

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

    Przykład (przed)

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

    Przykład (po)

      struct A
      {
        static void func();
      };
    
      void A::func() {}  // removed const
    
  • Deklaracja wyliczek do przodu nie jest dozwolona w kodzie WinRT (dotyczy /ZW tylko)

    Kod skompilowany dla środowisko wykonawcze systemu Windows (WinRT) enum nie zezwala na deklarowane typy, podobnie jak w przypadku kompilowania zarządzanego kodu C++ dla programu .Net Framework /clr przy użyciu przełącznika kompilatora. To zachowanie zapewnia, że rozmiar wyliczenia jest zawsze znany i może być poprawnie rzutowany na system typów WinRT. Kompilator odrzuca kod napisany w ten sposób i generuje błąd kompilatora C2599 wraz z błędem kompilatora C3197.

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

    Przykład (przed)

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

    Przykład (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;
        }
      };
    
  • Przeciążony operator niebędący członkiem new i operator delete mogą nie być zadeklarowane w tekście (domyślnie poziom 1 (/W1)

    Poprzednie wersje kompilatora nie wystawiają ostrzeżenia, gdy funkcje new i operator delete nieznajdują się w tekście. Kod napisany w ten sposób jest niewłaściwie formowany (nie jest wymagana diagnostyka) i może powodować problemy z pamięcią wynikające z niezgodności nowych i usuniętych operatorów (zwłaszcza w przypadku użycia razem z cofaniem alokacji o rozmiarze), które mogą być trudne do zdiagnozowania. Kompilator generuje teraz ostrzeżenie kompilatora C4595, aby ułatwić identyfikację kodu napisanego w ten sposób.

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

    Przykład (przed)

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

    Przykład (po)

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

    Naprawianie kodu napisanego w ten sposób może wymagać, aby definicje operatorów zostały przeniesione z pliku nagłówkowego i do odpowiedniego pliku źródłowego.

Ulepszenia zgodności w wersji Visual Studio 2015 Update 3

  • std::is_convertable teraz wykrywa przypisanie samodzielne (biblioteka standardowa) std::is_convertable Poprzednie wersje cech typu nie wykryły prawidłowo przypisania typu klasy po usunięciu lub usunięciu jego konstruktora kopiowania lub jego prywatnego. Teraz obiekt std::is_convertable<>::value jest poprawnie ustawiony na wartość false po zastosowaniu do typu klasy za pomocą usuniętego lub prywatnego konstruktora kopiowania.

    Z tą zmianą nie jest skojarzona diagnostyka kompilatora.

    Przykład

      #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");
    

    W poprzednich wersjach Visual C++ std::is_convertable<>::value statyczne asercji w dolnej części tego przykładu były pass, ponieważ został niepoprawnie ustawiony na true. Teraz obiekt std::is_convertable<>::value jest poprawnie ustawiony na wartość false, co powoduje niepowodzenie asercji statycznych.

  • Domyślne lub usunięte konstruktory trywialne kopiowania i przenoszenia respektują specyfikatory dostępu

    Poprzednie wersje kompilatora nie sprawdzały specyfikatora dostępu domyślnych lub usuniętych konstruktorów trywialnych kopii i przenoszenia przed zezwoleniem na ich wywoływanie. To stare zachowanie było nieprawidłowe i nie jest zgodne ze standardem C++. W niektórych przypadkach to stare zachowanie stworzyło ryzyko dyskretnego złego generowania kodu, co z powodu nieprzewidywalnego zachowania środowiska uruchomieniowego. Kompilator sprawdza teraz specyfikator dostępu domyślnych lub usuniętych konstruktorów kopii i przenoszenia, aby określić, czy można go nazwać, a jeśli nie, generuje ostrzeżenie kompilatora C2248 w wyniku.

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

    Przykład (przed)

      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
      }
    

    Przykład (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);
      }
    
  • Domyślnie cofanie obsługi kodu ATL z przypisanymi wartościami (/W1domyślnie poziom 1)

    Poprzednie wersje kompilatora obsługiwane były kod ATL z przypisanymi kodami. W następnej fazie usuwania obsługi kodu ATL z przypisanymi funkcjami, który rozpoczął się w Visual C++ 2008 r., kod ATL z przypisanymi funkcjami jest przestarzały. Kompilator generuje teraz ostrzeżenie kompilatora C4467, aby ułatwić identyfikację tego rodzaju przestarzałego kodu.

      warning C4467: Usage of ATL attributes is deprecated
    

    Jeśli chcesz nadal używać kodu ATL z przypisanymi wartościami do momentu usunięcia obsługi z kompilatora, /Wv:18 możesz wyłączyć to ostrzeżenie, przekazując argumenty wiersza polecenia lub /wd4467#pragma warning(disable:4467) do kompilatora albo dodając kod źródłowy.

    Przykład 1 (przed)

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

    Przykład 1 (po)

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

    Czasami może być konieczne utworzenie pliku IDL w celu uniknięcia użycia przestarzałych atrybutów ATL, jak w poniższym przykładowym kodzie

    Przykład 2 (przed)

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

    Najpierw utwórz plik *.idl; Wygenerowanego pliku vc140.idl można użyć do uzyskania pliku *.idl zawierającego interfejsy i adnotacje.

    Następnie dodaj krok MIDL do kompilacji, aby upewnić się, że są generowane definicje interfejsu języka C++.

    Przykład 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;
          };
      }
    

    Następnie użyj atl bezpośrednio w pliku implementacji, jak w poniższym przykładowym kodzie.

    Przykład 2 Implementacja (po)

      #include <idl.header.h>
      #include <atlbase.h>
    
      class ATL_NO_VTABLE CFooImpl :
          public ICustom,
          public ATL::CComObjectRootEx<CComMultiThreadModel>
      {
      public:
          BEGIN_COM_MAP(CFooImpl)
          COM_INTERFACE_ENTRY(ICustom)
          END_COM_MAP()
      };
    
  • Prekompilowane pliki nagłówka (PCH) i niezgodne #include dyrektywy (dotyczy tylko /Wall/WX)

    Poprzednie wersje kompilatora akceptowały niezgodne #include dyrektywy w plikach źródłowych -Yc między plikami i -Yu kompilacjami podczas korzystania ze wstępnie skompilowanych plików nagłówka (PCH). Kod napisany w ten sposób nie jest już akceptowany przez kompilator. Kompilator generuje teraz ostrzeżenie kompilatora CC4598, aby ułatwić identyfikację #include niezgodnych dyrektyw podczas korzystania z plików PCH.

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

    Przykład (przed):

    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"
    

    Przykład (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"
    
  • Prekompilowane pliki nagłówka (PCH) i niezgodne katalogi dołączania (dotyczy tylko /Wall/WX)

    Poprzednie wersje kompilatora zaakceptowały niezgodne argumenty wiersza polecenia katalogu dołączania (-I) -Yc-Yu do kompilatora między kompilacjami i podczas korzystania ze wstępnie skompilowanych plików nagłówka (PCH). Kod napisany w ten sposób nie jest już akceptowany przez kompilator. Kompilator generuje teraz ostrzeżenie kompilatora CC4599, aby ułatwić identyfikację niezgodnych argumentów wiersza polecenia katalogu dołączania (-I) podczas korzystania z plików PCH.

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

    Przykład (przed)

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

    Przykład (po)

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

Co nowego w języku C++ w języku Visual Studio 2013

Ulepszona obsługa standardów ISO C/C++

Compiler

MSVC obsługuje następujące funkcje języka ISO C++11:

  • Domyślne argumenty szablonu dla szablonów funkcji.
  • Delegowanie konstruktorów
  • Operatory konwersji jawnej.
  • Listy inicjatorów i jednolite inicjowanie.
  • Nieprzetworzone literały ciągu.
  • Szablony wariancji.
  • Szablony aliasów.
  • Usunięte funkcje.
  • Inicjatory niestatycznych członków danych (NSDMI).
  • Funkcje domyślne. *
  • Obsługuje następujące funkcje języka ISO C99:
  • _Bool
  • Literały złożone.
  • Wyznaczone inicjatory.
  • Łączenie deklaracji z kodem.
  • Konwersja literału ciągu na modyfikowalne wartości może być niedozwolone przy użyciu nowej opcji kompilatora /Zc:strictStrings. W języku C++98 konwersja z literałów char* ciągów na (i literały wchar_t*ciągu szerokiego na ) była przestarzała. W języku C++11 konwersja została całkowicie usunięta. Mimo że kompilator może być ściśle zgodny ze standardem, zamiast tego udostępnia /Zc:strictStrings opcję , która umożliwia kontrolowanie konwersji. Domyślnie ta opcja jest wyłączona. Należy pamiętać, że jeśli używasz tej opcji w trybie debugowania, STL nie zostanie skompilowany.
  • rvalue/lvalue rzutowania odwołania. W przypadku odwołań rvalue język C++11 może wyraźnie rozróżnić wartości lvalue i rvalue. Wcześniej kompilator nie zapewniał tego w określonych scenariuszach rzutowania. Dodano /Zc:rvalueCastnową opcję kompilatora, , aby kompilator był zgodny z dokumentem roboczym języka C++ (patrz sekcja 5.4, [expr.cast]/1). Zachowanie domyślne, gdy ta opcja nie jest określona jest taka sama jak w Visual Studio 2012.

Uwaga

W przypadku funkcji domyślnych użycie operatora =default w celu zażądania konstruktorów przenoszenia w poszczególnych członkach i operatorów przypisania przenoszenia nie jest obsługiwane.

Biblioteki C99

Deklaracje i implementacje są dodawane dla brakujących funkcji w tych nagłówkach: math.h, ctype.h, wctype.h, stdio.h, stdlib.h i wchar.h. Dodano również nowe nagłówki complex.h, stdbool.h, hr i inttypes.h oraz implementacje dla wszystkich zadeklarowanych w nich funkcji. Dostępne są nowe nagłówki otoki języka C++ (ccomplex, ckkv, cinttypes, ctgmath) i zaktualizowano wiele innych (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar i cwctype).

Standardowa biblioteka szablonów

Obsługa operatorów jawnej konwersji języka C++11, list inicjatorów, wylików o zakresie i szablonów wariancji. Wszystkie kontenery obsługują teraz precyzyjne wymagania dotyczące elementów języka C++11. Obsługa tych funkcji języka C++14:

  • "Transparent operator functors" less<>, greater<>, plus<>, multiplies<> i tak dalej.
  • <make_unique T>(args...) i make_unique< T[]>(n)
  • cbegin()/cend(), rbegin()/rend() i crbegin()/crend() funkcje nie-członkowskie.
  • <Atomic> otrzymał wiele ulepszeń wydajności.
  • <> type_traits wprowadzono istotne poprawki dotyczące ustabilizowania i kodu.

Zmiany powodujące niezgodność

Ta ulepszona obsługa standardów ISO C/C++ może wymagać zmian w istniejącym kodzie, tak aby był zgodny z C++11 i poprawnie kompiluje się w Visual C++ w Visual Studio 2013.

ulepszenia Visual C++ biblioteki

  • Dodano zestaw SDK REST języka C++. Ma nowoczesną implementację usług REST w języku C++.
  • C++ AMP ulepszona obsługa tekstury. Teraz obejmuje obsługę mipmap i nowych trybów próbkowania.
  • Zadania PPL obsługują wiele technologii planowania i debugowania asynchronicznego. Nowe interfejsy API umożliwiają tworzenie zadań PPL zarówno dla normalnych wyników, jak i warunków wyjątków.

Wydajność aplikacji w języku C++

  • Wektoryzator automatyczny rozpoznaje i optymalizuje teraz więcej wzorców języka C++, aby przyspieszyć uruchamianie kodu.
  • Ulepszenia jakości kodu dla platformy ARM i mikro architektury Atom.
  • __vectorcall dodano konwencję wywoływania. Przekaż argumenty typu wektora przy użyciu __vectorcall wywoływania do używania rejestrów wektorów.
  • Nowe opcje programu Linker. Przełączniki /Gw (kompilator) i /Gy (asembler) umożliwiają optymalizacje łączenia w celu tworzenia bardziej zuchemnych plików binarnych.
  • C++ AMP pamięci współdzielonych w celu zmniejszenia lub wyeliminowania kopiowania danych między procesorem CPU i procesorem GPU.

Ulepszenia optymalizacji z przewodnikiem profilów (PGO)

  • Ulepszenia wydajności dzięki zmniejszeniu zestawu roboczego aplikacji zoptymalizowanych przy użyciu technologii PGO.
  • Nowa aplikacja PGO do środowisko wykonawcze systemu Windows tworzenia aplikacji.

środowisko wykonawcze systemu Windows tworzenia aplikacji

  • Obsługa typów boxed w strukturach wartości.

    Teraz można definiować typy wartości przy użyciu pól, które mogą mieć wartość null — na przykład w IBox<int>^ przeciwieństwie do wartości int. Oznacza to, że pola mogą mieć wartość lub być równe nullptr.

  • Bogatsze informacje o wyjątkach.

    Język C++/CX obsługuje nowy model błędów usługi Windows, który umożliwia przechwytywanie i propagację rozbudowanych informacji o wyjątkach w interfejsie binarnym aplikacji (ABI). Obejmuje to stosy wywołań i niestandardowe ciągi komunikatów.

  • Object::ToString() jest teraz wirtualny.

    Teraz można zastąpić ToString w zdefiniowanych przez użytkownika środowisko wykonawcze systemu Windows typu ref.

  • Obsługa przestarzałych interfejsów API.

    Publiczne środowisko wykonawcze systemu Windows API można teraz oznaczać jako przestarzałe i podać niestandardowy komunikat, który jest wyświetlany jako ostrzeżenie dotyczące kompilacji i może zapewnić wskazówki dotyczące migracji.

  • Ulepszenia debugera.

    Obsługa debugowania międzyoptymowego natywnego/JavaScript, środowisko wykonawcze systemu Windows diagnostyki wyjątków i debugowania kodu asynchronicznego (zarówno w środowisko wykonawcze systemu Windows, jak i PPL).

Uwaga

Oprócz funkcji i ulepszeń specyficznych dla języka C++, które zostały opisane w tej sekcji, inne ulepszenia w programie Visual Studio mogą również pomóc w pisaniu lepszych środowisko wykonawcze systemu Windows aplikacji.

Ulepszenia diagnostyki

  • Ulepszenia debugera. Obsługa debugowania asynchronicznego i Tylko mój kod debugowania.
  • Code Analysis kategorie. Teraz możesz wyświetlać dane wyjściowe podzielone na kategorie z Analizatora kodu, aby ułatwić znajdowanie i naprawianie błędów kodu.
  • Diagnostyka XAML. W języku XAML można teraz diagnozować problemy związane z czasami odpowiedzi interfejsu użytkownika i zużyciem baterii.
  • Ulepszenia debugowania grafiki i procesora GPU.
  • Zdalne przechwytywanie i odtwarzanie na rzeczywistych urządzeniach.
  • Jednoczesne C++ AMP i debugowanie procesora CPU.
  • Ulepszono C++ AMP środowiska uruchomieniowego.
  • Debugowanie śledzenia modułu cieniowania obliczeń HLSL.

Ulepszenia grafiki 3-D

  • Obsługa potoku zawartości obrazu dla wstępnie pomnożonego formatu alpha DDS.
  • Edytor obrazów używa wstępnie pomnożonego wewnętrznie alfa do renderowania, dzięki czemu unika renderowania artefaktów, takich jak ciemne obwódki.
  • Edytory obrazów i modeli. Tworzenie filtru zdefiniowanego przez użytkownika jest teraz obsługiwane w Projektancie cieniowania w Edytorze obrazów i Edytorze modelu.

Ide i produktywność

Ulepszone formatowanie kodu. Więcej ustawień formatowania można zastosować do kodu C++. Za pomocą tych ustawień można kontrolować położenie nowego wiersza nawiasów klamrowych i słów kluczowych, wcięcia, odstępy i zawijanie wiersza. Kod jest automatycznie formatowany po zakończeniu instrukcji i bloków oraz wklejeniu kodu do pliku.

Uzupełnianie nawiasów klamrowych. Kod języka C++ teraz automatycznie kończy znaki zamykające, które odpowiadają tym znakom otwierającym:

  • { (nawias klamrowy)
  • [ (nawias kwadratowy)
  • ( (nawiasy)
  • ' (pojedynczy cudzysłów)
  • "(cudzysłowami)

Dodatkowe funkcje automatycznego uzupełniania w języku C++.

  • Dodaje średnik dla typów klas.
  • Kończy nawiasy dla nieprzetworzonych literałów ciągu.
  • Kończy komentarze wielo wierszowe (/* */)

Znajdź wszystkie odwołania teraz automatycznie rozwiązuje i filtruje odwołania w tle po wyświetla listę dopasowania tekstowe.

Context-Based filtrowania listy elementów członkowskich. Niedostępne elementy członkowskie są filtrowane z list elementów członkowskich funkcji IntelliSense. Na przykład prywatne elementy członkowskie nie są wyświetlane na liście elementów członkowskich, chyba że modyfikujesz kod, który implementuje typ. Gdy lista elementów członkowskich jest otwarta, możesz nacisnąć klawisze CtrlJ+, aby usunąć jeden poziom filtrowania (dotyczy tylko bieżącego okna listy elementów członkowskich). Możesz ponownie nacisnąć klawisz CtrlJ+, aby usunąć filtrowanie tekstowe i wyświetlić każdy członek.

Przewijanie pomocy dotyczącej parametrów. Sygnatura funkcji wyświetlana w etykietce narzędzia pomoc parametru zmienia się teraz w oparciu o liczbę parametrów, które rzeczywiście wpisano, a nie tylko na podstawie dowolnego podpisu i nie aktualizując go na podstawie bieżącego kontekstu. Parametr pomaga również prawidłowo działać, gdy jest wyświetlany w zagnieżdżonych funkcjach.

Przełącz plik nagłówka/kodu. Teraz możesz przełączać się między nagłówkiem i odpowiadającym mu plikiem kodu za pomocą polecenia w menu skrótów lub skrótu klawiaturowego.

Okno właściwości Project C++ z Project zmiany rozmiaru

Automatyczne generowanie kodu procedury obsługi zdarzeń w językach C++/CX i C++/CLI. Podczas wpisywania kodu w celu dodania procedury obsługi zdarzeń w pliku kodu C++/CX lub C++/CLI edytor może automatycznie wygenerować wystąpienie delegata i definicję procedury obsługi zdarzeń. Gdy kod procedury obsługi zdarzeń może zostać wygenerowany automatycznie, zostanie wyświetlone okno etykietki narzędzia.

Ulepszenie świadomości DPI. Ustawienie świadomości DPI dla plików manifestu aplikacji obsługuje teraz ustawienie "Na monitor z dużą wartością dpi".

Szybsze przełączanie konfiguracji. W przypadku dużych aplikacji przełączanie konfiguracji — szczególnie kolejnych operacji przełączania — jest wykonywane znacznie szybciej.

Wydajność czasu kompilacji. Liczne optymalizacje i wykorzystanie wielu rdzeni przyspiesza kompilacje, szczególnie w przypadku dużych projektów. Kompilacje przyrostowe dla aplikacji języka C++, które mają odwołania do C++ WinMD, są również znacznie szybsze.

Co nowego w języku C++ w Visual Studio 2012 r.

Ulepszona obsługa standardów języka C++11

Standardowa biblioteka szablonów

  • Obsługa nowych nagłówków STL: atomic, chrono, condition_variable, filesystem>, <future>, <mutex>, <ratio> i <thread.><><><><
  • Aby zoptymalizować użycie zasobów pamięci, kontenery są teraz mniejsze. Na przykład w trybie wydania x86 std::vector z ustawieniami domyślnymi program ma mniejsze od 16 bajtów (od Visual Studio 2010 r. do 12 bajtów w Visual Studio 2012 r.) std::map i ma mniejsze od 16 bajtów (od Visual Studio 2010 r. do 8 bajtów w Visual Studio 2012 r.).
  • Zgodnie z dozwolonymi, ale nie wymaganymi przez standard C++11, zaimplementowano iteratory SCARY.

Inne ulepszenia języka C++11

  • Pętle for oparte na zakresach. Możesz napisać bardziej niezawodne pętle, które działają z tablicami, kontenerami STL i kolekcjami środowisko wykonawcze systemu Windows w postaci dla ( for-range-declaration : expression ). Jest to część obsługi języka podstawowego.

  • Bez stanowe wyrażenia lambda, które są blokami kodu, które rozpoczynają się od pustego wprowadzenia lambda [] i nie przechwytują zmiennych lokalnych, są teraz niejawnie konwertowane na wskaźniki funkcji zgodnie z wymaganiami standardu C++11.

  • Obsługa wyliczeń o zakresie. Klasa wylinia języka C++ jest teraz obsługiwana. Poniższy kod pokazuje, jak ten klucz wyliczy różni się od poprzedniego zachowania wyli roku.

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

środowisko wykonawcze systemu Windows tworzenia aplikacji

  • Natywny model interfejsu użytkownika oparty na języku XAML. W środowisko wykonawcze systemu Windows aplikacji można użyć nowego natywnego modelu interfejsu użytkownika opartego na języku XAML.
  • Visual C++ rozszerzenia składników. Te rozszerzenia upraszczają środowisko wykonawcze systemu Windows obiektów, które są niezbędną częścią środowisko wykonawcze systemu Windows aplikacji. Aby uzyskać więcej informacji, zobacz Roadmap for środowisko wykonawcze systemu Windows apps using C++ and Visual C++ language reference (C++/CX) (Harmonogram działania dla aplikacji korzystających z języka C++ i Visual C++ (C++/CX)
  • Gry DirectX. Możesz tworzyć atrakcyjne gry, korzystając z nowej obsługi directx dla środowisko wykonawcze systemu Windows aplikacji.
  • Międzyplatop w języku XAML/DirectX. środowisko wykonawcze systemu Windows, które korzystają zarówno z języka XAML, jak i DirectX, teraz efektywnie współdziałają.
  • środowisko wykonawcze systemu Windows projektowania bibliotek DLL składników. Tworzenie bibliotek DLL składników sprawia, środowisko wykonawcze systemu Windows rozszerzalne.

Kompilator i linker

  • Wektoryzator automatyczny. Kompilator analizuje pętle w kodzie i, jeśli to możliwe, emituje instrukcje, które używają rejestrów wektorów i instrukcji, które są obecne we wszystkich nowoczesnych procesorach. Dzięki temu pętle działają szybciej. (Instrukcje procesora są nazywane SSE, dla Streaming SIMD Extensions). Nie trzeba włączać ani żądać tej optymalizacji, ponieważ jest ona stosowana automatycznie.
  • Automatyczna paralelizator. Kompilator może analizować pętle w kodzie i emitować instrukcje, które rozkładają obliczenia na wiele rdzeni lub procesorów. Może to przyspieszyć uruchamianie pętli. Należy zażądać tej optymalizacji, ponieważ nie jest ona domyślnie włączona. W wielu przypadkach warto uwzględnić w #pragma loop(hint_parallel(N)) kodzie bezpośrednio przed pętlami, które mają być zrównolegnione.
  • Wektoryzator automatyczny i automatyczny paralelizator mogą ze sobą współpracować, dzięki czemu obliczenia są rozłożone na wiele rdzeni, a kod na każdym rdzeniu używa swoich rejestrów wektorów.

Nowość w wersji Visual Studio 2012 Update 1

Cel Windows XP podczas kompilowania kodu C++. Kompilator i biblioteki języka Microsoft C++ mogą być docelowe dla Windows XP i Windows Server 2003.

Obsługa programowania równoległego

C++ Accelerated Massive Parallelism (AMP)

C++ AMP przyspiesza wykonywanie kodu C++, korzystając ze sprzętu równoległego do przetwarzania danych, który jest zwykle obecny jako procesor GPU na dyskretnej karcie graficznej. Model C++ AMP obejmuje tablice wielowymiarowe, indeksowanie, transfer pamięci, kafelkowanie i bibliotekę funkcji matematycznych. Korzystając z C++ AMP języka i ograniczeń kompilatora, możesz kontrolować sposób, w jaki dane są przenoszone z procesora CPU do procesora GPU i z powrotem.

Debugowania. Środowisko debugowania dla aplikacji, które używają C++ AMP do obsługi procesora GPU, jest podobne do debugowania dla innych aplikacji języka C++. Obejmuje to nowe dodatki debugowania równoległego, które zostały wymienione wcześniej.

Profilowania. Obsługa profilowania dla aktywności procesora GPU jest teraz oparta na C++ AMP i innych modelach programowania opartych na direct3D.

Ogólne ulepszenia programowania równoległego

W przypadku sprzętu przechodzącego do architektur wielordzeniowych i wielordzeniowych deweloperzy nie mogą już polegać na stale zwiększających się szybkościach zegara z jednego rdzenia. Obsługa programowania równoległego w środowisko uruchomieniowe współbieżności umożliwia deweloperom korzystanie z tych nowych architektur. W Visual Studio 2010 r. wprowadzono zaawansowane biblioteki przetwarzania równoległego języka C++, takie jak Biblioteka równoległych wzorców, wraz z funkcjami, które mogą wykorzystać współbieżność, wyrażając zaawansowane potoki przepływu danych. W Visual Studio 2012 r. te biblioteki zostały rozszerzone w celu zapewnienia lepszej wydajności, większej kontroli i bogatszej obsługi równoległych wzorców, których deweloperzy potrzebują najbardziej. Zakres oferty obejmuje teraz:

  • Rozbudowane model programowania opartego na zadaniach, który obsługuje synchronizację i kontynuacje.
  • Algorytmy równoległe, które obsługują równoległość sprzężenia widelecowego (parallel_for, parallel_for z koligacją, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
  • Kontenery bezpieczne dla współbieżności, które zapewniają bezpieczne wątkowo wersje struktur danych std, takie jak priority_queue, kolejka, wektor i mapa.
  • Biblioteka agentów asynchronicznych, której deweloperzy mogą używać do wyrażania potoków przepływu danych, które w naturalny sposób rozkładają się na jednostki współbieżne.
  • Dostosowywalny harmonogram i menedżer zasobów ułatwiający bezproblemową kompozycję wzorców na tej liście.
Ogólne ulepszenia debugowania równoległego

Oprócz okna Zadania równoległe i okna stosów równoległych program Visual Studio 2012 oferuje nowe okno równoległego wyrażenia watch, które umożliwia badanie wartości wyrażenia we wszystkich wątkach i procesach oraz sortowanie i filtrowanie wyników. Możesz również użyć własnych wizualizatorów, aby rozszerzyć okno, i skorzystać z nowej obsługi wielu procesów we wszystkich oknach narzędzi.

IDE

Visual Studio szablonów. Teraz można używać technologii szablonów Visual Studio do tworzenia szablonów projektów i elementów języka C++.

Asynchroniczne ładowanie rozwiązań. Projekty są teraz ładowane asynchronicznie — najpierw kluczowe części rozwiązania — dzięki czemu można szybciej rozpocząć pracę.

Wdrożenie automatyczne na potrzeby debugowania zdalnego. Wdrażanie plików na potrzeby zdalnego debugowania w Visual C++ zostało uproszczone. Opcja Wd wdrażana w menu kontekstowym projektu automatycznie kopiuje na komputer zdalny pliki określone we właściwościach konfiguracji debugowania. Ręczne kopiowanie plików na komputer zdalny nie jest już wymagane.

Funkcja IntelliSense dla języka C++/interfejsu wiersza polecenia. Język C++/CLI ma teraz pełną obsługę funkcji IntelliSense. Funkcje IntelliSense, takie jak szybkie informacje, pomoc parametrów, elementy członkowskie listy i automatyczne uzupełnianie, działają teraz w języku C++/interfejsie wiersza polecenia. Ponadto inne ulepszenia funkcji IntelliSense i środowiska IDE wymienione w tym dokumencie działają również w języku C++/interfejsie wiersza polecenia.

Bogatsze etykietki narzędzi IntelliSense. Etykietki szybka podpowiedź funkcji IntelliSense dla języka C++ zawierają teraz bardziej rozbudowane informacje o stylu komentarzy dokumentacji XML. Jeśli używasz interfejsu API z biblioteki — na przykład C++ AMP — która zawiera komentarze dokumentacji XML, etykietka narzędzia IntelliSense zawiera więcej informacji niż tylko deklaracja. Ponadto jeśli kod zawiera komentarze dokumentacji XML, etykietki narzędzi funkcji IntelliSense będą wyświetlać bardziej rozbudowane informacje.

Konstrukcje kodu języka C++. Na liście rozwijanej Elementy członkowskie listy dostępny jest kod szkieletowy dla pętli switch, if-else, for i innych podstawowych konstrukcji kodu. Wybierz fragment kodu z listy, aby wstawić go do kodu, a następnie wypełnij wymaganą logikę. Możesz również utworzyć własne niestandardowe fragmenty kodu do użycia w edytorze.

Ulepszenia elementów członkowskich listy. Lista rozwijana Elementy członkowskie listy jest wyświetlana automatycznie podczas wpisywania kodu w edytorze kodu. Wyniki są filtrowane, tak aby podczas wpisywania były wyświetlane tylko odpowiednie elementy członkowskie. Możesz kontrolować rodzaj logiki filtrowania używanej przez listę elementów członkowskich — w oknie dialogowym Opcje w obszarze Edytor>tekstuC/C++>Advanced.

Kolorowanie semantyczne. Typy, wyliczenia, makra i inne tokeny języka C++ mają teraz domyślnie kolorowanie.

Wyróżnianie odwoływać. Wybranie symbolu wyróżnia teraz wszystkie wystąpienia symbolu w bieżącym pliku. Naciśnij klawiszeCtrlShiftUp++Arrow lub CtrlShiftDown++Arrow, aby przechodzić między wyróżnione odwołania. Tę funkcję można wyłączyć w oknie dialogowym Opcje w obszarze Edytor>tekstuC/C++>Zaawansowane.

Narzędzia do zarządzania cyklem życia aplikacji

Statyczne Code Analysis

Analiza statyczna dla języka C++ została zaktualizowana w celu zapewnienia bogatszych informacji o kontekście błędu, większej liczby reguł analizy i lepszych wyników analizy. W nowym Code Analysis można filtrować komunikaty według słowa kluczowego, projektu i ważności. Po wybraniu komunikatu w oknie wiersz w kodzie, w którym komunikat został wyzwolony, zostanie wyróżniony w edytorze kodu. W przypadku niektórych ostrzeżeń języka C++ komunikat zawiera listę wierszy źródłowych, które pokazują ścieżkę wykonywania prowadzącą do ostrzeżenia; wyróżnione punkty decyzyjne i przyczyny podjęcia tej konkretnej ścieżki. Analiza kodu jest zawarta w większości wersji Visual Studio 2012. W wersjach Professional, Premium i Ultimate uwzględniono wszystkie reguły. W wersjach Express dla Windows 8 i Windows Phone uwzględniane są tylko ostrzeżenia o krytycznym znaczeniu. Analiza kodu nie jest uwzględniona w wersji Express for Web. Oto kilka innych ulepszeń analizy kodu:

  • Nowe ostrzeżenia współbieżności pomagają uniknąć błędów współbieżności, upewnijąc się, że używasz odpowiednich dyscyplin blokowania w wielowątkowych programach C/C++. Analizator wykrywa potencjalne sytuacje wyścigu, inwersje zamówień blokad, naruszenia kontraktu blokowania wywołującego/wywołującego, niezgodne operacje synchronizacji i inne usterki współbieżności.
  • Reguły języka C++, które mają być stosowane do przebiegów analizy kodu, można określić przy użyciu zestawów reguł.
  • W Code Analysis można wstawić do kodu źródłowego pragmę, która pomija wybrane ostrzeżenie.
  • Dokładność i kompletność statycznej analizy kodu można poprawić przy użyciu nowej wersji języka adnotacji kodu źródłowego (SAL) firmy Microsoft w celu opisania sposobu, w jaki funkcja używa jej parametrów, założeń dotyczących ich i gwarancji, które podejmuje po zakończeniu.
  • Obsługa 64-bitowych projektów C++.

Zaktualizowano platformę testów jednostkowych

Użyj nowej struktury testów jednostkowych języka C++ w języku Visual Studio do pisania testów jednostkowych języka C++. Dodaj nowy projekt testu jednostkowego do istniejącego rozwiązania C++, lokalizując szablon testów jednostkowych języka C++ Project kategorii Visual C++ w oknie dialogowym Nowy Project testów. Zacznij pisać testy jednostkowe w wygenerowanym TEST_METHOD kodu w pliku Unittest1.cpp. Podczas kompilowania kodu testowego skompilować rozwiązanie. Jeśli chcesz uruchomić testy, otwórz okno Eksplorator testów jednostkowych, wybierając pozycję WidokInne WindowsUnit Test Explorer, a > następnie w menu skrótów odpowiedniego przypadku testowego wybierz pozycję Uruchom wybrany >test. Po zakończeniu testu możesz wyświetlić wyniki testu i dodatkowe informacje o śledzeniu stosu w tym samym oknie.

Wykresy zależności architektury

Aby lepiej zrozumieć kod, możesz teraz generować wykresy zależności dla plików binarnych, klas, przestrzeni nazw i plików dołączanych do rozwiązania. Na pasku menu wybierz pozycję ArchitekturaGeneruj> zależności Graph, a następnie w przypadku rozwiązania lub dla pliku dołączania w celu wygenerowania grafu zależności. Po zakończeniu generowania grafu można go eksplorować, rozwijając każdy węzeł, ucząc się relacji zależności, przenosząc się między węzłami i przeglądając kod źródłowy, wybierając pozycję Wyświetl zawartość w menu skrótów węzła. Aby wygenerować wykres zależności dla plików dołączanych, w menu skrótów pliku kodu źródłowego *.cpp lub pliku nagłówka *.h wybierz pozycję Wygeneruj Graph dołącz pliki.

Eksplorator architektury

Za pomocą Eksploratora architektury można eksplorować zasoby w rozwiązaniu C++, projektach lub plikach. Na pasku menu wybierz pozycję Architektura>Windows>Architecture Explorer. Możesz wybrać węzeł, który Cię interesuje, na przykład Widok klasy. W tym przypadku prawa strona okna narzędzi jest rozwinięta z listą przestrzeni nazw. W przypadku wybrania przestrzeni nazw nowa kolumna zawiera listę klas, struktur i wyliżeń w tej przestrzeni nazw. Możesz kontynuować eksplorowanie tych zasobów lub wrócić do kolumny po lewej stronie, aby uruchomić inne zapytanie. Zobacz Znajdowanie kodu za pomocą Eksploratora architektury.

Pokrycie kodu

Pokrycie kodu zostało zaktualizowane w celu dynamicznego instrumentacji plików binarnych w czasie wykonywania. Obniża to obciążenie związane z konfiguracją i zapewnia lepszą wydajność. Możesz również zbierać dane pokrycia kodu z testów jednostkowych dla aplikacji języka C++. Po utworzeniu testów jednostkowych języka C++ można użyć Eksploratora testów jednostkowych do odnajdywania testów w rozwiązaniu. Aby uruchomić testy jednostkowe i zebrać dla nich dane pokrycia kodu, w Eksploratorze testów jednostkowych wybierz pozycję Analizuj pokrycie kodu. Wyniki pokrycia kodu można sprawdzić w oknie Wyniki pokrycia kodu — na pasku menu wybierz pozycję Test>Windows>Kodowanie wyników.

Co nowego w języku C++ w Visual Studio 2010 r.

Kompilator i program linku języka C++

auto — Słowo kluczowe. Słowo auto kluczowe ma nowe przeznaczenie. Użyj domyślnego znaczenia słowa kluczowego auto , aby zadeklarować zmienną, której typ jest wywoływany z wyrażenia inicjalizacji w deklaracji zmiennej. Opcja /Zc:auto kompilatora wywołuje nowe lub poprzednie znaczenie słowa kluczowego auto .

Specyfikator typu decltype. Specyfikator decltype typu zwraca typ określonego wyrażenia. Użyj specyfikatora decltype typu w połączeniu ze auto słowem kluczowym , aby zadeklarować typ, który jest złożony lub znany tylko kompilatorowi. Na przykład użyj kombinacji , aby zadeklarować funkcję szablonu, której zwracany typ zależy od typów argumentów szablonu. Lub zadeklaruj funkcję szablonu, która wywołuje inną funkcję, a następnie zwraca zwracany typ wywoływanej funkcji.

Wyrażenia lambda. Funkcje lambda mają treść funkcji, ale nie mają nazwy. Funkcje lambda łączą najlepsze cechy wskaźników funkcji i obiektów funkcji. Użyj samej funkcji lambda jako parametru funkcji szablonu zamiast obiektu funkcji lub razem ze słowem kluczowym , auto aby zadeklarować zmienną, której typem jest lambda.

Rvalue Reference (Odwołanie do wartości Rvalue). Deklarator odwołania rvalue (&&) deklaruje odwołanie do rvalue. Odwołanie rvalue umożliwia używanie semantyki przenoszenia i doskonałego przekazywania w celu napisania bardziej wydajnych konstruktorów, funkcji i szablonów.

static_assert Deklaracja. Deklaracja static_assert testuje asercja oprogramowania w czasie kompilacji, w przeciwieństwie do innych mechanizmów asercji, które testują w czasie działania. Jeśli asercja zakończy się niepowodzeniem, kompilacja zakończy się niepowodzeniem i zostanie wyświetlony określony komunikat o błędzie.

nullptr i __nullptr słowa kluczowe. MSVC umożliwia użycie słowa kluczowego z nullptr kodem natywnym lub z kodem zarządzanym. Słowo nullptr kluczowe wskazuje, że uchwyt obiektu, wewnętrzny wskaźnik lub natywny typ wskaźnika nie wskazuje obiektu. Kompilator interpretuje kod nullptr zarządzany, gdy /clr używasz opcji kompilatora, i kod natywny, gdy nie używasz /clr opcji . Słowo kluczowe specyficzne dla __nullptr Microsoft ma takie samo znaczenie jak nullptr, ale ma zastosowanie tylko do kodu natywnego. W przypadku kompilowania natywnego kodu C/C++ /clr przy użyciu opcji kompilatora kompilator nie może określić, nullptr czy słowo kluczowe jest terminem natywnym, czy zarządzanym. Aby wyraźnie wyjaśnić intencję kompilatorowi, użyj słowa kluczowego nullptr, aby określić zarządzany termin, a __nullptr określić termin natywny.

/Zc:trigraphs Opcja kompilatora. Domyślnie obsługa trójgrafów jest wyłączona. Użyj opcji /Zc:trigraphs kompilatora, aby włączyć obsługę trójgrafów. Trójgraf składa się z dwóch kolejnych znaków zapytania (??), po których następuje unikatowy trzeci znak. Kompilator zastępuje trójgraf odpowiednim znakiem interpunkcji. Na przykład kompilator zastępuje ? = trójgraf ze znakiem # (znak numeru). Użyj trójgrafów w plikach źródłowych języka C, które używają zestawu znaków, który nie zawiera niektórych znaków interpunkcji.

Nowa Profile-Guided optymalizacji wydajności. PogoSafeMode to nowa opcja optymalizacji z przewodnikiem profilowym, która pozwala określić, czy podczas optymalizacji aplikacji używać trybu bezpiecznego, czy trybu szybkiego. Sejf jest bezpieczny wątkowo, ale jest wolniejszy niż tryb szybki. Domyślnym zachowaniem jest tryb szybki.

Nowa opcja środowiska uruchomieniowego języka wspólnego (CLR) /clr:nostdlib. Dodano nową opcję dla /clr (kompilacja środowiska uruchomieniowego języka wspólnego). Jeśli są uwzględniane różne wersje tych samych bibliotek, jest wyświetlany błąd kompilacji. Nowa opcja umożliwia wykluczenie domyślnych bibliotek CLR, dzięki czemu program może używać określonej wersji.

Nowa dyrektywa pragma detect_mismatch. Dyrektywa pragma detect_mismatch pozwala umieścić tag w plikach, który jest porównywany z innymi tagami o tej samej nazwie. Jeśli istnieje wiele wartości dla tej samej nazwy, linker zwraca błąd.

Funkcje wewnętrzne XOP, funkcje wewnętrzne FMA4 i funkcje wewnętrzne UPSP. Dodano nowe funkcje wewnętrzne w celu obsługi funkcji wewnętrznych XOP dodanych dla systemu Visual Studio 2010 z dodatkiem SP1, funkcji wewnętrznych FMA4 dodanych do programu Visual Studio 2010 SP1 i funkcji wewnętrznych UPSP dodanych dla technologii procesora Visual Studio 2010 SP1. Użyj __cpuid __cpuidex, aby określić, które technologie procesora są obsługiwane na określonym komputerze.

Visual Studio projektów języka C++ i systemu kompilacji

MSBuild. Visual C++ i projekty są teraz budowy przy użyciu MSBuild.exe, która zastępuje VCBuild.exe. MSBuild to to samo elastyczne, rozszerzalne narzędzie kompilacji oparte na języku XML, które jest używane przez inne Visual Studio i typy projektów. Z powodu tej zmiany pliki Visual Studio C++ używają teraz formatu pliku XML i mają rozszerzenie nazwy pliku vcxproj. Visual Studio C++ z wcześniejszych wersji programu Visual Studio są automatycznie konwertowane na nowy format pliku.

Katalogi VC++. Ustawienie katalogów VC++ znajduje się teraz w dwóch miejscach. Użyj stron właściwości projektu, aby ustawić wartości dla 1 projektu dla katalogów VC++. Użyj Menedżer właściwości i arkusza właściwości, aby ustawić globalne wartości konfiguracji dla katalogów VC++.

Project między Project zależnościami. We wcześniejszych wersjach zdefiniowane zależności między projektami były przechowywane w pliku rozwiązania. Gdy te rozwiązania są konwertowane na nowy format pliku projektu, zależności są konwertowane na odwołania między projektami. Ta zmiana może mieć wpływ na aplikacje, ponieważ koncepcje zależności rozwiązań i odwołań między projektami są różne.

Makra i zmienne środowiskowe. Nowe makro _ITERATOR_DEBUG_LEVEL wywołuje obsługę debugowania dla iteratorów. Użyj tego makra zamiast starszych _SECURE_SCL i _HAS_ITERATOR_DEBUGGING makr.

Biblioteki Visual C++

środowisko uruchomieniowe współbieżności biblioteki. Ta środowisko uruchomieniowe współbieżności obsługuje aplikacje i składniki, które działają jednocześnie, i jest platformą do programowania współbieżnych aplikacji w Visual C++. Aby obsługiwać programowanie aplikacji współbieżnych, biblioteka Parallel Patterns Library (PPL) udostępnia kontenery i algorytmy ogólnego przeznaczenia służące do wykonywania szczegółowej równoległości. Biblioteka agentów asynchronicznych udostępnia oparty na aktorze model programowania i interfejsy przekazywania komunikatów dla zgrubnego przepływu danych i zadań przetwarzania potokowego.

Standardowa biblioteka C++. Na poniższej liście opisano wiele zmian wprowadzonych w standardowej bibliotece C++.

  • Nowa funkcja języka C++ referencyjna rvalue została użyta do zaimplementowania semantyki przenoszenia i doskonałego przekazywania dla wielu funkcji w standardowej bibliotece szablonów. Semantyka przenoszenia i doskonałe przekazywanie znacznie poprawiają wydajność operacji przydzielania lub przypisywania zmiennych lub parametrów.
  • Odwołania Rvalue są również używane do implementowania nowej unique_ptr klasy, która jest bezpieczniejszym typem inteligentnego wskaźnika niż auto_ptr klasa. Klasa unique_ptr jest wymienna, ale nie można jej kopiować, implementuje ścisłą semantykę własności bez wpływu na bezpieczeństwo i dobrze działa z kontenerami, które wiedzą o odwołaniach rvalue. Klasa auto_ptr jest przestarzała.
  • Do nagłówka algorytmu dodano 15 nowych funkcji, find_if_notna przykład , is_sorted<i> . copy_if
  • W nagłówku <> pamięci nowa funkcja make_shared jest wygodnym, niezawodnym i wydajnym sposobem na wskaźnik współużytkowany do obiektu w tym samym czasie, gdy obiekt jest konstruowany.
  • Listy połączone z singly są obsługiwane przez forward_list <> nagłówka.
  • Nowe funkcje cbeginczłonkowskie , cend, crbegini crend zapewniają funkcję , const_iterator która przesuwa się do przodu lub do tyłu przez kontener.
  • Nagłówek <system_error> i powiązane szablony obsługują przetwarzanie błędów systemowych niskiego poziomu. Składowe klasy mogą exception_ptr służyć do transportu wyjątków między wątkami.
  • Nagłówek <codecvt> obsługuje konwertowanie różnych kodowań znaków Unicode na inne.
  • Nagłówek <alokatorów> definiuje kilka szablonów, które ułatwiają przydzielanie i wolne bloki pamięci dla kontenerów opartych na węzłach.
  • Istnieje wiele aktualizacji losowego <nagłówka> .

Biblioteka klas Microsoft Foundation (MFC)

Windows 7 Funkcje. MFC obsługuje wiele funkcji Windows 7, na przykład interfejs użytkownika wstążki, pasek zadań, listy szybkiego dostępu, miniatury z kartami, podglądy miniatur, pasek postępu, nakładkę ikon i indeksowanie wyszukiwania. Ponieważ MFC automatycznie obsługuje wiele Windows 7, może nie być trzeba modyfikować istniejącej aplikacji. Aby obsługiwać inne funkcje w nowych aplikacjach, użyj Kreatora aplikacji MFC, aby określić funkcje, których chcesz użyć.

Świadomość wielo dotykowa. MFC obsługuje aplikacje, które mają interfejs użytkownika z wieloma dotykami, na przykład aplikacje napisane dla systemu operacyjnego Microsoft Surface. Aplikacja obsługująca wiele dotyku może obsługiwać Windows dotykową i komunikaty gestów, które są kombinacjami komunikatów dotykowych. Wystarczy zarejestrować aplikację pod celu obsługi zdarzeń dotykowych i gestów, a system operacyjny będzie przekierowyowywowyć zdarzenia wielodotykowe do programów obsługi zdarzeń.

Wysoki poziom świadomości DPI. Domyślnie aplikacje MFC mają teraz świadomość wysokiej rozdzielczości DPI. Jeśli aplikacja ma świadomość wysokiej rozdzielczości DPI (wysokie kropki na cal), system operacyjny może skalować okna, tekst i inne elementy interfejsu użytkownika do bieżącej rozdzielczości ekranu. Oznacza to, że skalowany obraz będzie bardziej prawdopodobnie poprawnie rozplanowany, a nie obcięty ani nie będzie pikselowany.

Uruchom ponownie Menedżera. Menedżer ponownego uruchamiania automatycznie zapisuje dokumenty i uruchamia ponownie aplikację w przypadku nieoczekiwanego zamknięcia lub ponownego uruchomienia. Na przykład możesz użyć menedżera ponownego uruchamiania, aby uruchomić aplikację po jej zamknięciu przez automatyczną aktualizację. Aby uzyskać więcej informacji na temat sposobu konfigurowania aplikacji do korzystania z menedżera ponownego uruchamiania, zobacz Jak dodać obsługę Menedżera ponownego uruchamiania.

Ctaskdialog. Zamiast CTaskDialog standardowego AfxMessageBox okna komunikatu można użyć klasy . Klasa CTaskDialog wyświetla i zbiera więcej informacji niż standardowe okno komunikatu.

Biblioteka SafeInt

Nowa biblioteka SafeInt wykonuje bezpieczne operacje arytmetyczne, które są związane z przepełnieniem liczb całkowitych. Ta biblioteka porównuje również różne rodzaje liczb całkowitych.

Nowe Active Template Library (ATL)

Dodano nowe makra do atl w celu rozszerzenia funkcjonalności PROP_ENTRY_TYPE i PROP_ENTRY_TYPE_EX. PROP_ENTRY_INTERFACE i PROP_ENTRY_INTERFACE_EX umożliwiają dodanie listy prawidłowych identyfikatorów CLSID. PROP_ENTRY_INTERFACE_CALLBACK i PROP_ENTRY_INTERFACE_CALLBACK_EX umożliwiają określenie funkcji wywołania zwrotnego w celu określenia, czy clsid jest prawidłowy.

/analyze , ostrzeżenia

Większość /analyze ostrzeżeń (Enterprise Code Analysis) została usunięta z bibliotek C Run-Time (CRT), MFC i ATL.

Animacja i obsługa D2D

MFC obsługuje teraz animacje i grafiki Direct2D. Biblioteka MFC ma kilka nowych klas i funkcji MFC, które obsługują tę funkcję. Istnieją również dwa nowe wskazówki, które pokazują, jak dodać obiekt D2D i obiekt animacji do projektu. Te wskazówki to: Dodawanie obiektu D2D do obiektu MFC Project i Przewodnik: dodawanie animacji do obiektu MFC Project.

IDE

Ulepszona funkcja IntelliSense. Funkcja IntelliSense Visual C++ została całkowicie przeprojektowana, aby była szybsza, dokładniejsza i mogła obsługiwać większe projekty. Aby osiągnąć to ulepszenie, idee rozróżniają sposób, w jaki deweloper widokuje i modyfikuje kod źródłowy, a także sposób, w jaki idee wykorzystują kod źródłowy i ustawienia projektu do kompilowania rozwiązania. Ze względu na to rozdzielenie obowiązków funkcje przeglądania, takie jak Widok klasy i nowe okno dialogowe Przejdź do, są obsługiwane przez system oparty na nowym pliku bazy danych programu SQL Server Desktop (sdf), który zastępuje stary plik przeglądania bez kompilacji (ncb). Funkcje IntelliSense, takie jak Szybkie informacje, Automatyczne uzupełnianie i Pomoc w parametrach, analizują jednostki translacji tylko wtedy, gdy jest to wymagane. Funkcje hybrydowe, takie jak nowe okno Hierarchia wywołań, używają kombinacji funkcji przeglądania i IntelliSense. Ponieważ funkcja IntelliSense przetwarza tylko te informacje, których obecnie potrzebujesz, środowisko IDE reaguje bardziej elastycznie. Ponadto ponieważ informacje są bardziej aktualne, widoki IDE i okna są dokładniejsze. Ponadto, ponieważ infrastruktura IDE jest lepiej zorganizowana, bardziej sprawna i skalowalna, może obsługiwać większe projekty.

Ulepszone błędy funkcji IntelliSense. Środowisko IDE lepiej wykrywa błędy, które mogą spowodować utratę funkcji IntelliSense, i wyświetla czerwone faliste podkreślenia pod nimi. Ponadto środowisko IDE zgłasza błędy funkcji IntelliSense w oknie listy błędów. Aby wyświetlić kod, który powoduje problem, kliknij dwukrotnie błąd w oknie Lista błędów.

#include autouzupełniań. Ide obsługuje automatyczne uzupełnianie dla słowa kluczowego #include . Po wpisaniu #includepliku ide tworzy pole listy rozwijanej prawidłowych plików nagłówkowych. Jeśli będziesz kontynuować, wpisując nazwę pliku, ide przefiltruje listę na podstawie wpisu. W dowolnym momencie możesz wybrać z listy plik, który chcesz dołączyć. Dzięki temu można szybko dołączać pliki bez znajomości dokładnej nazwy pliku.

Przejdź do. Okno dialogowe Przejdź do umożliwia wyszukiwanie wszystkich symboli i plików w projekcie, które pasują do określonego ciągu. Wyniki wyszukiwania są natychmiast poprawiane podczas wpisywania dodatkowych znaków w ciągu wyszukiwania. Pole Opinia o wynikach informuje o liczbie znalezionych elementów i pomaga zdecydować, czy ograniczyć wyszukiwanie. Pola rodzaj/zakres, lokalizacjai wersja zapoznawcza opinii ułatwiają ujednoznacznienie elementów o podobnych nazwach. Ponadto można rozszerzyć tę funkcję do obsługi innych języków programowania.

Debugowanie równoległe i profilowanie. Debuger Visual Studio wie o środowisko uruchomieniowe współbieżności i ułatwia rozwiązywanie problemów z aplikacjami do przetwarzania równoległego. Za pomocą nowego narzędzia profilera współbieżności można wizualizować ogólne zachowanie aplikacji. Ponadto można użyć nowych okien narzędzi do wizualizacji stanu zadań i ich stosów wywołań.

Projektant wstążki. Projektant wstążki to edytor graficzny, który umożliwia tworzenie i modyfikowanie interfejsu użytkownika wstążki MFC. Końcowy interfejs użytkownika wstążki jest reprezentowany przez plik zasobów oparty na formacie XML (mfcribbon-ms). W przypadku istniejących aplikacji możesz przechwycić bieżący interfejs użytkownika wstążki, tymczasowo dodając kilka wierszy kodu, a następnie wywołując Projektanta wstążki. Po utworzeniu pliku zasobów wstążki możesz zastąpić ręcznie napisany kod interfejsu użytkownika wstążki kilkoma instrukcjemi, które ładują zasób wstążki.

Wywołaj hierarchię. Okno Hierarchia wywołań umożliwia przechodzenie do wszystkich funkcji wywoływanych przez określoną funkcję lub do wszystkich funkcji, które wywołują określoną funkcję.

narzędzia

Kreator klas MFC. Visual C++ 2010 przywróci dobrze znane narzędzie kreatorów klas MFC. Kreator klas MFC to wygodny sposób dodawania klas, komunikatów i zmiennych do projektu bez konieczności ręcznego modyfikowania zestawów plików źródłowych.

Kreator kontrolki ATL. Kreator sterowania ATL nie wypełnia już automatycznie ProgID pola. Jeśli kontrolka ATL nie ma kontrolki ProgID, inne narzędzia mogą z nim nie współpracować. Jednym z przykładów narzędzia, które wymaga, aby kontrolki były kontrolkami , ProgID jest okno dialogowe Wstawianie aktywnej kontrolki. Aby uzyskać więcej informacji na temat okna dialogowego, zobacz Insert ActiveX controls (Wstawianie ActiveX formantów).

Microsoft Macro Assembler — odwołanie

Dodanie typu danych YMMWORD obsługuje 256-bitowe operandy multimedialne, które są zawarte w instrukcjach Intel Advanced Vector Extensions (AVX).

Co nowego w języku C++ w Visual Studio 2008 r.

Visual C++ zintegrowane środowisko projektowe (IDE)

  • Okna dialogowe tworzone w aplikacjach ATL, MFC i Win32 są teraz zgodne z Windows vista. Podczas tworzenia nowego projektu przy użyciu programu Visual Studio 2008 wszystkie okna dialogowe wstawiania do aplikacji będą zgodne z wytycznymi w stylu Windows Vista. W przypadku ponownego skompilowania projektu utworzonego przy użyciu starszej wersji programu Visual Studio wszystkie istniejące okna dialogowe będą zachowywać taki sam wygląd, jak wcześniej. Aby uzyskać więcej informacji na temat wstawiania okien dialogowych do aplikacji, zobacz Edytor okien dialogowych.

  • Kreator rejestracji Project ATL ma teraz opcję rejestrowania składników dla wszystkich użytkowników. Począwszy od programu Visual Studio 2008, składniki COM i biblioteki typów tworzone przez kreatora atl Project są rejestrowane w węźle HKEY_CURRENT_USER rejestru, chyba że dla wszystkich użytkowników zostanie zaznaczona wartość Zarejestruj składnik.

  • Kreator tworzenia Project ATL nie udostępnia już opcji tworzenia projektów ATL z przypisanymi elementami. Począwszy od Visual Studio 2008 r., kreator Project ATL nie ma możliwości zmiany stanu przypisanego nowego projektu. Wszystkie nowe projekty ATL, które tworzy kreator, są teraz nieprzydzielone.

  • Zapisywanie w rejestrze może zostać przekierowane. Wraz z wprowadzeniem Windows Vista zapisywanie w niektórych obszarach rejestru wymaga programu do uruchomienia w trybie podwyższonym poziomem uprawnień. Nie jest pożądane, aby zawsze uruchamiać Visual Studio w trybie z podwyższonym poziomem uprawnień. Przekierowywanie na użytkownika automatycznie przekierowuje zapis w rejestrze z HKEY_CLASSES_ROOT do HKEY_CURRENT_USER bez żadnych zmian programowania.

  • Kod Projektant klas ma teraz ograniczoną obsługę natywnego kodu C++. We wcześniejszych wersjach Visual Studio Projektant klas tylko z Visual C# i Visual Basic. Użytkownicy języka C++ mogą teraz używać Projektant klas, ale tylko w trybie tylko do odczytu. Aby uzyskać więcej informacji na temat korzystania z Projektant klas w języku C++, zobacz Working with Visual C++ Code in Projektant klas (Praca z kodem Visual C++ w języku Projektant klas).

  • Kreator projektu nie ma już opcji tworzenia projektu w języku C++ SQL Server projektu. Począwszy od Visual Studio 2008 r., kreator nowego projektu nie ma możliwości utworzenia projektu w języku C++ SQL Server projektu. SQL Server utworzone przy użyciu starszej wersji programu Visual Studio będą nadal kompilowane i działać poprawnie.

Biblioteki Visual C++

Ogólne

  • Aplikacje mogą być powiązane z określonymi wersjami bibliotek Visual C++ biblioteki. Czasami aplikacja zależy od aktualizacji, które zostały wprowadzone Visual C++ biblioteki po wydaniu. W takim przypadku uruchomienie aplikacji na komputerze, który ma wcześniejsze wersje bibliotek, może spowodować nieoczekiwane zachowanie. Teraz można powiązać aplikację z określoną wersją bibliotek, dzięki czemu nie będzie ona uruchamiana na komputerze z wcześniejszą wersją bibliotek.

Biblioteka STL/CLR

  • Visual C++ zawiera teraz bibliotekę STL/CLR. Biblioteka STL/CLR jest opakowaniem standardowej biblioteki szablonów (STL), podzestawu standardowej biblioteki C++ do użycia z językiem C++ i środowiskiem uruchomieniowym języka wspólnego (CLR) języka .NET Framework. Za pomocą STL/CLR można teraz używać wszystkich kontenerów, iteratorów i algorytmów STL w środowisku zarządzanym.

Biblioteka MFC

  • Windows Vista obsługuje formanty wspólne. Dodano ponad 150 metod w 18 nowych lub istniejących klasach w celu obsługi funkcji w systemie Windows Vista lub ulepszenia funkcjonalności w bieżących klasach MFC.
  • Nowa klasa CNetAddressCtrl umożliwia wprowadzanie i weryfikowanie adresów IPv4 i IPv6 lub nazw DNS.
  • Nowa klasa CPagerCtrl upraszcza korzystanie z kontrolki Windows pager.
  • Nowa klasa CSplitButton upraszcza użycie kontrolki Windows, aby wybrać akcję domyślną lub opcjonalną.

Biblioteka obsługi języka C++

  • W języku C++ wprowadzono bibliotekę marshalingu. Biblioteka marshalingu zapewnia łatwy i zoptymalizowany sposób marshalingu danych między środowiskami natywnymi i zarządzanymi. Biblioteka jest alternatywą dla bardziej złożonych i mniej wydajnych metod, takich jak korzystanie z funkcji PInvoke. Aby uzyskać więcej informacji, zobacz Omówienie marshalingu w języku C++.

Serwer ATL

  • Serwer ATL jest udostępniany jako udostępniony projekt źródłowy.
  • Większość kodu serwera ATL została wydana jako udostępniony projekt źródłowy w projekcie CodePlex i nie jest instalowana w ramach Visual Studio 2008 r. Kilka plików skojarzonych z serwerem ATL nie jest już częścią Visual Studio. Aby uzyskać listę usuniętych plików, zobacz Removed ATL Server Files (Usunięte pliki serwera ATL).
  • Klasy kodowania i dekodowania danych z pliku atlenc.h oraz funkcje narzędzi i klasy z atlutil.h i atlpath.h są teraz częścią biblioteki ATL.
  • Firma Microsoft będzie nadal obsługiwać wersje serwera ATL, które są zawarte we wcześniejszych wersjach Visual Studio, o ile te wersje Visual Studio są obsługiwane. CodePlex będzie kontynuować opracowywanie kodu serwera ATL jako projektu społeczności. Firma Microsoft nie obsługuje wersji CodePlex serwera ATL.

Visual C++ i linker

Zmiany kompilatora

  • Kompilator obsługuje zarządzane kompilacje przyrostowe. Po określeniu tej opcji kompilator nie będzie ponownie kompilować kodu po zmianie przywołynego zestawu. Zamiast tego wykona kompilację przyrostową. Pliki są ponownie kompilowane tylko wtedy, gdy zmiany wpływają na kod zależny.
  • Atrybuty związane z serwerem ATL nie są już obsługiwane. Kompilator nie obsługuje już kilku atrybutów, które były bezpośrednio powiązane z serwerem ATL. Aby uzyskać pełną listę usuniętych atrybutów, zobacz Istotne zmiany.
  • Kompilator obsługuje mikroarchitekturę Intel Core. Kompilator zawiera dostrajanie mikroarchitektur Intel Core podczas generowania kodu. Domyślnie to dostrajanie jest włączone i nie można go wyłączyć, ponieważ ułatwia to również Pentium 4 i inne procesory.
  • Funkcje wewnętrzne obsługują nowsze procesory AMD i Intel. Kilka nowych instrukcji wewnętrznych obsługuje większą funkcjonalność w najnowszych procesorach AMD i Intel. Aby uzyskać więcej informacji na temat nowych funkcji wewnętrznych, zobacz Dodatkowe Streaming SIMD Extensions 3 Instrukcje, Streaming SIMD Extensions 4 Instrukcje, SSE4A i funkcje wewnętrzne zaawansowanego manipulowania bitami, funkcje wewnętrzne AES, _mm_clmulepi64_si128 i __rdtscp.
  • Funkcja __cpuid zostanie zaktualizowana. Funkcje __cpuid, __cpuidex obsługują teraz kilka nowych funkcji z najnowszych wersji procesorów AMD i Intel. Funkcja __cpuidex wewnętrzna jest nowa i zbiera więcej informacji z najnowszych procesorów.
  • Opcja /MP kompilatora skraca całkowity czas kompilacji. Opcja /MP może znacznie skrócić całkowity czas kompilowania kilku plików źródłowych, tworząc kilka procesów, które kompilują pliki jednocześnie. Ta opcja jest szczególnie przydatna na komputerach, które obsługują hiperwątkę, wiele procesorów lub wiele rdzeni.
  • Opcja /Wp64 kompilatora i słowo __w64 kluczowe są przestarzałe. Opcja /Wp64 kompilatora i __w64 słowo kluczowe, które wykrywają problemy z przenośnością 64-bitową, są przestarzałe i zostaną usunięte w przyszłej wersji kompilatora. Zamiast tej opcji kompilatora i słowa kluczowego użyj MSVC dla platformy 64-bitowej.
  • /Qfast_transcendentals generuje kod w tekście dla funkcji przesłonięć.
  • /Qimprecise_fwaits Usuwa polecenia fwait wewnętrzne, aby wypróbować bloki podczas korzystania z opcji /fp:except kompilatora.

Zmiany w linkerze

  • Informacje o kontroli konta użytkownika są teraz osadzone w plikach manifestu dla plików wykonywalnych przez Visual C++ (link.exe). Ta funkcja jest domyślnie włączona. Aby uzyskać więcej informacji na temat sposobu wyłączania tej funkcji lub modyfikowania domyślnego zachowania, /MANIFESTUAC zobacz (Osadza informacje funkcji UAC w manifeście).
  • Linker ma teraz możliwość włączenia /DYNAMICBASE funkcji randomizacji układu przestrzeni adresowej w systemie Windows Vista. Ta opcja modyfikuje nagłówek pliku wykonywalnego, aby wskazać, czy aplikacja powinna być losowo zmieniana w czasie ładowania.

Co nowego w języku C++ w Visual Studio 2005 r.

Następujące funkcje zostały nowe w programie Visual C++ Service Pack 1 dla programu 2005:

Funkcje wewnętrzne dla platform x86 i 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

Funkcje wewnętrzne tylko dla x64

  • __vmx_on
  • __vmx_vmclear
  • __vmx_vmlaunch
  • __vmx_vmptrld
  • __vmx_vmread
  • __vmx_vmresume
  • __vmx_vmwrite

Słowa kluczowe nowego języka

__sptr, __uptr

Nowe funkcje kompilatora

W tej wersji kompilator wprowadza istotne zmiany.

  • 64-bitowe kompilatory natywne i krzyżowe.
  • /analyzeDodano Enterprise Code Analysis kompilatora (Enterprise Code Analysis).
  • /bigobj Dodano opcję kompilatora.
  • /clr:pureDodano wartości , /clr:safe/clr:oldSyntax i . (Później przestarzałe w Visual Studio 2015 r. i usunięte w Visual Studio 2017 r.)
  • Przestarzałe opcje kompilatora: w tej wersji wiele opcji kompilatora jest przestarzałych; Aby uzyskać więcej informacji, zobacz Przestarzałe opcje kompilatora.
  • Podwójna liczba fragmentów w /clr kodzie jest ograniczona. Aby uzyskać więcej informacji, zobacz Double Thunking (C++ ).
  • /EH(Model obsługi wyjątków) /EHs lub nie może być już używany do przechwycenia wyjątku, który jest zgłaszany z elementem innym niż throw; użyj ./EHa
  • /errorReport Dodano opcję kompilatora (Zgłaszaj wewnętrzne błędy kompilatora).
  • /favor Dodano opcję kompilatora (Optymalizuj dla 64).
  • /FADodano /Fa opcję kompilatora , (wyświetlanie listy plików).
  • /FC Dodano opcję kompilatora (Pełna ścieżka pliku kodu źródłowego w diagnostyce).
  • /fp (Określ Floating-Point zachowanie) dodano opcję kompilatora.
  • /G (Optymalizacja pod kątem procesora) Dodano opcję kompilatora opcji.
  • /G (Optymalizacja pod kątem procesora) Dodano opcję kompilatora opcji.
  • /G3Usunięto /G4/G5opcje /G6kompilatora /G7, /GB i . Kompilator używa teraz "modelu mieszanego", który próbuje utworzyć najlepszy plik wyjściowy dla wszystkich architektur.
  • /Gf został usunięty. Zamiast tego /GF użyj (Wyeliminuj zduplikowane ciągi).
  • /GL (Optymalizacja całego programu) jest teraz zgodna z programem /CLRHEADER.
  • /GR jest teraz domyślnie włączone.
  • /GS (Sprawdzanie zabezpieczeń buforu) zapewnia teraz ochronę zabezpieczeń zagrożonych parametrów wskaźnika. /GS jest teraz domyślnie włączone. /GS Teraz działa również na funkcjach skompilowanych do języka MSIL za pomocą /clr funkcji (kompilacja środowiska uruchomieniowego języka wspólnego).
  • /homeparams Dodano opcję kompilatora (Kopiuj parametry rejestru do stosu).
  • /hotpatch Dodano opcję kompilatora (Create Hotpatchable Image) (Utwórz obraz z możliwością poprawki).
  • Zaktualizowano heurystykę funkcji wbudowanej; Zobacz inline, __inlinei __forceinlineinline_depth , aby uzyskać więcej informacji
  • Dodano wiele nowych funkcji wewnętrznych, a wiele wcześniej nieudokumentowanych funkcji wewnętrznych jest teraz udokumentowanych.
  • Domyślnie każde wywołanie nowej, która kończy się niepowodzeniem, będzie zgłaszać wyjątek.
  • /ML Opcje /MLd kompilatora i zostały usunięte. Visual C++ nie obsługuje już jednowątkowej, statycznie połączonej biblioteki CRT.
  • Kompilator zaimplementował optymalizację nazwanej wartości zwracanej, /O1która jest włączona podczas kompilacji za pomocą funkcji , /O2 (Minimalizuj rozmiar, Maksymalizuj szybkość), /Og (optymalizacje globalne) i /Ox (pełna optymalizacja).
  • /Oa opcja kompilatora została usunięta, ale zostanie zignorowana w trybie dyskretnym; Użyj modyfikatorów noalias lub restrict__declspec , aby określić sposób, w jaki kompilator wykonuje aliasy.
  • /Op Opcja kompilatora została usunięta. Zamiast /fp tego użyj Floating-Point (Określ zachowanie).
  • Program OpenMP jest teraz obsługiwany przez Visual C++.
  • /openmp Dodano opcję kompilatora (Włącz obsługę openMP 2.0).
  • /Ow Opcja kompilatora została usunięta, ale zostanie dyskretnie zignorowana. Użyj modyfikatorów noalias lub restrict__declspec , aby określić sposób, w jaki kompilator wykonuje aliasy.

Optymalizacje sterowane profilem

  • /QI0f został usunięty.
  • /QIfdiv został usunięty.
  • /QIPF_B Dodano opcję kompilatora (Errata dla krokowego procesora B).
  • /QIPF_C Dodano opcję kompilatora (Errata dla krokowego procesora C).
  • /QIPF_fr32 Dodano opcję kompilatora (Nie używaj 96 górnych rejestrów zmiennoprzecinków).
  • /QIPF_noPIC Dodano opcję kompilatora (Generuj kod zależny od pozycji).
  • /QIPF_restrict_plabels (Przyjmijmy, że opcja kompilatora Nie utworzono funkcji w czasie uruchamiania) została dodana.

Obsługa formatu Unicode w kompilatorze i konsolidatorze

  • /vd (Wyłącz przemieszczenia konstrukcji) umożliwia teraz używanie operatora dynamic_cast na konstruowany obiekt (/vd2)
  • /YX Opcja kompilatora została usunięta. Zamiast /Yc tego użyj (Utwórz prekompilowany plik nagłówka) /Yu lub (Użyj prekompilowanych plików nagłówka). Jeśli usuniesz konfigurację /YX kompilacji i zastąpisz ją niczym, może to spowodować szybsze kompilacje.
  • /Zc:forScope jest teraz domyślnie włączone.
  • /Zc:wchar_t jest teraz domyślnie włączone.
  • /Zd Opcja kompilatora została usunięta. Informacje debugowania tylko dla numeru wiersza nie są już obsługiwane. Zamiast /Zi tego użyj polecenia (zobacz /Z7, /Zi, /ZI (Format informacji debugowania), aby uzyskać więcej informacji.
  • /Zg Jest teraz prawidłowy tylko w plikach kodu źródłowego języka C, a nie w plikach kodu źródłowego języka C++.
  • /Zx Dodano opcję kompilatora (Debuguj zoptymalizowany kod Itanium).

Nowe funkcje językowe

  • Atrybut attributeattribute jest teraz przestarzały.
  • appdomain__declspec Dodano modyfikator .
  • __clrcall dodano konwencję wywoływania.
  • Przestarzały modyfikator declspec (C++) umożliwia teraz określenie ciągu, który będzie wyświetlany w czasie kompilacji, gdy użytkownik spróbuje uzyskać dostęp do przestarzałej klasy lub funkcji.
  • dynamic_cast Operator ma istotne zmiany.
  • Wyliczy natywne umożliwiają teraz określenie typu bazowego.
  • jitintrinsicdeclspec Dodano modyfikator .
  • noaliasdeclspec Dodano modyfikator .
  • process__declspec Dodano modyfikator .
  • Abstrakt, przesłonięcie i zapieczętowane są prawidłowe dla kompilacji natywnych.
  • __restrict Dodano słowo kluczowe .
  • restrictdeclspec Dodano modyfikator .
  • __thiscall jest teraz słowem kluczowym.
  • __unaligned Słowo kluczowe jest teraz udokumentowane.
  • volatile (C++) ma zaktualizowane zachowanie w odniesieniu do optymalizacji.

Nowe funkcje preprocesora

  • __CLR_VER dodano wstępnie zdefiniowane makro.
  • Pragma komentarza (C/C++) teraz akceptuje /MANIFESTDEPENDENCY jako komentarz linkera. Opcja exestr komentarza jest teraz przestarzała.
  • embedded_idl Atrybut (dyrektywa #import ) przyjmuje teraz opcjonalny parametr .
  • fenv_access Pragmy
  • float_control Pragmy
  • fp_contract Pragmy
  • Zmienne globalne nie będą inicjowane w kolejności, w których zostały zadeklarowane, jeśli masz zmienne globalne w sekcjach zarządzanych, nieza zarządzaniem i nieza zarządzaniem pragma. Jest to potencjalna zmiana przerywania, jeśli na przykład nieza zarządzana zmienna globalna jest zainicjowana za pomocą zarządzanych zmiennych globalnych i wymagany jest w pełni skonstruowany obiekt zarządzany.
  • Sekcje określone za pomocą init_seg są teraz tylko do odczytu, a nie odczytu/zapisu, jak w poprzednich wersjach.
  • inline_depth wartość domyślna to teraz 16. Wartość domyślna 16 obowiązywała również w programie .NET 2003 Visual C++ 2003.
  • _INTEGRAL_MAX_BITS wstępnie zdefiniowane makro, zobacz Wstępnie zdefiniowane makra.
  • _M_CEE, _M_CEE_PURE i _M_CEE_SAFE wstępnie zdefiniowane makra, zobacz Wstępnie zdefiniowane makra.
  • _M_IX86_FP dodano wstępnie zdefiniowane makro.
  • _M_X64 dodano wstępnie zdefiniowane makro.
  • make_public Pragmy
  • managed, unmanaged zaktualizowano składnię pragma (teraz ma i pushpop)
  • mscorlib.dll jest teraz niejawnie przywołyny przez dyrektywę we #using wszystkich kompilacjach /clr .
  • _OPENMP dodano wstępnie zdefiniowane makro.
  • Parametr optimize pragma został zaktualizowany, a i w nie są już prawidłowymi parametrami.
  • no_registry #import atrybut został dodany.
  • regiondodano pragmy, endregion
  • _VC_NODEFAULTLIB dodano wstępnie zdefiniowane makro.
  • Makra wariancji są teraz implementowane.
  • vtordisp jest przestarzała i zostanie usunięta w przyszłej wersji Visual C++.
  • Pragma warning ma teraz specyfikator pomijania.

Nowe funkcje łączenia

  • Moduły (pliki wyjściowe MSIL inne niż zestaw) są teraz dozwolone jako dane wejściowe dla linkera.
  • /ALLOWISOLATION Dodano opcję łączenia (wyszukiwania manifestu).
  • /ASSEMBLYRESOURCE (Osadź zasób zarządzany) został zaktualizowany, aby umożliwić teraz określenie nazwy zasobu w zestawie i określenie, że zasób jest prywatny w zestawie.
  • /CLRIMAGETYPE Dodano opcję łączenia (Określ typ obrazu CLR).
  • /CLRSUPPORTLASTERROR Dodano opcję łączenia (Zachowaj kod ostatniego błędu dla wywołań PInvoke).
  • /CLRTHREADATTRIBUTE Dodano opcję łączenia (Ustaw atrybut wątku CLR).
  • /CLRUNMANAGEDCODECHECK Dodano opcję łączenia (SuppressUnmanagedCodeSecurityAttribute).
  • /ERRORREPORT Dodano opcję łączenia (Zgłaszaj wewnętrzne błędy linkera).
  • /EXETYPE Opcja łączenia została usunięta. Linker nie obsługuje już tworzenia sterowników Windows 95 i Windows 98. Użyj odpowiedniego ddk do utworzenia tych sterowników urządzeń. Słowo kluczowe EXETYPE nie jest już prawidłowe dla plików definicji modułu.
  • /FUNCTIONPADMIN Dodano opcję łączenia (Utwórz obraz z możliwością hotpatchable).
  • /LTCG Opcja łączenia jest teraz obsługiwana w modułach skompilowanych za pomocą programu /clr. /LTCG Zaktualizowano również pod kątem obsługi optymalizacji z przewodnikiem profilowym.
  • /MANIFEST Dodano opcję łączenia (Utwórz manifest zestawu side-by-side).
  • /MANIFESTDEPENDENCY Dodano opcję łączenia (Określ zależności manifestu).
  • /MANIFESTFILE Dodano opcję łączenia (Nazwij plik manifestu).
  • /MAPINFO:LINES Opcja łączenia została usunięta.
  • /NXCOMPAT Dodano opcję łączenia (zgodną z zapobieganiem wykonywaniu danych).
  • /PGD Dodano opcję Profile-Guided Database for Profile-Guided Optimizations (Określ bazę danych dla optymalizacji wydajności).
  • /PROFILE Dodano opcję łączenia (Profiler narzędzi wydajności).
  • /SECTION Opcja łączenia (Określ atrybuty sekcji) obsługuje teraz negację atrybutów i nie obsługuje już atrybutów L ani D (powiązanych z VxD).
  • Obsługa formatu Unicode w kompilatorze i konsolidatorze
  • /VERBOSE Opcja łączenia (komunikatów o postępie drukowania) akceptuje teraz również usługi ICF i REF.
  • /VXD Opcja łączenia została usunięta. Linker nie obsługuje już tworzenia sterowników Windows 95 i Windows 98. Użyj odpowiedniego ddk do utworzenia tych sterowników urządzeń. Słowo kluczowe VXD nie jest już prawidłowe dla plików definicji modułu.
  • /WS Opcja łączenia została usunięta. /WSZostał użyty do modyfikowania obrazów docelowych Windows NT 4.0. IMAGECFG.exe -R można użyć zamiast /WS. IMAGECFG.exe można znaleźć na Windows CD-ROM NT 4.0 w SUPPORT\DEBUG\I386\IMAGECFG.EXE.
  • /WX Opcja łączenia (Traktuj ostrzeżenia linkera jako błędy) jest teraz udokumentowana.

Nowe funkcje narzędzia linkera

  • /ALLOWISOLATION Dodano opcję editbin
  • Instrukcja pliku definicji modułu DESCRIPTION została usunięta. Linker nie obsługuje już budowania sterowników urządzeń wirtualnych.
  • /ERRORREPORT Dodano opcję bscmake.exe, dumpbin.exe, editbin.exe i lib.exe.
  • /LTCG Dodano opcję lib.
  • /NXCOMPAT Dodano opcję editbin.
  • /RANGE Dodano opcję dumpbin.
  • /TLS Dodano opcję dumpbin.
  • /WS Opcja editbin została usunięta. /WSZostał użyty do modyfikowania obrazów docelowych Windows NT 4.0. IMAGECFG.exe -R można użyć zamiast /WS. IMAGECFG.exe można znaleźć na Windows CD-ROM NT 4.0 w SUPPORT\DEBUG\I386\IMAGECFG.EXE.
  • Dodano opcję lib /WX[:NO].

Nowe funkcje NMAKE

  • /ERRORREPORT został dodany.
  • /G został dodany.
  • Wstępnie zdefiniowane reguły zostały zaktualizowane.
  • Makro $(MAKE), które jest udokumentowane w makrach rekursji, teraz zapewnia pełną ścieżkę do nmake.exe.

Nowe funkcje MASM

  • Wyrażenia MASM są teraz wartościami 64-bitowych. W poprzednich wersjach wyrażenia MASM były wartościami 32-bitowych.
  • Instrukcja __asm int 3 powoduje teraz skompilowanie funkcji do natywnej.
  • Alias (MASM) jest teraz udokumentowany.
  • /ERRORREPORT ml.exe i ml64.exe zostanie dodana opcja .
  • . FPO jest teraz udokumentowane.
  • H2INC.exe nie zostanie Visual C++ 2005 r. Jeśli chcesz nadal używać H2INC, użyj H2INC.exe z poprzedniej wersji Visual C++.
  • Dodano operator IMAGEREL.
  • Dodano operator HIGH32.
  • Dodano operator LOW32.
  • ml64.exe to wersja masm dla architektury x64. Składa pliki asm x64 w pliki obiektów x64. Język zestawu wbudowanego nie jest obsługiwany w kompilatorze x64. Dodano następujące dyrektywy MASM dla ml64.exe (x64):
  • .ALLOCSTACK
  • .ENDPROLOG
  • .PUSHFRAME
  • .PUSHREG
  • .SAVEREG
  • .SAVEXMM128
  • . SETFRAME Ponadto dyrektywa PROC została zaktualizowana przy użyciu składni tylko x64.
  • Dodano dyrektywę MMWORD
  • /omf(ML.exe wiersza polecenia) oznacza teraz ./c ML.exe nie obsługuje łączenia obiektów formatu OMF.
  • Dyrektywa SEGMENT obsługuje teraz dodatkowe atrybuty.
  • Dodano operator SECTIONREL.
  • Dodano dyrektywę XMMWORD

Nowe funkcje CRT

  • Dodano bezpieczne wersje kilku funkcji. Te funkcje lepiej obsługują błędy i wymuszają bardziej rygorystyczne mechanizmy kontroli buforów, aby uniknąć typowych wad zabezpieczeń. Nowe bezpieczne wersje są identyfikowane za pomocą _s sufiksu.
  • Istniejące mniej bezpieczne wersje wielu funkcji zostały wycofane. Aby wyłączyć ostrzeżenia o wyłączeniu, zdefiniuj _CRT_SECURE_NO_WARNINGS.
  • Wiele istniejących funkcji weryfikuje teraz ich parametry i wywołuje nieprawidłowy program obsługi parametrów, gdy zostanie przekazany nieprawidłowy parametr.
  • Wiele istniejących funkcji jest teraz ustawionych errno tam, gdzie wcześniej nie były.
  • Dodano typedef errno_t z typem integer. errno_tJest używany za każdym razem, gdy funkcja zwraca typ lub parametr, który zawiera kody błędów z .errno errno_tZastępuje .errcode
  • Funkcje zależne od ustawień regionalnych mają teraz wersje, które zamiast używać bieżących ustawień regionalnych, przyjmą ustawienia lokalne jako parametr. Te nowe funkcje mają _l sufiks. Dodano kilka nowych funkcji do pracy z obiektami regionalnymi. Nowe funkcje to _get_current_locale, _create_locale i _free_locale.
  • Dodano nowe funkcje do obsługi blokowania i odblokowywania dojść do plików.
  • Rodzina _spawn funkcji nie resetuje błędu do zera w przypadku powodzenia, tak jak w poprzednich wersjach.
  • Wersje rodziny printf funkcji, które umożliwiają określenie kolejności, w której są używane argumenty są dostępne.
  • Unicode jest teraz obsługiwanym formatem tekstu. Funkcja obsługuje _open _O_TEXTW, _O_UTF8 i _O_UTF16 atrybutów. Funkcja fopen obsługuje metodę "ccs=ENCODING" określającą format Unicode.
  • Nowa wersja bibliotek CRT wbudowanych w kod zarządzany (MSIL) /clr jest teraz dostępna i jest używana podczas kompilowania za pomocą opcji (kompilacja środowiska uruchomieniowego języka wspólnego).
  • _fileinfo została usunięta.
  • Domyślny rozmiar pliku to time_t teraz 64 bity, time_t co rozszerza zakres funkcji i kilka funkcji czasu do roku 3000.
  • CRT obsługuje teraz ustawianie ustawień regionalnych dla każdego wątku. Funkcja została _configthreadlocale dodana w celu obsługi tej funkcji.
  • Funkcje _statusfp2 i __control87_2 zostały dodane w celu umożliwienia dostępu do zmiennoprzecinkowego słowa sterującego i kontrolowania go na procesorze zmiennoprzecinkowym x87 i SSE2.
  • Funkcje _mkgmtime i _mkgmtime64 zostały dodane w celu zapewnienia obsługi konwersji czasu (struct tm) na czas średni Greenwich (GMT).
  • W celu lepszego zachowania zgodności swprintf ze standardem w programie i vswprintf w wymuszono zmiany.
  • Nowy plik nagłówkowy INTRIN. H, udostępnia prototypy dla niektórych funkcji wewnętrznych.
  • Funkcja fopen ma teraz atrybut N.
  • Funkcja _open ma teraz atrybut _O_NOINHERIT .
  • Funkcja atoi zwraca teraz INT_MAX i ustawia wartość errno ERANGE w przypadku przepełnienia. W poprzednich wersjach zachowanie przepełnienia było niezdefiniowane.
  • Rodzina printf funkcji obsługuje szesnastkową zmiennoprzecinkową dane wyjściowe zaimplementowane zgodnie ze standardem ANSI C99 przy użyciu specyfikatorów typu formatu %a i %A.
  • Rodzina printf obsługuje teraz prefiks rozmiaru "ll" (długi).
  • Funkcja _controlfp została zoptymalizowana pod kątem lepszej wydajności.
  • Dodano wersje debugowania niektórych funkcji.
  • Dodano _chgsignl wartości i _cpysignl (długie wersje podwójne).
  • Dodano _locale_t typ do tabeli typów.
  • Dodano nowe _countof makro do obliczania liczby elementów w tablicy.
  • W każdym temacie funkcji dodano sekcję .NET Framework odpowiedników.
  • Kilka funkcji ciągów ma teraz opcję obcinania ciągów zamiast awarii, gdy bufory wyjściowe są zbyt małe; zobacz _TRUNCATE.
  • _set_se_translator Teraz wymaga użycia opcji /EHa kompilatora.
  • fpos_t Jest teraz __int64 w obszarze /Za (dla kodu C) i gdy centrum STDC jest ustawione ręcznie (dla kodu C++). Kiedyś był to .struct
  • _CRT_DISABLE_PERFCRIT_LOCKS może poprawić wydajność we/wy programów jednowątkowych.
  • Nazwy POSIX zostały wycofane na rzecz nazw zgodnych ze standardem ISO C++ ( _getch na przykład użyj nazwy zamiast getch).
  • Dla trybu czystego są dostępne nowe pliki obj opcji linku
  • _recalloc łączy funkcje i realloccalloc.

Co nowego w języku C++ w Visual Studio 2003

Compiler

  • Informacje na temat uruchamiania aplikacji Managed Extensions for C++ sbudowaną za pomocą kompilatora bieżącej wersji w poprzedniej wersji środowiska uruchomieniowego.
  • Managed Extensions for C++ często zadawane pytania.
  • Dodano przewodnik pokazujący sposób przenoszenia istniejącej, natywnej aplikacji do korzystania z usługi Managed Extensions for C++: Przewodnik: Przenoszenie istniejącej natywnej aplikacji C++ do współdziałania z .NET Framework Components.
  • Teraz możesz utworzyć delegata dla metody typu wartości.
  • Zgodność kompilatora ze standardem C++ została znacząco rozszerzona na platformę Visual C++ .NET 2003.
  • /arch dodano opcję kompilatora.
  • /Gf jest przestarzała i zostanie usunięty w następnej wersji Visual C++.
  • /G7 dodano opcję kompilatora.
  • Opcja /GS kompilatora została rozszerzona o ochronę zmiennych lokalnych przed bezpośrednim przepełnieniem buforu.
  • Opcja /noBool kompilatora została usunięta. Kompilator teraz pozwala pojawiać bool się tylko jako słowo kluczowe (a nie identyfikator) w pliku kodu źródłowego języka C++.
  • Typ long long jest teraz dostępny jako uwaga typedef__int64 , że long long w CRT nie jest jeszcze dostępna obsługa tego typu.
  • Opcja /Zm kompilatora określa teraz limit alokacji pamięci prekompilowanych nagłówków.
  • _InterlockedCompareExchange są teraz udokumentowane.
  • _InterlockedDecrement są teraz udokumentowane.
  • _InterlockedExchange są teraz udokumentowane.
  • _InterlockedExchangeAdd są teraz udokumentowane.
  • _InterlockedIncrement są teraz udokumentowane.
  • _ReadWriteBarrier dodano funkcje wewnętrzne.

Atrybuty

  • implements Atrybut jest teraz udokumentowany.

Funkcje łączenia

Dodano następujące przełączniki łączenia:

  • /ASSEMBLYDEBUG
  • /ASSEMBLYLINKRESOURCE
  • DELAYSIGN
  • /KEYFILE
  • /KEYCONTAINER
  • /SAFESEH

MASM

Tthe. Dodano dyrektywę /safeseh SAFESEH i ml.exe opcji.

Zobacz też

Przewodnik po przenoszeniu i uaktualnianiu pakietu Visual C++