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

Artykuł
03/21/2023

Ta strona zbiera wszystkie strony "Co nowego" dla wszystkich wersji programu Visual C++ z programu Visual Studio 2015 z powrotem do 2003 roku. Te informacje są dostarczane jako wygoda w przypadku, gdy może być przydatne podczas uaktualniania z wcześniejszych wersji programu Visual Studio.

Uwaga

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

Co nowego w języku C++ w programie Visual Studio 2015

W programie Visual Studio 2015 lub nowszym ciągłe ulepszenia zgodności kompilatora mogą czasami zmieniać sposób zrozumienia istniejącego kodu źródłowego przez kompilator. W takim przypadku podczas kompilacji mogą wystąpić nowe lub różne błędy, a nawet różnice behawioralne w kodzie, 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 małe i proste. Uwzględniliśmy wiele przykładów wcześniej akceptowalnego kodu źródłowego, które mogą wymagać zmiany (przed) i poprawek w celu ich skorygowania (po).

Chociaż te różnice mogą mieć wpływ na kod źródłowy lub inne artefakty kompilacji, nie mają wpływu na zgodność binarną między aktualizacjami wersji visual C++. Bardziej poważny rodzaj zmiany, zmiana powodująca niezgodność może mieć wpływ na zgodność binarną, ale tego rodzaju przerwy w zgodności binarnej występują tylko między głównymi wersjami programu Visual C++. Na przykład między językami Visual C++ 2013 i Visual C++ 2015. Aby uzyskać informacje na temat zmian powodujących niezgodność w programach Visual C++ 2013 i Visual C++ 2015, zobacz Historia zmian języka Visual C++ 2003 – 2015.

Ulepszenia zgodności w programie Visual Studio 2015
Ulepszenia zgodności w programie Visual Studio 2015 Update 1
Ulepszenia zgodności w programie Visual Studio 2015 Update 2
Ulepszenia zgodności w programie Visual Studio 2015 Update 3

Ulepszenia zgodności w programie Visual Studio 2015

/Zc:forScope- opcja

Opcja /Zc:forScope- kompilatora 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 ta była zwykle używana w celu zezwolenia na niestandardowy kod, który używa zmiennych pętli po punkcie, w którym, zgodnie ze standardem, powinny one zniknąć z zakresu. To było konieczne tylko wtedy, gdy kompilujesz z opcją /Za , ponieważ bez /Za, przy użyciu zmiennej for pętla po zakończeniu pętli jest zawsze dozwolone. Jeśli nie interesuje Cię zgodność ze standardami (na przykład jeśli kod nie jest przeznaczony do przenoszenia do innych kompilatorów), możesz wyłączyć /Za opcję (lub ustawić właściwość Wyłącz rozszerzenia językowe na Nie). Jeśli dbasz o pisanie przenośnego, zgodnego ze standardami kodu, należy 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 kompilatora /Zg (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 za pomocą języka C++/interfejsu wiersza polecenia z poziomu wiersza polecenia z plikiem mstest.exe. Zamiast tego użyj pliku vstest.console.exe
modyfikowalne słowo kluczowe.

Specyfikator mutable klasy magazynu nie jest już dozwolony w miejscach, w których wcześniej skompilowane bez błędu. Teraz kompilator zwraca błąd C2071 (nielegalna klasa magazynu). Zgodnie ze standardem specyfikator modyfikowalny może być stosowany tylko do nazw składowych danych klasy i nie można ich stosować do nazw zadeklarowanych jako const lub static i nie można ich zastosować do składowych odwołań.

Rozważmy na przykład następujący kod:
```
  struct S {
      mutable int &r;
  };
```
Poprzednie wersje kompilatora Microsoft C++ zaakceptowały to, ale teraz kompilator daje następujący błąd:
```
  error C2071: 'S::r': illegal storage class
```
Aby naprawić błąd, po prostu usuń nadmiarowe mutable słowo kluczowe.
char_16_t i char32_t

Nie można już używać char16_t aliasów ani char32_t jako aliasów w definicji typów, ponieważ te typy są teraz traktowane jako wbudowane. Często zdarzało się, że użytkownicy i autorzy bibliotek definiują char16_tchar32_t odpowiednio i jako aliasy uint16_t elementów i uint32_t.
```
  #include <cstdint>

  typedef uint16_t char16_t; //C2628
  typedef uint32_t char32_t; //C2628

  int main(int argc, char* argv[])
  {
  uint16_t x = 1; uint32_t y = 2;
  char16_t a = x;
  char32_t b = y;
  return 0;
  }
```
Aby zaktualizować kod, usuń typedef deklaracje i zmień nazwy innych identyfikatorów, które zderzają się z tymi nazwami.
Parametry szablonu innego niż typ

Określony kod, który obejmuje parametry szablonu innego niż typ, jest teraz poprawnie sprawdzany pod kątem zgodności typów po podaniu jawnych argumentów szablonu. Na przykład poniższy kod skompilowany bez błędu w poprzednich wersjach programu 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 poprawnie wyświetla błąd, ponieważ typ parametru szablonu nie jest zgodny z argumentem szablonu (parametr jest wskaźnikiem do elementu członkowskiego const, ale funkcja f jest inny niż const):
```
  error C2893: Failed to specialize function template 'void S2::f(void)'note: With the following template arguments:note: 'C=S1'note: 'Function=S1::f'
```
Aby rozwiązać ten błąd w kodzie, upewnij się, że typ używanego argumentu szablonu pasuje do zadeklarowanego typu parametru szablonu.
__declspec(align)

Kompilator nie akceptuje __declspec(align) już funkcji. To było zawsze ignorowane, ale teraz generuje 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 wpływu, usunięcie go nie zmienia.
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 programie Visual Studio 2013, ale nie jest kompilowany w programie Visual Studio 2015:
```
  struct S {
  public:
      S();
  private:
      S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Problem polega na tym, że konstruktor kopiujący jest prywatny, więc nie można skopiować obiektu w normalnym przebiegu obsługi wyjątku. To samo dotyczy, gdy konstruktor kopiujący 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.

Przechwycenie wyjątku według wartości wymaga również skopiowania obiektu wyjątku. Poniższy kod skompilowany w programie Visual Studio 2013, ale nie jest kompilowany w programie 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 catch dla odwołania.
```
  catch(D& d)
  {
  }
```
Literały ciągu, po których następują makra

Kompilator obsługuje teraz literały zdefiniowane przez użytkownika. W związku z tym literały ciągów, po których następują makra bez żadnych interweniujących białych znaków, są interpretowane jako literały zdefiniowane przez użytkownika, co może powodować błędy lub nieoczekiwane wyniki. Na przykład w poprzednich kompilatorach następujący kod został pomyślnie skompilowany:
```
  #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 łączone w jeden. W programie Visual Studio 2015 kompilator interpretuje to jako literał zdefiniowany przez użytkownika, ale ponieważ nie ma zgodnego literału zdefiniowanego przez użytkownika _x zdefiniowanego przez użytkownika, powoduje 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łem ciągu a makrem.
Sąsiadujące literały ciągu

Podobnie jak poprzednio, ze względu na powiązane zmiany w analizowaniu ciągów, sąsiadujące literały ciągu (szerokie lub wąskie literały ciągu) bez żadnych białych znaków zostały zinterpretowane jako pojedynczy połączony ciąg w poprzednich wersjach Visaul C++. W programie Visual Studio 2015 należy teraz dodać biały znak 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

Wprowadzono zmianę operatora delete w celu zapewnienia zgodności z standardem C++14. Szczegółowe informacje o zmianach standardów można znaleźć w artykule C++ Size Deallocation (Alokacja rozmiaru języka C++). Zmiany dodają postać operatora globalnego delete , który przyjmuje parametr rozmiaru. Zmiana powodująca niezgodność polega na tym, że jeśli wcześniej używano operatora delete z tym samym podpisem (aby odpowiadaćnowemu operatorowi umieszczania), zostanie wyświetlony błąd kompilatora (C2956, który występuje w momencie użycia nowego umieszczania, ponieważ jest to pozycja w kodzie, w którym kompilator próbuje zidentyfikować odpowiedni operator dopasowaniadelete).

Funkcja void operator delete(void *, size_t) była operatorem usuwania umieszczania odpowiadającym nowej funkcji void * operator new(size_t, size_t) umieszczania w języku C++11. W przypadku cofnięcia przydziału rozmiaru języka C++14 ta delete funkcja jest teraz zwykłą funkcją cofania transakcji (operator globalnydelete). Standard wymaga, aby jeśli użycie funkcji umieszczania nowego wyszukuje odpowiednią delete funkcję i znajduje zwykłą funkcję cofania, program jest źle sformułowany.

Załóżmy na przykład, że kod definiuje zarówno umieszczenie nowego, jak i usunięcie 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 rozmiaru delete globalnego. Zastanów się, czy można użyć innego typu niż size_t w przypadku dowolnego umieszczania nowych operatorów i delete . Należy pamiętać, że typ size_ttypedef obiektu jest zależny od kompilatora. Jest on przeznaczony typedef dla unsigned int języka Visual C++. Dobrym rozwiązaniem jest użycie wyliczonego typu, takiego jak:
```
  enum class my_type : size_t {};
```
Następnie zmień definicję umieszczania new i delete użyj tego typu jako drugiego argumentu size_tzamiast . Należy również zaktualizować wywołania, aby umieścić nowe , aby przekazać nowy typ (na przykład za pomocą polecenia static_cast<my_type> , aby przekonwertować wartość z liczby całkowitej) i zaktualizować definicję new i delete rzutować z powrotem do typu liczby całkowitej. Nie musisz używać elementu enum dla tego elementu; typ klasy z elementem size_t członkowskim również będzie działać.

Alternatywną rozwiązaniem jest możliwość całkowitego wyeliminowania umieszczania. Jeśli kod używa funkcji umieszczania nowego w celu zaimplementowania puli pamięci, w której argument umieszczania jest rozmiarem przydzielonego lub usuniętego obiektu, rozmiar funkcji cofania może być odpowiedni do zastąpienia własnego niestandardowego kodu 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 /Zc:sizedDealloc-kompilatora . Jeśli używasz tej opcji, funkcje dwóch argumentów delete nie istnieją i nie spowodują konfliktu z operatorem usuwania umieszczania.
Składowe danych unii

Składowe danych związków nie mogą już mieć typów odwołań. Poniższy kod został pomyślnie skompilowany w programie Visual Studio 2013, ale generuje błąd w programie 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 odwołań na wskaźnik lub wartość. Zmiana typu na wskaźnik wymaga zmian w kodzie, który używa pola unii. Zmiana kodu na wartość spowoduje zmianę danych przechowywanych 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 związki zawodowe

są teraz bardziej zgodne ze standardem. Poprzednie wersje kompilatora wygenerowały jawny konstruktor i destruktor dla anonimowych związków. Są one usuwane w programie Visual Studio 2015.

struct S {
    S();
};

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

Powyższy kod generuje następujący błąd w programie Visual Studio 2015:

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

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;

Związki z anonimowymi strukturami

Aby zachować zgodność ze standardem, zachowanie środowiska uruchomieniowego zmieniło się dla elementów członkowskich struktur anonimowych w związkach. Konstruktor dla anonimowych składowych struktury w unii nie jest już niejawnie wywoływany po utworzeniu takiego związku. Ponadto destruktor anonimowych składowych struktury w unii nie jest już niejawnie wywoływany, gdy związek wykracza poza zakres. Rozważ następujący kod, w którym unia U zawiera anonimową strukturę zawierającą składową, która jest nazwaną strukturą S, która ma destruktora.

  #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 programie Visual Studio 2013 konstruktor dla języka S jest wywoływany podczas tworzenia unii, a destruktor dla języka S jest wywoływany, gdy stos funkcji f jest czyszczony. Jednak w programie Visual Studio 2015 konstruktor i destruktor nie są wywoływane. Kompilator wyświetla ostrzeżenie dotyczące tej zmiany 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 środowiska uruchomieniowego struktur innych niż anonimowe 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;
  }

Alternatywnie spróbuj przenieść konstruktor i kod 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;
  }

Rozpoznawanie szablonu

Wprowadzono zmiany w rozpoznawaniu nazw dla szablonów. W języku C++, biorąc pod uwagę kandydatów do rozpoznawania nazwy, może się okazać, że co najmniej jedna nazwa uwzględniana jako potencjalne dopasowania powoduje utworzenie nieprawidłowego wystąpienia szablonu. Te nieprawidłowe wystąpienia zwykle nie powodują błędów kompilatora, czyli zasady znanej jako SFINAE (Niepowodzenie podstawiania nie jest błędem).

Jeśli teraz sfINAE wymaga, aby kompilator tworzył wystąpienie specjalizacji szablonu klasy, wszelkie błędy występujące podczas tego procesu to błędy kompilatora. W poprzednich wersjach kompilator zignorował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);
  }
```
Jeśli kompilujesz przy użyciu bieżącego kompilatora, wystąpi 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 faktu, że w momencie pierwszego wywołania is_base_of klasa "D" nie została jeszcze zdefiniowana.

W takim przypadku poprawka nie 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łówków, sprawdź kolejność instrukcji include dla plików nagłówków, aby upewnić się, że wszystkie definicje klas są kompilowane przed użyciem problematycznych szablonów.
Konstruktory kopii

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

Ulepszenia zgodności w programie Visual Studio 2015 Update 1

Prywatne wirtualne klasy bazowe i dziedziczenie pośrednie

Poprzednie wersje kompilatora pozwoliły klasie pochodnej wywoływać funkcje składowe 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 rezultacie wystawia 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 and operator delete

Poprzednie wersje kompilatora zezwalały na usunięcie operatora innego niż składowe nowego i innego niż składowe jako statyczne i zadeklarowane w przestrzeniach nazw innych niż globalna przestrzeń nazw. To stare zachowanie spowodowało ryzyko, że program nie będzie wywoływać implementacji operatora lub delete zamierzonej new przez programistę, co spowodowało dyskretne złe zachowanie środowiska uruchomieniowego. Kompilator nie akceptuje już kodu napisanego w ten sposób i zamiast tego wystawia 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 daje określonej diagnostyki, nowy operator wbudowany jest uznawany za źle sformułowany.
Wywoływanie metody "operator type()" (konwersja zdefiniowana przez użytkownika) w typach innych niż klasy Poprzednie wersje kompilatora zezwalały na wywoływanie typów innych niż klasy podczas dyskretnego ignorowania. To stare zachowanie spowodowało ryzyko dyskretnego generowania nieprawidłowego kodu, co spowodowało nieprzewidywalne zachowanie środowiska uruchomieniowego. Kompilator nie akceptuje już kodu napisanego w ten sposób i zamiast tego wystawia 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'
  }
```
Nadmiarowa nazwa typu w opracowanych specyfikatorach typów Poprzednie wersje kompilatora dozwolone typename w opracowanych 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 wystawia 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;
```

Potrącenie typów tablic z listy inicjatora Poprzednie wersje kompilatora nie obsługiwało potrącenia typu tablic z listy inicjatorów. Kompilator obsługuje teraz tę formę potrącenia typu, a w związku z tym wywołania szablonów funkcji przy użyciu list inicjatora mogą być teraz niejednoznaczne lub inne przeciążenie może zostać wybrane niż w poprzednich wersjach kompilatora. Aby rozwiązać te problemy, program musi teraz jawnie określić przeciążenie przeznaczone przez programistę.

Gdy to nowe zachowanie powoduje przeciążenie rozwiązania, aby rozważyć dodatkowego kandydata, który jest równie dobry jak kandydat historyczny, wywołanie staje się niejednoznaczne, a w rezultacie błąd kompilatora problemów kompilatora C2668.

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

Przykład 1: Niejednoznaczne wywołanie funkcji przeciążonej (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ążonej 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 przeciążenie rozpoznawania, aby rozważyć dodatkowego kandydata, który jest lepszym dopasowaniem niż kandydat historyczny, wywołanie rozwiązuje się jednoznacznie z nowym kandydatem, powodując zmianę zachowania programu, która prawdopodobnie różni się od zamierzonego przez programistę.

Przykład 2: zmiana rozdzielczości 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 rozdzielczości 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 wcześniej istniejące ostrzeżenia związane z switch instrukcjami. Te ostrzeżenia zostały przywrócone. Kompilator wystawia teraz przywrócone ostrzeżenia, a ostrzeżenia związane z określonymi przypadkami (w tym przypadek domyślny) są teraz wydawane w wierszu zawierającym przypadek naruszenia, a nie w ostatnim wierszu instrukcji switch. W wyniku teraz wydawania tych ostrzeżeń w różnych wierszach niż w przeszłości ostrzeżenia wcześniej pomijane przy użyciu #pragma warning(disable:####) mogą nie być już pomijane zgodnie z oczekiwaniami. Aby pominąć te ostrzeżenia zgodnie z oczekiwaniami, może być konieczne przeniesienie #pragma warning(disable:####) dyrektywy do wiersza powyżej pierwszej potencjalnie obraźliwej sprawy. 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 dokumentacji.

#include: używanie specyfikatora katalogu nadrzędnego ".". w nazwa_ścieżki (dotyczy /Wall/WXtylko )

Poprzednie wersje kompilatora nie wykryły użycia specyfikatora katalogu nadrzędnego ".". w ścieżce #include dyrektyw. Kod napisany w ten sposób jest zwykle przeznaczony do uwzględnienia nagłówków, które istnieją poza projektem, niepoprawnie używając ścieżek względnych projektu. To stare zachowanie spowodowało ryzyko kompilowania programu przez dołączenie innego pliku źródłowego 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ę o kodzie napisanym w ten sposób i wyświetla 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 daje określonej diagnostyki, zalecamy również, aby specyfikator katalogu nadrzędnego"." powinien być używany do określania katalogów dołączania projektu.
#pragma optimize() rozszerza poprzedni koniec pliku nagłówka (ma to wpływ tylko na /Wall/WX)

Poprzednie wersje kompilatora nie wykryły zmian ustawień flag optymalizacji, które unikną pliku nagłówka zawartego w jednostce tłumaczenia. Kompilator wykrywa teraz i powiadamia programistę o kodzie napisanym w ten sposób i wyświetla opcjonalne ostrzeżenie kompilatora C4426 w lokalizacji obiektu, #includejeśli jest włączone. To ostrzeżenie jest wyświetlane tylko wtedy, gdy zmiany powodują konflikt 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"
```

Niezgodność #pragma ostrzeżenie (wypychanie) i ostrzeżenie #pragma (tylko wpływa na /Wall/WX)

Poprzednie wersje kompilatora nie wykryły #pragma warning(push) zmian stanu sparowanych ze #pragma warning(pop) zmianami stanu w innym pliku źródłowym, który jest rzadko zamierzony. To stare zachowanie spowodowało ryzyko, że program zostanie skompilowany z innym zestawem ostrzeżeń włączonych niż zamierzony przez programistę, co może spowodować dyskretne złe zachowanie środowiska uruchomieniowego. Kompilator wykrywa teraz i powiadamia programistę o kodzie napisanym w ten sposób i wyświetla opcjonalne ostrzeżenie kompilatora C5031 w lokalizacji pasującego #pragma warning(pop)elementu , jeśli jest włączone. To ostrzeżenie zawiera notatkę odwołującą się do lokalizacji odpowiedniego #pragma warning(push)elementu .

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

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

Niedopasowane #pragma warning(push) (dotyczy /Wall/WXtylko )

Poprzednie wersje kompilatora nie wykryły niezgodnych #pragma warning(push) zmian stanu na końcu jednostki tłumaczenia. Kompilator wykrywa teraz i powiadamia programistę o kodzie napisanym w ten sposób i wyświetla opcjonalne ostrzeżenie kompilatora C5032 w lokalizacji niedopasowanego #pragma warning(push)elementu , jeśli jest włączone. To ostrzeżenie jest wyświetlane tylko wtedy, gdy w jednostce tłumaczenia nie występują błędy 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 ostrzeżenia #pragma

Poprzednie wersje kompilatora śledziły #pragma warning zmiany stanu w niewystarczającym stopniu, aby wyświetlać wszystkie zamierzone ostrzeżenia. To zachowanie spowodowało ryzyko efektywnego pomijania niektórych ostrzeżeń w sytuacjach innych niż zamierzony przez programistę. Kompilator śledzi #pragma warning teraz stan bardziej niezawodnie — szczególnie związane ze #pragma warning zmianami stanu wewnątrz szablonów — i opcjonalnie wyświetla nowe ostrzeżenia C5031 i C5032, które mają pomóc programisty zlokalizować niezamierzone zastosowania #pragma warning(push) elementów i #pragma warning(pop).

W wyniku ulepszonego #pragma warning śledzenia zmian stanu ostrzeżenia wcześniej nieprawidłowo pominięte lub ostrzeżenia związane z problemami, które były wcześniej błędnie diagnozowane, mogą być teraz wydawane.
Ulepszona identyfikacja kodu, który nie jest osiągalny

Zmiana standardowej biblioteki języka C++ i ulepszona możliwość wbudowanych wywołań funkcji w porównaniu z poprzednimi wersjami kompilatora może pozwolić kompilatorowi udowodnić, że określony kod jest teraz nieosiągalny. To nowe zachowanie może spowodować powstanie nowych i częściej wystawianych wystąpień ostrzeżenia C4720.
```
  warning C4720: unreachable code
```
W wielu przypadkach to ostrzeżenie może być wystawiane tylko podczas kompilowania z włączonymi optymalizacjami, ponieważ optymalizacje mogą wstawić więcej wywołań funkcji, wyeliminować nadmiarowy kod lub w inny sposób umożliwić ustalenie, że określony kod jest niemożliwy do osiągnięcia. Zaobserwowaliśmy, że w blokach try/catch często wystąpiły nowe wystąpienia ostrzeżenia C4720, szczególnie w odniesieniu do używania elementu 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
  }
```
pow(T, int) Usuwanie optymalizacji wyrejestrowywania

Poprzednie wersje standardowej biblioteki języka C++ zdefiniowały pow(T, int) szablon funkcji, który wyrejestrował pow wywołanie funkcji do serii operacji mnożenia. Ta technika spowoduje naliczanie dużej ilości niedokładności ze względu na charakter operacji zmiennoprzecinkowych, powodując wyniki końcowe, które mogą być znacznie niedokładne. W programie Visual Studio 2015 Update 1 to zachowanie zostało usunięte, aby uniknąć niezamierzonej utraty dokładności podczas korzystania z pow funkcji. Jednak ta wersja programu była znacznie szybsza pow niż poprawne obliczenie. Jeśli ta zmiana spowoduje znaczną regresję wydajności, a projekt nie wymaga dokładnych wyników zmiennoprzecinkowych (na przykład projekt jest już kompilowany z /fp:fast), rozważ zastąpienie wywołań do pow tej funkcji 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 identyczna z tym, co zostało uwzględnione w poprzednich wersjach programu Visual Studio.

Ulepszenia zgodności w programie 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 analizuje niektórych rodzajów wyrażeń wewnątrz decltype specyfikatorów z powodu braku obsługi wyrażenia SFINAE. 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ę wyrażenia SFINAE ze względu na ciągłe ulepszenia zgodności. W rezultacie kompilator wydaje teraz ostrzeżenia i błędy znalezione w wyrażeniach, które poprzednie wersje kompilatora nie zostały przeanalizowane.

Gdy to nowe zachowanie analizuje decltype wyrażenie zawierające typ, który nie został jeszcze zadeklarowany, kompilator wystawia błąd kompilatora C2039 w wyniku.
```
  error C2039: 'type': is not a member of 'global namespace'
```
Przykład 1: użycie typu niezadeklarowanego (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 {};
  }
```
Gdy to nowe zachowanie analizuje decltype wyrażenie, które nie ma niezbędnego użycia słowa kluczowego typename , aby określić, że nazwa zależna jest typem, kompilator wystawia 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 składowe uniemożliwiają niejawnie zdefiniowane konstruktory i operatory przypisania Poprzednie wersje kompilatora zezwoliły na klasę zawierającą volatile zmienne składowe, które mają domyślne konstruktory kopiowania/przenoszenia oraz domyślne operatory przypisania kopiowania/przenoszenia generowane automatycznie. To stare zachowanie było nieprawidłowe i nie jest zgodne ze standardem C++. Kompilator uwzględnia teraz klasę, która ma zmienne nietrwałe, aby mieć nietrywialne operatory konstrukcji i przypisania, które uniemożliwiają automatyczne generowanie domyślnych implementacji tych operatorów. Jeśli taka klasa jest członkiem unii (lub anonimowej unii wewnątrz klasy), konstruktory kopiowania/przenoszenia i operatory przypisania kopiowania/przenoszenia unii (lub klasy zawierającej nieonimną unię) będą niejawnie zdefiniowane jako usunięte. Próba skonstruowania lub skopiowania unii (lub klasy zawierającej anonimową unię) bez jawnego zdefiniowania ich jest błędem, a w rezultacie błąd kompilatora problemów 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 składowe nie obsługują kwalifikatorów cv.

Poprzednie wersje programu Visual C++ 2015 zezwalały na statyczne funkcje składowe z kwalifikatorami cv. To zachowanie jest spowodowane regresją w programach Visual C++ 2015 i Visual C++ 2015 Update 1; Visual C++ 2013 i poprzednie wersje języka Visual C++ odrzucają kod napisany w ten sposób. Zachowanie programów Visual C++ 2015 i Visual C++ 2015 Update 1 jest nieprawidłowe i nie jest zgodne ze standardem C++. Program Visual Studio 2015 Update 2 odrzuca kod napisany w ten sposób i zamiast tego zgłasza 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
```

Przekazywanie deklaracji wyliczenia nie jest dozwolone w kodzie WinRT (dotyczy /ZW tylko)

Kod skompilowany dla środowisko wykonawcze systemu Windows (WinRT) nie zezwala na enum deklarowanie typów, podobnie jak w przypadku kompilowania zarządzanego kodu C++ dla programu .Net Framework przy użyciu przełącznika kompilatora/clr. To zachowanie zapewnia, że rozmiar wyliczenia jest zawsze znany i może być poprawnie przewidywany system typów WinRT. Kompilator odrzuca kod napisany w ten sposób i wystawia 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 nienależące do elementu członkowskiego — nowy, a usuwanie operatora nie może być zadeklarowane w tekście (poziom 1 (/W1) domyślnie)

Poprzednie wersje kompilatora nie wydają ostrzeżenia, gdy funkcje usuwania operatorainnego niż składowe są deklarowane w tekście. Kod napisany w ten sposób jest źle sformułowany (bez wymaganej diagnostyki) i może powodować problemy z pamięcią wynikające z niezgodności nowych i usuniętych operatorów (szczególnie w przypadku użycia razem z przydziałem wielkości), które mogą być trudne do zdiagnozowania. Kompilator wydaje 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
  {
    ...
  }
```
Naprawienie kodu napisanego w ten sposób może wymagać przeniesienia definicji operatorów z pliku nagłówka i do odpowiedniego pliku źródłowego.

Ulepszenia zgodności w programie Visual Studio 2015 Update 3

std::is_convertable wykrywa teraz samozapisania (standardowej biblioteki) Poprzednie wersje std::is_convertable cech typu nie wykryły poprawnie samodzielnego przypisania typu klasy, gdy jego konstruktor kopiowania jest usuwany lub prywatny. std::is_convertable<>::value Teraz jest poprawnie ustawiana na false wartość , gdy jest stosowana do typu klasy z usuniętym lub prywatnym konstruktorem kopiowania.

Brak diagnostyki kompilatora skojarzonej z tą zmianą.

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 języka Visual C++statyczne asercji w dolnej części tego przykładu zostały przekazane, ponieważ std::is_convertable<>::value zostały niepoprawnie ustawione na true. std::is_convertable<>::value Teraz jest poprawnie ustawiona na falsewartość , co powoduje niepowodzenie asercji statycznych.
Domyślne lub usunięte trywialne kopiowanie i przenoszenie konstruktorów przestrzega specyfikatorów dostępu

Poprzednie wersje kompilatora nie sprawdzały specyfikatora dostępu domyślnego lub usuniętego trywialnego kopiowania i przenoszenia konstruktorów 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 spowodowało ryzyko dyskretnego generowania nieprawidłowego kodu, co spowodowało nieprzewidywalne zachowanie środowiska uruchomieniowego. Kompilator sprawdza teraz specyfikator dostępu domyślnego lub usuniętego trywialnego kopiowania i przenoszenia konstruktorów, aby określić, czy można go wywołać, a jeśli nie, wystawia 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);
  }
```

Wycofanie obsługi przypisanych kodów ATL (poziom 1 (/W1) domyślnie)

Poprzednie wersje kompilatora obsługiwały przypisany kod ATL. W następnej fazie usuwania obsługi przypisanego kodu ATL, który rozpoczął się w programie Visual C++ 2008, przypisany kod ATL został przestarzały. Kompilator wydaje teraz ostrzeżenie kompilatora C4467, aby ułatwić zidentyfikowanie tego rodzaju przestarzałego kodu.

  warning C4467: Usage of ATL attributes is deprecated

Jeśli chcesz nadal używać przypisanego kodu ATL do momentu usunięcia obsługi z kompilatora, możesz wyłączyć to ostrzeżenie, przekazując /Wv:18 argumenty wiersza polecenia lub /wd4467 do kompilatora lub dodając #pragma warning(disable:4467) 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 lub utworzenie pliku IDL w celu uniknięcia użycia przestarzałych atrybutów ATL, jak w przykładowym kodzie poniżej

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; Wygenerowany plik vc140.idl może sł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()
  };

Wstępnie skompilowane pliki nagłówka (PCH) i niedopasowane dyrektywy #include (mają wpływ tylko na /Wall/WX)

Poprzednie wersje kompilatora zaakceptowały #include niezgodność dyrektyw w plikach źródłowych między kompilacjami -Yc i -Yu podczas używania plików prekompilowanego nagłówka (PCH). Kod napisany w ten sposób nie jest już akceptowany przez kompilator. Kompilator wydaje teraz ostrzeżenie kompilatora CC4598, aby ułatwić identyfikowanie niezgodnych #include 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"
```
Wstępnie skompilowane pliki nagłówka (PCH) i niedopasowane katalogi dołączania (dotyczy /Wall/WXtylko )

Poprzednie wersje kompilatora zaakceptowały niezgodność argumentów wiersza polecenia dołączania (-I) do kompilatora między kompilacjami -Yc i -Yu podczas używania plików prekompilowanego nagłówka (PCH). Kod napisany w ten sposób nie jest już akceptowany przez kompilator. Kompilator wydaje teraz ostrzeżenie kompilatora CC4599, aby ułatwić identyfikację niezgodnych argumentów wiersza polecenia dołączania katalogu (-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 programie Visual Studio 2013

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

Compiler

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

Domyślne argumenty szablonu dla szablonów funkcji.
Delegowanie konstruktorów
Jawne operatory konwersji.
Listy inicjatorów i jednolita inicjalizacja.
Nieprzetworzone literały ciągu.
Szablony Wariadyczne.
Szablony aliasów.
Usunięte funkcje.
Inicjatory niestacjonowanych składowych danych (NSDMI).
Domyślne funkcje. *
Obsługuje te funkcje języka ISO C99:
_Bool
Literały złożone.
Wyznaczone inicjatory.
Mieszanie deklaracji z kodem.
Konwersja literału ciągu na wartości modyfikowalne może być niedozwolona przy użyciu nowej opcji kompilatora /Zc:strictStrings. W języku C++98 konwersja literałów ciągu na char* (a literały szerokiego ciągu do wchar_t*) 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ę umożliwiającą kontrolowanie konwersji. Domyślnie opcja jest wyłączona. Należy pamiętać, że jeśli używasz tej opcji w trybie debugowania, STL nie zostanie skompilowana.
rzutowania odwołań rvalue/lvalue. W przypadku odwołań rvalue język C++11 może wyraźnie odróżnić wartości lvalue i rvalues. Wcześniej kompilator nie dostarczył tego w określonych scenariuszach rzutowania. Dodano nową opcję kompilatora, /Zc:rvalueCastaby kompilator był zgodny z dokumentem roboczym języka C++ (patrz sekcja 5.4, [expr.cast]/1). Domyślne zachowanie, gdy ta opcja nie jest określona, jest taka sama jak w programie Visual Studio 2012.

Uwaga

W przypadku domyślnych funkcji używanie =default do żądania konstruktorów przenoszenia elementów członkowskich i operatorów przypisania przenoszenia nie jest obsługiwane.

Biblioteki C99

Deklaracje i implementacje są dodawane do 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, fenv.h i inttypes.h oraz implementacje dla wszystkich zadeklarowanych w nich funkcji. Istnieją nowe nagłówki otoki języka C++ (ccomplex, cfenv, cinttypes, ctgmath) i wiele innych są aktualizowane (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar i cwctype).

Standardowa biblioteka szablonów

Obsługa jawnych operatorów konwersji języka C++11, list inicjatorów, wyliczenia o określonym zakresie i szablonów wariadycznych. Wszystkie kontenery obsługują teraz wymagania dotyczące elementów szczegółowego języka C++11. Obsługa tych funkcji języka C++14:

"Przezroczyste operatory functors" mniej<>, większe<>, plus<>, mnożą<> itd.
<make_unique T>(args...) i make_unique<T[]>(n)
cbegin()/cend(), rbegin()/rend() i crbegin()/crend() funkcje inne niż składowe.
<atomic> otrzymał wiele ulepszeń wydajności.
<> type_traits otrzymał poważne poprawki stabilizacji 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ła zgodna z językiem C++11 i poprawnie kompilowana w programie Visual C++ w programie Visual Studio 2013.

Ulepszenia biblioteki Visual C++

Dodano zestaw SDK REST języka C++. Ma nowoczesną implementację usług REST w języku C++.
Obsługa tekstur C++ AMP jest rozszerzona. Obejmuje ona teraz obsługę map 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++

Automatycznie wektoryzator rozpoznaje teraz i optymalizuje więcej wzorców języka C++, aby przyspieszyć działanie kodu.
Ulepszenia jakości kodu mikro-architektury arm i platformy ARM.
__vectorcall jest dodawana konwencja wywoływania. Przekazywanie argumentów typu wektorów przy użyciu konwencji wywoływania __vectorcall do używania rejestrów wektorów.
Nowe opcje konsolidatora. Przełączniki /Gw (kompilatora) i /Gy (asemblera) umożliwiają optymalizacje konsolidatora w celu tworzenia chudszych plików binarnych.
Obsługa pamięci udostępnionej C++ AMP w celu zmniejszenia lub wyeliminowania kopiowania danych między procesorem CPU i procesorem GPU.

Ulepszenia optymalizacji z przewodnikiem profilu (PGO)

Ulepszenia wydajności wynikające z zmniejszenia zestawu roboczego aplikacji zoptymalizowanych przy użyciu infrastruktury PGO.
Nowe PGO na potrzeby tworzenia aplikacji środowisko wykonawcze systemu Windows.

Obsługa tworzenia aplikacji środowisko wykonawcze systemu Windows

Obsługa typów pól w strukturach wartości.

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

Język C++/CX obsługuje nowy model błędów systemu Windows, który umożliwia przechwytywanie i propagację zaawansowanych 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ć ciągi ToString w typach ref zdefiniowanych przez użytkownika środowisko wykonawcze systemu Windows.
Obsługa przestarzałych interfejsów API.

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

Obsługa debugowania międzyoperacyjnego/javaScript, diagnozowania wyjątków środowisko wykonawcze systemu Windows i debugowania kodu asynchronicznego (zarówno ś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 debugowania tylko mojego kodu.
Kategorie analizy kodu. Teraz możesz wyświetlić podzielone na kategorie dane wyjściowe z analizatora kodu, aby ułatwić znajdowanie i naprawianie wad kodu.
Diagnostyka XAML. Teraz możesz zdiagnozować problemy z czasem odpowiedzi interfejsu użytkownika i użyciem baterii w języku XAML.
Ulepszenia debugowania grafiki i procesora GPU.
Zdalne przechwytywanie i odtwarzanie na rzeczywistych urządzeniach.
Jednoczesne debugowanie języka C++ AMP i procesora CPU.
Ulepszona diagnostyka środowiska uruchomieniowego C++ AMP.
Debugowanie śledzenia cieniowania obliczeń HLSL.

Ulepszenia grafiki 3-W

Obsługa potoku zawartości obrazu dla wstępnie pomnożonego formatu DDS alfa.
Edytor obrazów używa wstępnie pomnożonej alfa do renderowania, a tym samym unika renderowania artefaktów, takich jak ciemne halo.
Edytory obrazów i modeli. Tworzenie filtru zdefiniowanego przez użytkownika jest teraz obsługiwane w funkcji Cieniowania Projektant w Edytorze obrazów i Edytorze modeli.

Środowisko IDE i produktywność

Ulepszone formatowanie kodu. Możesz zastosować więcej ustawień formatowania do kodu C++. Za pomocą tych ustawień można kontrolować umieszczanie nowych wierszy nawiasów klamrowych i słów kluczowych, wcięcia, odstępy i zawijanie wierszy. Kod jest automatycznie formatowany podczas wykonywania instrukcji i bloków oraz wklejania kodu do pliku.

Uzupełnianie nawiasów klamrowych. Kod języka C++ automatycznie uzupełnia znaki zamykające, które odpowiadają następującym znakom otwierającym:

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

Dodatkowe funkcje automatycznego uzupełniania języka C++.

Dodaje średnik dla typów klas.
Kończy nawiasy dla nieprzetworzonych literałów ciągów.
Kończy komentarze wielowierszowe (/* */)

Funkcja Znajdź wszystkie odwołania jest teraz automatycznie rozpoznawana i filtruje odwołania w tle po wyświetleniu listy dopasowań tekstowych.

Filtrowanie listy elementów członkowskich opartych na kontekście. Niedostępne elementy członkowskie są odfiltrowane 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 implementujący typ. Gdy lista elementów członkowskich jest otwarta, możesz nacisnąć klawisze Ctrl+J, aby usunąć jeden poziom filtrowania (dotyczy tylko bieżącego okna listy elementów członkowskich). Możesz ponownie nacisnąć klawisze Ctrl+J, aby usunąć filtrowanie tekstowe i pokazać każdy element członkowski.

Przewijanie parametrów. Wyświetlana sygnatura funkcji w etykietce narzędzia pomocy parametrów zmienia się teraz na podstawie liczby wpisana parametrów, a nie tylko wyświetlania dowolnego podpisu, a nie aktualizowania go na podstawie bieżącego kontekstu. Pomoc parametru działa również poprawnie, gdy jest on wyświetlany w funkcjach zagnieżdżonych.

Przełącz plik nagłówka/kodu. Teraz można przełączać się między nagłówkiem a odpowiadającym mu plikiem kodu przy użyciu polecenia w menu skrótów lub skrótu klawiaturowego.

Okno Właściwości projektu C++ z możliwością zmiany rozmiaru

Automatyczne generowanie kodu procedury obsługi zdarzeń w językach C++/CX i C++/CLI. Podczas pisania 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ę programu obsługi zdarzeń. Zostanie wyświetlone okno etykietki narzędzia, gdy kod obsługi zdarzeń może zostać wygenerowany automatycznie.

Ulepszenia rozpoznawania dpi. Ustawienie Rozpoznawanie dpi dla plików manifestu aplikacji obsługuje teraz ustawienie "Na monitor o wysokiej rozdzielczości DPI".

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

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

Co nowego w języku C++ w programie Visual Studio 2012

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 z ustawieniami std::vector domyślnymi skurczyła się z 16 bajtów w programie Visual Studio 2010 do 12 bajtów w programie Visual Studio 2012 i std::map zmniejszyła się z 16 bajtów w programie Visual Studio 2010 do 8 bajtów w programie Visual Studio 2012.
Zgodnie z wymaganiami standardu C++11 iteratory SCARY zostały zaimplementowane.

Inne ulepszenia języka C++11

Oparte na zakresie dla pętli. Można pisać bardziej niezawodne pętle, które działają z tablicami, kontenerami STL i kolekcjami środowisko wykonawcze systemu Windows w formularzu dla ( for-range-declaration : expression ). Jest to część obsługi języka podstawowego.
Bezstanowe lambdy, które są blokami kodu, które zaczynają się od pustego wprowadzenia lambda [] i przechwytywania żadnych zmiennych lokalnych, są teraz niejawnie konwertowane na wskaźniki funkcji zgodnie z wymaganiami standardu C++11.
Obsługa wyliczeń o określonym zakresie. Klucz wyliczenia klasy wyliczenia języka C++ jest teraz obsługiwany. Poniższy kod pokazuje, jak ten klucz wyliczenia różni się od poprzedniego zachowania wyliczenia.
```
enum class Element { Hydrogen, Helium, Lithium, Beryllium };
void func1(Element e);
func1(Hydrogen); // error C2065: 'Hydrogen' : undeclared identifier
func1(Element::Helium); // OK
```

Obsługa tworzenia aplikacji środowisko wykonawcze systemu Windows

Natywny model interfejsu użytkownika oparty na języku XAML. W przypadku aplikacji środowisko wykonawcze systemu Windows można użyć nowego natywnego modelu interfejsu użytkownika opartego na języku XAML.
Rozszerzenia składników Visual C++. Te rozszerzenia upraszczają użycie obiektów środowisko wykonawcze systemu Windows, które są niezbędną częścią aplikacji środowisko wykonawcze systemu Windows. Aby uzyskać więcej informacji, zobacz Plan działania dla aplikacji środowisko wykonawcze systemu Windows przy użyciu języka C++ i dokumentacji języka Visual C++ (C++/CX)
Gry DirectX. Możesz opracowywać atrakcyjne gry przy użyciu nowej obsługi directX dla aplikacji środowisko wykonawcze systemu Windows.
Interop XAML/DirectX. środowisko wykonawcze systemu Windows aplikacje korzystające zarówno z języka XAML, jak i DirectX, działają wydajnie.
środowisko wykonawcze systemu Windows tworzenie bibliotek DLL składników. Programowanie bibliotek DLL składników sprawia, że środowisko środowisko wykonawcze systemu Windows jest rozszerzalne.

Kompilator i konsolidator

Autowektory. Kompilator analizuje pętle w kodzie i, jeśli to możliwe, emituje instrukcje korzystające z rejestrów wektorów i instrukcji, które znajdują się we wszystkich nowoczesnych procesorach. Dzięki temu pętle działają szybciej. (Instrukcje procesora są znane jako SSE, dla rozszerzeń SIMD przesyłania strumieniowego). Nie musisz włączać ani żądać tej optymalizacji, ponieważ jest ona stosowana automatycznie.
Auto-parallelizer. Kompilator może analizować pętle w kodzie i emitować instrukcje, które rozkładają obliczenia na wiele rdzeni lub procesorów. Dzięki temu pętle będą działać szybciej. Należy zażądać tej optymalizacji, ponieważ nie jest ona domyślnie włączona. W wielu przypadkach pomaga dołączyć element #pragma loop(hint_parallel(N)) do kodu bezpośrednio przed pętlami, które mają zostać zrównane.
Auto-vectorizer i auto-parallelizer mogą współdziałać ze sobą, dzięki czemu obliczenia są rozłożone na wiele rdzeni, a kod na każdym rdzeniu używa rejestrów wektorów.

Nowość w programie Visual Studio 2012 Update 1

Docelowy system Windows XP podczas kompilowania kodu C++. Możesz użyć kompilatora i bibliotek języka Microsoft C++, aby kierować do systemów 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 z sprzętu równoległego danych, który jest zwykle obecny jako procesor GPU na dyskretnej karcie graficznej. Model programowania C++ AMP zawiera wielowymiarowe tablice, indeksowanie, transfer pamięci, tiling i bibliotekę funkcji matematycznych. Za pomocą rozszerzeń języka C++ AMP i ograniczeń kompilatora można kontrolować sposób przenoszenia danych z procesora CPU do procesora GPU i z powrotem.

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

Profilowanie. Obecnie istnieje obsługa profilowania dla działań procesora GPU opartych na języku C++ AMP i innych modelach programowania opartych na direct3D.

Ogólne ulepszenia programowania równoległego

Dzięki przejściu sprzętu do architektur wielordzeniowych i wielordzeniowych deweloperzy nie mogą już polegać na stale rosnących szybkościach zegara z pojedynczych rdzeni. Obsługa programowania równoległego w środowisku uruchomieniowym współbieżności umożliwia deweloperom korzystanie z tych nowych architektur. W programie Visual Studio 2010 wprowadzono zaawansowane biblioteki równoległości języka C++, takie jak biblioteka wzorców równoległych, wraz z funkcjami, które umożliwiają korzystanie z współbieżności przez wyrażanie zaawansowanych potoków przepływu danych. W programie Visual Studio 2012 biblioteki te zostały rozszerzone, aby zapewnić lepszą wydajność, większą kontrolę i bogatszą obsługę wzorców równoległych, których deweloperzy potrzebują najbardziej. Zakres oferty obejmuje teraz:

Rozbudowany model programowania oparty na zadaniach, który obsługuje asynchronię i kontynuacje.
Algorytmy równoległe, które obsługują równoległość łączenia rozwidlenia (parallel_for, parallel_for z koligacją, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
Kontenery bezpieczne współbieżności, które zapewniają bezpieczne wątkowo wersje struktur danych std, takich jak priority_queue, kolejka, wektor i mapa.
Biblioteka asynchronicznych agentów, której deweloperzy mogą używać do wyrażania potoków przepływu danych, które naturalnie rozkładają się na współbieżne jednostki.
Dostosowywalny harmonogram i menedżer zasobów ułatwiający płynną kompozycję wzorców na tej liście.

Ogólne ulepszenia debugowania równoległego

Oprócz okna Zadania równoległe i okna Stosy równoległe program Visual Studio 2012 oferuje nowe okno Do obejrzenia równoległego, dzięki czemu można zbadać wartości wyrażenia we wszystkich wątkach i procesach oraz przeprowadzić 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

Obsługa szablonów programu Visual Studio. Teraz możesz użyć technologii Szablony programu Visual Studio do tworzenia szablonów projektów i elementów języka C++.

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

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

Funkcja IntelliSense języka C++/CLI. 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 dla języka C++/CLI. Ponadto inne ulepszenia funkcji IntelliSense i środowiska IDE wymienione w tym dokumencie działają również dla języka C++/CLI.

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

Konstrukcje kodu języka C++. Kod szkieletowy jest dostępny dla przełącznika, if-else, dla pętli i innych podstawowych konstrukcji kodu, na liście rozwijanej Elementy członkowskie listy. 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 Członkowie listy jest wyświetlana automatycznie podczas pisania kodu w edytorze kodu. Wyniki są filtrowane, dzięki czemu podczas wpisywania są 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>tekstów C/C++>Advanced.

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

Wyróżnianie odwołań. Wybranie symbolu wyróżnia teraz wszystkie wystąpienia symbolu w bieżącym pliku. Naciśnij klawisze Ctrl+Shift Strzałka w+górę lub Ctrl+Shift+Strzałka w dół, aby przejść między wyróżnionymi odwołaniami. Tę funkcję można wyłączyć w oknie dialogowym Opcje w obszarze Edytor>tekstów C/C++>Advanced.

Narzędzia do zarządzania cyklem życia aplikacji

Analiza kodu statycznego

Analiza statyczna 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 oknie Analiza kodu 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 został wyzwolony komunikat, zostanie wyróżniony w edytorze kodu. W przypadku niektórych ostrzeżeń języka C++ komunikat wyświetla wiersze źródłowe, które pokazują ścieżkę wykonywania, która prowadzi do ostrzeżenia; punkty decyzyjne i powody podjęcia tej konkretnej ścieżki są wyróżnione. Analiza kodu jest uwzględniana w większości wersji programu Visual Studio 2012. W wersjach Professional, Premium i Ultimate wszystkie reguły są uwzględniane. W wersjach Express dla systemów Windows 8 i Windows Telefon są uwzględniane tylko najbardziej krytyczne ostrzeżenia. Analiza kodu nie jest uwzględniana w wersji Express dla sieci Web. Oto kilka innych ulepszeń analizy kodu:

Nowe ostrzeżenia współbieżności pomagają uniknąć błędów współbieżności, upewniając się, że używasz poprawnych dyscyplin blokujących w programach C/C++. Analizator wykrywa potencjalne warunki wyścigu, inwersje kolejności blokady, naruszenia kontraktu wywołującego/wywoływanego, niezgodne operacje synchronizacji i inne błędy współbieżności.
Możesz określić reguły języka C++, które mają być stosowane do przebiegów analizy kodu przy użyciu zestawów reguł.
W oknie Analiza kodu można wstawić do kodu źródłowego pragma, który pomija wybrane ostrzeżenie.
Możesz zwiększyć dokładność i kompletność analizy kodu statycznego przy użyciu nowej wersji języka adnotacji kodu źródłowego (SAL) firmy Microsoft, aby opisać sposób, w jaki funkcja używa jej parametrów, założeń, które ich dotyczy, oraz gwarancji, które sprawia, że po zakończeniu.
Obsługa 64-bitowych projektów C++.

Zaktualizowana struktura testów jednostkowych

Użyj nowej struktury testów jednostkowych języka C++ w programie Visual Studio, aby napisać testy jednostkowe języka C++. Dodaj nowy projekt testu jednostkowego do istniejącego rozwiązania C++, lokalizując szablon projektu testów jednostkowych języka C++ w kategorii Visual C++ w oknie dialogowym Nowy projekt. Rozpocznij pisanie testów jednostkowych w wygenerowanych TEST_METHOD wycinku kodu w pliku Unittest1.cpp. Po napisaniu kodu testowego skompiluj rozwiązanie. Jeśli chcesz uruchomić testy, otwórz okno Eksplorator testów jednostkowych, wybierając pozycję Wyświetl>inne Eksplorator testów jednostkowych systemu Windows>, a następnie w menu skrótów dla żądanego przypadku testowego wybierz pozycję Uruchom wybrany test. Po zakończeniu przebiegu testu można wyświetlić wyniki testu i dodatkowe informacje śledzenia stosu w tym samym oknie.

Wykresy zależności architektury

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

Eksplorator architektury

Za pomocą Eksploratora architektury możesz eksplorować zasoby w rozwiązaniu, projektach lub plikach języka C++. Na pasku menu wybierz pozycję Architektura Eksplorator architektury>systemu Windows>. Możesz wybrać interesujący Cię węzeł, na przykład Widok klasy. W tym przypadku po prawej stronie okna narzędzia zostanie rozwinięta lista przestrzeni nazw. W przypadku wybrania przestrzeni nazw nowa kolumna zawiera listę klas, struktur i wyliczenia w tej przestrzeni nazw. Możesz nadal eksplorować te zasoby lub wrócić do kolumny po lewej stronie, aby rozpocząć kolejne zapytanie. Zobacz Znajdowanie kodu za pomocą Eksploratora architektury.

Pokrycie kodu

Pokrycie kodu zostało zaktualizowane w celu dynamicznego instrumentowania plików binarnych w czasie wykonywania. Zmniejsza to obciążenie konfiguracji 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żesz 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ę Testuj>wyniki pokrycia kodu systemu Windows>.

Co nowego w języku C++ w programie Visual Studio 2010

Kompilator języka C++ i konsolidator

auto słowo kluczowe. Słowo auto kluczowe ma nowy cel. 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 .

decltype, specyfikator typu. Specyfikator decltype typu zwraca typ określonego wyrażenia. Użyj specyfikatora typu w połączeniu decltype ze słowem kluczowym, auto 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 typ zwracany 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 auto słowem kluczowym, aby zadeklarować zmienną, której typem jest lambda.

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 do zapisu bardziej wydajnych konstruktorów, funkcji i szablonów.

static_assert deklaracji. Deklaracja static_assert testuje asercję oprogramowania w czasie kompilacji, w przeciwieństwie do innych mechanizmów asercji testujących w czasie wykonywania. Jeśli potwierdzenie 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. Program MSVC umożliwia używanie słowa kluczowego nullptr z kodem natywnym lub kodem zarządzanym. Słowo nullptr kluczowe wskazuje, że uchwyt obiektu, wskaźnik wewnętrzny lub natywny typ wskaźnika nie wskazuje obiektu. Kompilator interpretuje nullptr kod zarządzany podczas korzystania z /clr opcji kompilatora i kodu natywnego /clr , gdy nie używasz opcji . Słowo kluczowe __nullptr specyficzne dla firmy Microsoft ma takie samo znaczenie jak nullptr, ale dotyczy tylko kodu natywnego. Jeśli kompilujesz natywny kod C/C++ przy użyciu /clr opcji kompilatora, kompilator nie może określić, czy nullptr słowo kluczowe jest natywne, czy zarządzane. Aby wyjaśnić intencję kompilatora, użyj słowa kluczowego nullptr, aby określić termin zarządzany i __nullptr, aby określić termin macierzysty .

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

Nowa opcja optymalizacji sterowanej profilem. Pogo Sejf Mode to nowa opcja optymalizacji sterowanej profilem, która umożliwia określenie, czy używać trybu bezpiecznego, czy trybu szybkiego podczas optymalizowania aplikacji. Sejf tryb jest bezpieczny wątkowo, ale jest wolniejszy niż tryb szybki. Tryb szybki jest zachowaniem domyślnym.

Nowa opcja środowiska uruchomieniowego języka wspólnego (CLR) /clr:nostdlib. Dodano nową opcję /clr (kompilacja środowiska uruchomieniowego języka wspólnego). Jeśli uwzględniono różne wersje tych samych bibliotek, zostanie wyświetlony błąd kompilacji. Nowa opcja umożliwia wykluczenie domyślnych bibliotek CLR, aby program mógł używać określonej wersji.

Nowa dyrektywa pragma detect_mismatch. Dyrektywa pragma detect_mismatch umożliwia umieszczenie tagu w plikach, które są porównywane z innymi tagami o tej samej nazwie. Jeśli istnieje wiele wartości dla tej samej nazwy, konsolidator wystawia błąd.

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

Projekty visual Studio C++ i system kompilacji

Msbuild. Rozwiązania i projekty Visual C++ są teraz kompilowane przy użyciu pliku MSBuild.exe, który zastępuje plik VCBuild.exe. Program MSBuild jest tym samym elastycznym, rozszerzalnym narzędziem kompilacji opartym na formacie XML, które jest używane przez inne języki i typy projektów programu Visual Studio. Ze względu na tę zmianę pliki projektu programu Visual Studio C++ używają teraz formatu pliku XML i mają rozszerzenie nazwy pliku vcxproj. Pliki projektu 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 poszczególnych projektów dla katalogów VC++. Użyj Menedżera właściwości i arkusza właściwości, aby ustawić globalne wartości dla katalogów VC++.

Zależności między projektami. We wcześniejszych wersjach zdefiniowane zależności między projektami były przechowywane w pliku rozwiązania. Po przekonwertowaniu tych rozwiązań 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łania 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 makr _SECURE_SCL i _HAS_ITERATOR_DEBUGGING.

Biblioteki Visual C++

Biblioteki środowiska uruchomieniowego współbieżności. Platforma środowiska uruchomieniowego współbieżności obsługuje aplikacje i składniki, które są uruchamiane jednocześnie, i jest strukturą do programowania współbieżnych aplikacji w programie Visual C++. W celu obsługi programowania współbieżnego aplikacji biblioteka równoległych wzorców (PPL) udostępnia kontenery ogólnego przeznaczenia i algorytmy do wykonywania precyzyjnego równoległości. Biblioteka agentów asynchronicznych udostępnia oparty na aktorach model programowania i interfejsy przekazywania komunikatów dla gruboziarnistego przepływu danych i zadań potokowych.

Standardowa biblioteka C++. Poniższa lista zawiera opis wielu zmian wprowadzonych w standardowej bibliotece języka 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. Przenoszenie semantyki i doskonałe przekazywanie znacznie poprawia wydajność operacji przydzielających lub przypisujących zmienne lub parametry.
Odwołania Rvalue są również używane do implementowania nowej unique_ptr klasy, która jest bezpieczniejszym typem inteligentnego auto_ptr wskaźnika niż klasa. Klasa unique_ptr jest wymienna, ale nie do kopiowania, implementuje semantyka ścisłej własności bez wpływu na bezpieczeństwo i dobrze współpracuje z kontenerami, które są świadomi odwołań rvalue. Klasa auto_ptr jest przestarzała.
Do nagłówka algorytmu <> dodano piętnaście nowych funkcji, find_if_notna przykład , copy_ifi is_sorted.
W nagłówku <pamięci> nowa funkcja make_shared jest wygodnym, niezawodnym i wydajnym sposobem na utworzenie współużytkowanego wskaźnika do obiektu.
Połączone listy singly są obsługiwane przez <nagłówek forward_list> .
Nowe cbeginfunkcje składowe , cend, crbegini crend zapewniają const_iterator funkcję, która przechodzi 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. exception_ptr Składowe klasy mogą 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 kodowanie.
<Nagłówek alokatorów> definiuje kilka szablonów, które ułatwiają przydzielanie i zwalnianie bloków pamięci dla kontenerów opartych na węzłach.
Istnieje wiele aktualizacji losowego> nagłówka<.

Biblioteka klas programu Microsoft Foundation (MFC)

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

Rozpoznawanie wielodotyku. MFC obsługuje aplikacje, które mają interfejs użytkownika wielodotykowy, na przykład aplikacje napisane dla systemu operacyjnego Microsoft Surface. Aplikacja wielodotykowa może obsługiwać komunikaty dotykowe i komunikaty gestów systemu Windows, które są kombinacjami komunikatów dotykowych. Wystarczy zarejestrować aplikację pod kątem zdarzeń dotyku i gestów, a system operacyjny będzie kierować zdarzenia wielodotykowe do programów obsługi zdarzeń.

Rozpoznawanie wysokiej rozdzielczości DPI. Domyślnie aplikacje MFC są teraz obsługujące wysoką rozdzielczość DPI. Jeśli aplikacja ma wartość High-DPI (wysoka liczba kropek 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 jest bardziej prawdopodobne, aby został poprawnie ułożony, a nie obcięty ani pikselowany.

Uruchom ponownie Menedżera. Menedżer ponownego uruchamiania automatycznie zapisuje dokumenty i ponownie uruchamia aplikację, jeśli nieoczekiwanie zostanie zamknięta lub ponownie uruchomiona. Można na przykład użyć menedżera ponownego uruchamiania, aby uruchomić aplikację po jej zamknięciu przez automatyczną aktualizację. Aby uzyskać więcej informacji na temat konfigurowania aplikacji pod kątem korzystania z menedżera ponownego uruchamiania, zobacz Instrukcje: Dodawanie obsługi menedżera ponownego uruchamiania.

Ctaskdialog. Klasę CTaskDialog można użyć zamiast standardowego AfxMessageBox pola komunikatu. Klasa CTaskDialog wyświetla i zbiera więcej informacji niż standardowe pole komunikatu.

Biblioteka SafeInt

Nowa biblioteka Sejf Int wykonuje bezpieczne operacje arytmetyczne, które stanowią przepełnienie całkowite. Ta biblioteka porównuje również różne rodzaje liczb całkowitych.

Nowe makra aktywnej biblioteki szablonów (ATL)

Nowe makra zostały dodane do usługi 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 identyfikator CLSID jest prawidłowy.

/analyze Warnings

Większość /analyze ostrzeżeń (Analiza kodu przedsiębiorstwa) została usunięta z bibliotek czasu wykonywania języka C (CRT), MFC i ATL.

Obsługa animacji i D2D

MFC obsługuje teraz animację i grafikę Direct2D. Biblioteka MFC ma kilka nowych klas i funkcji MFC do obsługi tej funkcji. Istnieją również dwa nowe przewodniki pokazujące, jak dodać obiekt D2D i obiekt animacji do projektu. Te przewodniki to przewodnik: dodawanie obiektu D2D do projektu MFC i przewodnik: dodawanie animacji do projektu MFC.

IDE

Ulepszona funkcja IntelliSense. Funkcja IntelliSense dla języka 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, środowisko IDE rozróżnia sposób, w jaki deweloper wyświetla i modyfikuje kod źródłowy oraz jak środowisko IDE używa kodu źródłowego i ustawień projektu do tworzenia rozwiązania. Ze względu na to rozdzielenie obowiązków funkcje przeglądania, takie jak Widok klasy i nowe okno dialogowe Przechodzenie do , są obsługiwane przez system oparty na nowym pliku bazy danych pulpitu programu SQL Server (sdf), który zastępuje stary plik przeglądania kompilacji (ncb). Funkcje IntelliSense, takie jak szybkie informacje, automatyczne uzupełnianie i Pomoc parametru, analizują jednostki tłumaczenia tylko wtedy, gdy jest to wymagane. Funkcje hybrydowe, takie jak nowe okno Hierarchii wywołań, używają kombinacji funkcji przeglądania i funkcji IntelliSense. Ponieważ funkcja IntelliSense przetwarza tylko wymagane w tej chwili informacje, środowisko IDE jest bardziej elastyczne. Ponadto, ponieważ informacje są bardziej aktualne, widoki IDE i okna są bardziej dokładne. Na koniec, ponieważ infrastruktura IDE jest lepiej zorganizowana, bardziej zdolna i bardziej 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 pod nimi czerwone faliste podkreślenia. Ponadto środowisko IDE zgłasza błędy funkcji IntelliSense w oknie Lista błędów. Aby wyświetlić kod powodujący problem, kliknij dwukrotnie błąd w oknie Lista błędów.

#include funkcja autouzupełniania. Środowisko IDE obsługuje automatyczne uzupełnianie dla słowa kluczowego #include . Po wpisaniu w #includeśrodowisku IDE zostanie utworzone pole listy rozwijanej prawidłowych plików nagłówkowych. Jeśli będziesz kontynuować, wpisując nazwę pliku, środowisko IDE filtruje 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 Przechodzenie do umożliwia wyszukiwanie wszystkich symboli i plików w projekcie, które pasują do określonego ciągu. Wyniki wyszukiwania są natychmiast zmieniane podczas wpisywania dodatkowych znaków w ciągu wyszukiwania. Pole Opinie o wynikach informuje o liczbie znalezionych elementów i pomaga zdecydować, czy ograniczyć wyszukiwanie. Pola Rodzaj/Zakres, Lokalizacja i Podgląd opinii ułatwiają uściślanie elementów o podobnych nazwach. Ponadto można rozszerzyć tę funkcję, aby obsługiwać inne języki programowania.

Debugowanie równoległe i profilowanie. Debuger programu Visual Studio zna środowisko uruchomieniowe współbieżności i ułatwia rozwiązywanie problemów z aplikacjami przetwarzania równoległego. Możesz użyć nowego narzędzia profilera współbieżności, aby zwizualizować 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 Projektant wstążki. Po utworzeniu pliku zasobu wstążki możesz zastąpić kod interfejsu użytkownika wstążki odręczną się kilkoma instrukcjami, które ładują zasób wstążki.

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

Narzędzia

Kreator klas MFC. Visual C++ 2010 przywraca dobrze uznane narzędzie Kreatora 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 kontrolek ATL. Kreator kontrolek ATL nie wypełnia już pola automatycznie ProgID . Jeśli kontrolka ATL nie ma ProgID, inne narzędzia mogą nie działać z nią. Jednym z przykładów narzędzia, które wymaga, aby kontrolki miały ProgID kontrolkę, jest okno dialogowe Wstawianie aktywnej kontrolki . Aby uzyskać więcej informacji na temat okna dialogowego, zobacz Wstawianie kontrolek ActiveX.

Microsoft Macro Assembler — odwołanie

Dodanie typu danych YMMWORD obsługuje 256-bitowe operandy multimedialne zawarte w instrukcjach Intel Advanced Vector Extensions (AVX).

Co nowego w języku C++ w programie Visual Studio 2008

Zintegrowane środowisko projektowe (IDE) visual C++

Okna dialogowe utworzone w aplikacjach ATL, MFC i Win32 są teraz zgodne z wytycznymi dotyczącymi stylu systemu Windows Vista. Podczas tworzenia nowego projektu przy użyciu programu Visual Studio 2008 wszystkie okna dialogowe wstawione do aplikacji będą zgodne z wytycznymi stylu systemu Windows Vista. Jeśli ponownie skompilujesz projekt utworzony przy użyciu starszej wersji programu Visual Studio, wszystkie istniejące okna dialogowe zachowają ten sam wygląd, jaki wcześniej miał. Aby uzyskać więcej informacji na temat wstawiania okien dialogowych do aplikacji, zobacz Edytor okien dialogowych.
Kreator projektu ATL ma teraz możliwość 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 projektu ATL są rejestrowane w węźle HKEY_CURRENT_USER rejestru, chyba że wybierzesz opcję Zarejestruj składnik dla wszystkich użytkowników.
Kreator projektu ATL nie oferuje już opcji tworzenia przypisanych projektów ATL. Począwszy od programu Visual Studio 2008, kreator projektu ATL nie ma możliwości zmiany stanu przypisanego nowego projektu. Wszystkie nowe projekty ATL tworzone przez kreatora są teraz nieprzydatne.
Zapisywanie w rejestrze można przekierować. Wraz z wprowadzeniem systemu Windows Vista pisanie do niektórych obszarów rejestru wymaga programu do uruchomienia w trybie podwyższonym uprawnień. Nie jest pożądane, aby zawsze uruchamiać program Visual Studio w trybie podwyższonego poziomu uprawnień. Przekierowywanie poszczególnych użytkowników automatycznie przekierowuje zapisy rejestru z HKEY_CLASSES_ROOT do HKEY_CURRENT_USER bez żadnych zmian programistycznych.
Klasa Projektant ma teraz ograniczoną obsługę natywnego kodu C++. We wcześniejszych wersjach programu Visual Studio klasa Projektant pracowała tylko z językami Visual C# i Visual Basic. Użytkownicy języka C++ mogą teraz używać Projektant klasy, ale tylko w trybie tylko do odczytu. Aby uzyskać więcej informacji na temat używania Projektant klasy w języku C++, zobacz Praca z kodem Visual C++ w Projektant klasy.
Kreator projektu nie ma już opcji utworzenia projektu C++ SQL Server. Począwszy od programu Visual Studio 2008, nowy kreator projektu nie ma możliwości utworzenia projektu C++ SQL Server. Projekty programu SQL Server utworzone przy użyciu starszej wersji programu Visual Studio będą nadal kompilować i działać poprawnie.

Biblioteki Visual C++

Ogólne

Aplikacje mogą być powiązane z określonymi wersjami bibliotek Visual C++. Czasami aplikacja zależy od aktualizacji, które zostały wprowadzone do bibliotek Visual C++ po wydaniu. W takim przypadku uruchomienie aplikacji na komputerze z wcześniejszymi wersjami bibliotek może spowodować nieoczekiwane zachowanie. Teraz można powiązać aplikację z określoną wersją bibliotek, aby nie była uruchamiana na komputerze, na którym jest wcześniejsza wersja bibliotek.

Biblioteka STL/CLR

Język Visual C++ zawiera teraz bibliotekę STL/CLR. Biblioteka STL/CLR jest pakietem standardowej biblioteki szablonów (STL), podzbiorem standardowej biblioteki C++ do użycia z językiem C++ i środowiskiem uruchomieniowym języka wspólnego programu .NET Framework (CLR). Dzięki funkcji STL/CLR można teraz używać wszystkich kontenerów, iteratorów i algorytmów biblioteki STL w środowisku zarządzanym.

Biblioteka MFC

System Windows Vista obsługuje typowe kontrolki. Dodano ponad 150 metod w 18 nowych lub istniejących klasach do obsługi funkcji w systemie Windows Vista lub w celu ulepszenia funkcjonalności w bieżących klasach MFC.
Nowa CNetAddressCtrl klasa umożliwia wprowadzanie i weryfikowanie adresów IPv4 i IPv6 lub nazw DNS.
Nowa CPagerCtrl klasa upraszcza korzystanie z kontrolki stronicowania systemu Windows.
Nowa CSplitButton klasa upraszcza korzystanie z kontrolki splitbutton systemu Windows w celu wybrania domyślnej lub opcjonalnej akcji.

Biblioteka obsługi języka C++

Język C++ wprowadza bibliotekę marshalingu. Biblioteka marshalingowa 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 używanie funkcji PInvoke. Aby uzyskać więcej informacji, zobacz Omówienie marshalingu w języku C++ .

Serwer ATL

Serwer ATL jest udostępniany jako współużytkowany projekt źródłowy.
Większość podstaw kodu serwera ATL została wydana jako udostępniony projekt źródłowy w programie CodePlex i nie jest zainstalowana w ramach programu Visual Studio 2008. Kilka plików skojarzonych z serwerem ATL nie jest już częścią programu Visual Studio. Aby uzyskać listę usuniętych plików, zobacz Usunięto pliki serwera ATL.
Klasy kodowania i dekodowania danych z biblioteki atlenc.h oraz funkcji narzędzi i klas 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ą uwzględnione we wcześniejszych wersjach programu Visual Studio, o ile te wersje programu 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.

Kompilator i konsolidator Visual C++

Zmiany kompilatora

Kompilator obsługuje zarządzane kompilacje przyrostowe. Po określeniu tej opcji kompilator nie będzie ponownie kompilować kodu w przypadku zmiany przywoływalnego zestawu. Zamiast tego wykona kompilację przyrostową. Pliki są ponownie komilowane 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 zwią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 mikroarchitektury Intel Core podczas generowania kodu. Domyślnie to dostrajanie jest włączone i nie można go wyłączyć, ponieważ pomaga również procesorom Pentium 4 i innym procesorom.
Funkcje wewnętrzne obsługują nowsze procesory AMD i Intel. Kilka nowych instrukcji wewnętrznych obsługuje większą funkcjonalność w nowszych procesorach AMD i Intel. Aby uzyskać więcej informacji na temat nowych funkcji wewnętrznych, zobacz Dodatkowe rozszerzenia SIMD 3, Streaming SIMD Extensions 4 Instructions, SSE4A and Advanced Bit Manipulation Elementy wewnętrzne, Funkcje wewnętrzne AES, _mm_clmulepi64_si128 i __rdtscp.
Funkcja __cpuid jest aktualizowana. Funkcje __cpuid, __cpuidex obsługują teraz kilka nowych funkcji z najnowszych wersji procesorów AMD i Intel. Funkcja wewnętrzna __cpuidex jest nowa i zbiera więcej informacji z ostatnich procesorów.
Opcja kompilatora /MP 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 kompilujących pliki jednocześnie. Ta opcja jest szczególnie przydatna na komputerach obsługujących wielowątkowość, wiele procesorów lub wiele rdzeni.
Opcja kompilatora /Wp64 i __w64 słowo kluczowe są przestarzałe. Opcja kompilatora /Wp64 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, która jest przeznaczona dla platformy 64-bitowej.
/Qfast_transcendentals generuje wbudowany kod dla funkcji transcend.
/Qimprecise_fwaits Usuwa polecenia fwait wewnętrzne, aby wypróbować bloki podczas korzystania z opcji kompilatora /fp:except .

Zmiany konsolidatora

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

Co nowego w języku C++ w programie Visual Studio 2005

W programie Visual C++ 2005 z dodatkiem Service Pack 1 wprowadzono następujące funkcje:

Funkcje wewnętrzne dla 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 architektury x64

__vmx_on
__vmx_vmclear
__vmx_vmlaunch
__vmx_vmptrld
__vmx_vmread
__vmx_vmresume
__vmx_vmwrite

Nowe słowa kluczowe języka

__sptr, __uptr

Nowe funkcje kompilatora

Kompilator zawiera zmiany powodujące niezgodność w tej wersji.

64-bitowe natywne i krzyżowe kompilatory.
/analyze Dodano opcję kompilatora (Analiza kodu w przedsiębiorstwie).
/bigobj Dodano opcję kompilatora.
/clr:pure, /clr:safei /clr:oldSyntax zostały dodane. (Później przestarzałe w programie Visual Studio 2015 i usunięte w programie Visual Studio 2017).
Przestarzałe opcje kompilatora: wiele opcji kompilatora zostało przestarzałych w tej wersji; Aby uzyskać więcej informacji, zobacz Przestarzałe opcje kompilatora.
Dwukrotne thunking w /clr kodzie jest zmniejszone; zobacz Double Thunking (C++), aby uzyskać więcej informacji.
/EH (Model obsługi wyjątków) lub /EHs nie można go już użyć do przechwycenia wyjątku, który jest zgłaszany z czymś innym niż zgłoszenie; użyj polecenia /EHa.
/errorReport Dodano opcję kompilatora (Zgłoś wewnętrzne błędy kompilatora).
/favor Dodano opcję kompilatora optymalizatora 64.
/FA/Fa Dodano opcję kompilatora (Lista plików).
/FC Dodano opcję kompilatora Pełna ścieżka pliku kodu źródłowego w diagnostyce.
/fp Dodano opcję kompilatora (Określ zachowanie zmiennoprzecinkowe).
/G (Optymalizowanie pod kątem procesora) Dodano opcję kompilatora opcji opcji.
/G (Optymalizowanie pod kątem procesora) Dodano opcję kompilatora opcji opcji.
/G3Usunięto opcje , /G4, /G7/G5/G6i /GB kompilatora. Kompilator używa teraz "modelu mieszanego", który próbuje utworzyć najlepszy plik wyjściowy dla wszystkich architektur.
/Gf został usunięty. Zamiast tego użyj /GF (eliminuj zduplikowane ciągi).
/GL(KtoTo le Program Optimization) jest teraz zgodny z /CLRHEADER.
/GR jest teraz domyślnie włączona.
/GS (Sprawdzanie zabezpieczeń buforu) zapewnia teraz ochronę zabezpieczeń dla parametrów wskaźnika podatnego na zagrożenia. /GS jest teraz domyślnie włączona. /GS teraz działa również na funkcjach skompilowanych do MSIL za pomocą /clr (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 możliwy do poprawiania).
Heurystyka funkcji wbudowanych została zaktualizowana; Aby uzyskać więcej informacji, zobacz inline, __forceinline__inlinei inline_depth
Dodano wiele nowych funkcji wewnętrznych, a wiele wcześniej nieudokumentowanych funkcji wewnętrznych zostało udokumentowanych.
Domyślnie każde wywołanie nowego, które kończy się niepowodzeniem, zgłosi wyjątek.
/ML opcje kompilatora /MLd zostały usunięte. Język Visual C++ nie obsługuje już obsługi bibliotek CRT połączonych statycznie z jednym wątkiem.
Kompilator zaimplementował optymalizację nazwanych wartości zwracanych, która jest włączona podczas kompilowania za pomocą /O1polecenia ( /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; noalias użyj modyfikatorów lub restrict__declspec , aby określić sposób tworzenia aliasów przez kompilator.
/Op Opcja kompilatora została usunięta. Zamiast tego użyj ( /fp określ zachowanie zmiennoprzecinkowe).
Protokół OpenMP jest teraz obsługiwany przez program Visual C++.
/openmp Dodano opcję kompilatora OpenMP 2.0.
/Ow Opcja kompilatora została usunięta, ale zostanie zignorowana w trybie dyskretnym. noalias Użyj modyfikatorów lubrestrict__declspec, aby określić sposób tworzenia aliasów przez kompilator.

Optymalizacje sterowane profilem

/QI0f został usunięty.
/QIfdiv został usunięty.
/QIPF_B Dodano opcję kompilatora Errata dla kroków procesora B.
/QIPF_C Dodano opcję kompilatora Errata for C CPU Stepping( Krokping) .
/QIPF_fr32 (Nie używaj górnej 96 rejestrów zmiennoprzecinkowych) dodano opcję kompilatora.
/QIPF_noPIC Dodano opcję kompilatora (Generuj kod zależny od położenia).
/QIPF_restrict_plabels (Przyjmij, że nie utworzono funkcji w czasie wykonywania) dodano opcję kompilatora.

Obsługa formatu Unicode w kompilatorze i konsolidatorze

/vd (Wyłącz przemieszczenia konstrukcji) teraz umożliwia użycie operatora dynamic_cast na konstruowaniu obiektu (/vd2)
/YX Opcja kompilatora została usunięta. Użyj /Yc (utwórz wstępnie skompilowany plik nagłówka) lub /Yu (zamiast tego użyj prekompilowanego pliku nagłówka). Jeśli usuniesz /YX z konfiguracji kompilacji i zastąpisz ją niczym, może to spowodować szybsze kompilacje.
/Zc:forScope jest teraz domyślnie włączona.
/Zc:wchar_t jest teraz domyślnie włączona.
/Zd Opcja kompilatora została usunięta. Informacje debugowania tylko numer wiersza nie są już obsługiwane. Zamiast tego użyj /Zi (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

Atrybutattribute jest teraz przestarzały.
appdomain__declspec Dodano modyfikator.
__clrcall dodano konwencję wywoływania.
przestarzały modyfikator deklaspec (C++) umożliwia teraz określenie ciągu, który będzie wyświetlany w czasie kompilacji, gdy użytkownik próbuje uzyskać dostęp do przestarzałej klasy lub funkcji.
dynamic_cast Operator ma zmiany powodujące niezgodność.
Wyliczenia natywne umożliwiają teraz określenie typu bazowego.
jitintrinsicdeclspec Dodano modyfikator.
noaliasdeclspec Dodano modyfikator.
process__declspec Dodano modyfikator.
abstrakcyjne, przesłonięcia 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++) zaktualizował zachowanie w odniesieniu do optymalizacji.

Nowe funkcje preprocesora

__CLR_VER dodane wstępnie zdefiniowane makro.
Pragma komentarza (C/C++) akceptuje /MANIFESTDEPENDENCY teraz jako komentarz konsolidatora. Opcja exestr komentarza jest teraz przestarzała.
embedded_idl atrybut ( #import dyrektywa) przyjmuje teraz opcjonalny parametr.
fenv_access Pragmy
float_control Pragmy
fp_contract Pragmy
Zmienne globalne nie zostaną zainicjowane w kolejności deklarowanej, jeśli masz zmienne globalne w sekcjach zarządzanych, niezarządzanych i niezarządzanych pragma. Jest to potencjalna zmiana powodująca niezgodność, jeśli na przykład niezarządzana zmienna globalna jest inicjowana za pomocą zarządzanych zmiennych globalnych, a w pełni skonstruowany obiekt zarządzany jest wymagany.
Sekcje określone przy użyciu init_seg są teraz tylko do odczytu, a nie do odczytu/zapisu, jak w poprzednich wersjach.
inline_depth wartość domyślna to teraz 16. Wartość domyślna 16 również obowiązywała w programie Visual C++ .NET 2003.
_INTEGRAL_MAX_BITS dodane wstępnie zdefiniowane makro, zobacz Wstępnie zdefiniowane makra.
_M_CEE, _M_CEE_PURE i _M_CEE_SAFE dodanych wstępnie zdefiniowanych makr, zobacz Wstępnie zdefiniowane makra.
_M_IX86_FP dodane wstępnie zdefiniowane makro.
_M_X64 dodane wstępnie zdefiniowane makro.
make_public Pragmy
managed, unmanaged zaktualizowano składnię pragma (teraz ma push i pop)
biblioteka mscorlib.dll jest teraz niejawnie przywołynięty przez #using dyrektywę we wszystkich /clr kompilacjach.
_OPENMP dodane wstępnie zdefiniowane makro.
optymalizacja pragma została zaktualizowana, a i w nie są już prawidłowymi parametrami.
dodano atrybut no_registry#import.
region, endregion dodano pragmas
_VC_NODEFAULTLIB dodane wstępnie zdefiniowane makro.
Makra Wariadyczne są teraz implementowane.
vtordisp jest przestarzały i zostanie usunięty w przyszłej wersji programu Visual C++.
Pragma warning ma teraz specyfikator pomijania.

Nowe funkcje konsolidatora

Moduły (pliki wyjściowe MSIL bez zestawu) są teraz dozwolone jako dane wejściowe konsolidatora.
/ALLOWISOLATION Dodano opcję konsolidatora 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ę konsolidatora Typu obrazu CLR.
/CLRSUPPORTLASTERROR Dodano opcję konsolidatora Zachowaj ostatni kod błędu dla wywołań PInvoke).
/CLRTHREADATTRIBUTE Dodano opcję konsolidatora clr thread attribute (Ustaw atrybut wątku CLR).
/CLRUNMANAGEDCODECHECK Dodano opcję konsolidatora Add SuppressUnmanagedCodeSecurityAttribute.
/ERRORREPORT Dodano opcję konsolidatora (Zgłoś wewnętrzne błędy konsolidatora).
/EXETYPE Opcja konsolidatora została usunięta. Konsolidator nie obsługuje już tworzenia sterowników urządzeń z systemami Windows 95 i Windows 98. Użyj odpowiedniego zestawu DDK, aby utworzyć te sterowniki urządzeń. Słowo kluczowe EXETYPE nie jest już prawidłowe dla plików definicji modułu.
/FUNCTIONPADMIN Dodano opcję konsolidatora Utwórz obraz z możliwością poprawiania dostępu.
/LTCG Opcja konsolidatora jest teraz obsługiwana w modułach skompilowanych za pomocą /clrpolecenia . /LTCG została również zaktualizowana w celu obsługi optymalizacji sterowanych profilem.
/MANIFEST Dodano opcję konsolidatora Create Side-by-Side Assembly Manifest (Utwórz manifest zestawu równoległego).
/MANIFESTDEPENDENCY Dodano opcję konsolidatora Określ zależności manifestu.
/MANIFESTFILE Dodano opcję konsolidatora (Nazwa pliku manifestu).
/MAPINFO:LINES Opcja konsolidatora została usunięta.
/NXCOMPAT Dodano opcję konsolidatora zgodnego z zapobieganiem wykonywaniu danych.
/PGD Dodano opcję konsolidatora Określ bazę danych dla optymalizacji sterowanej profilem.
/PROFILE Dodano opcję konsolidatora narzędzi wydajnościowych.
/SECTION (Określ atrybuty sekcji) opcja konsolidatora obsługuje teraz negację atrybutów i nie obsługuje już atrybutów L lub D (związanych z VxD).
Obsługa formatu Unicode w kompilatorze i konsolidatorze
/VERBOSE (Drukuj komunikaty postępu) opcja konsolidatora akceptuje teraz również elementy ICF i REF.
/VXD Opcja konsolidatora została usunięta. Konsolidator nie obsługuje już tworzenia sterowników urządzeń z systemami Windows 95 i Windows 98. Użyj odpowiedniego zestawu DDK, aby utworzyć te sterowniki urządzeń. Słowo kluczowe VXD nie jest już prawidłowe dla plików definicji modułu.
/WS Opcja konsolidatora została usunięta. /WS został użyty do modyfikowania obrazów przeznaczonych dla systemu Windows NT 4.0. IMAGECFG.exe -R nazwa pliku może być używana zamiast /WS. PLIK IMAGECFG.exe można znaleźć w pliku CD-ROM systemu Windows NT 4.0 w pliku SUPPORT\DEBUG\I386\IMAGECFG.EXE.
/WX (Traktuj ostrzeżenia konsolidatora jako błędy) opcja konsolidatora jest teraz udokumentowana.

Nowe funkcje narzędzi konsolidatora

/ALLOWISOLATION Dodano opcję editbin
Instrukcja pliku definicji modułu DESCRIPTION jest usuwana. Konsolidator nie obsługuje już tworzenia sterowników urządzeń wirtualnych.
/ERRORREPORT Dodano opcję do pliku 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. /WS został użyty do modyfikowania obrazów przeznaczonych dla systemu Windows NT 4.0. IMAGECFG.exe -R nazwa pliku może być używana zamiast /WS. PLIK IMAGECFG.exe można znaleźć w pliku CD-ROM systemu Windows NT 4.0 w pliku SUPPORT\DEBUG\I386\IMAGECFG.EXE.
Dodano opcję /WX[:NO] lib.

Nowe funkcje NMAKE

/ERRORREPORT dodano.
/G dodano.
Zaktualizowano wstępnie zdefiniowane reguły.
Makro $(MAKE), które zostało udokumentowane w makrach rekursji, teraz daje pełną ścieżkę do pliku nmake.exe.

Nowe funkcje masm

Wyrażenia MASM są teraz wartościami 64-bitowymi. W poprzednich wersjach wyrażenia MASM były wartościami 32-bitowymi.
Instrukcja __asm int 3 powoduje teraz skompilowanie funkcji natywnej.
ALIAS (MASM) jest teraz udokumentowany.
/ERRORREPORT Dodano opcję ml.exe i ml64.exe.
. Obiekt FPO jest teraz udokumentowany.
Plik H2INC.exe nie zostanie dostarczony w programie Visual C++ 2005. Jeśli musisz nadal używać H2INC, użyj pliku H2INC.exe z poprzedniej wersji programu Visual C++.
Dodano operator IMAGEREL.
dodano operator HIGH32.
dodano operator LOW32.
ml64.exe to wersja rozwiązania MASM dla architektury x64. Zestawuje pliki x64 .asm do plików obiektów x64. Wbudowany język zestawu 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 za pomocą składni tylko x64.
Dodano dyrektywę MMWORD
/omf (Opcja wiersza polecenia ML.exe) oznacza /cteraz . Plik 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 obsługują błędy w lepszy sposób i wymuszają bardziej rygorystyczne mechanizmy kontroli w buforach, aby uniknąć typowych wad zabezpieczeń. Nowe bezpieczne wersje są identyfikowane przez sufiks _s .
Istniejące mniej bezpieczne wersje wielu funkcji zostały przestarzałe. Aby wyłączyć ostrzeżenia o wycofaniu, zdefiniuj _CRT_SECURE_NO_WARNINGS.
Wiele istniejących funkcji weryfikuje teraz parametry i wywołuje nieprawidłową procedurę obsługi parametrów po przekazaniu nieprawidłowego parametru.
Wiele istniejących funkcji jest teraz ustawionych errno tam, gdzie nie były wcześniej.
Dodano definicję errno_t typu z liczbą całkowitą typu. errno_t jest używany za każdym razem, gdy funkcja zwraca typ lub parametr zajmuje się kodami błędów z errno. errno_terrcodezastępuje element .
Funkcje zależne od ustawień regionalnych mają teraz wersje, które przyjmują ustawienia regionalne jako parametr, a nie przy użyciu bieżących ustawień regionalnych. Te nowe funkcje mają sufiks _l . Dodano kilka nowych funkcji do pracy z obiektami ustawień regionalnych. Nowe funkcje to _get_current_locale, _create_locale i _free_locale.
Dodano nowe funkcje do obsługi blokady i odblokowywania dojść do plików.
_spawn Rodzina funkcji nie resetuje błędu do zera w przypadku powodzenia, podobnie jak w poprzednich wersjach.
printf Wersje rodziny funkcji, które umożliwiają określenie kolejności, w jakiej są używane argumenty.
Unicode jest teraz obsługiwanym formatem tekstu. Funkcja _open obsługuje atrybuty _O_TEXTW, _O_UTF8 i _O_UTF16. Funkcja fopen obsługuje metodę "ccs=ENCODING" określającą format Unicode.
Dostępna jest nowa wersja bibliotek CRT wbudowanych w kod zarządzany (MSIL) i jest używana podczas kompilowania za pomocą /clr opcji (kompilacja środowiska uruchomieniowego języka wspólnego).
_fileinfo został usunięty.
Domyślny rozmiar time_t wynosi teraz 64 bity, co rozszerza zakres i time_t kilka funkcji czasu do roku 3000.
CRT obsługuje teraz ustawianie ustawień regionalnych dla każdego wątku. Funkcja _configthreadlocale została dodana do obsługi tej funkcji.
Dodano _statusfp2 funkcje i __control87_2 , aby umożliwić dostęp do i kontrolę słowa sterowania zmiennoprzecinkowego zarówno na procesorze zmiennoprzecinkowym x87, jak i SSE2.
Dodano _mkgmtime funkcje i _mkgmtime64 w celu zapewnienia obsługi konwersji czasu (tm struktury) na Greenwich Mean Time (GMT).
Wprowadzono zmiany i swprintfvswprintf w celu lepszego zachowania zgodności ze standardem.
Nowy plik nagłówka INTRIN. H, udostępnia prototypy niektórych funkcji wewnętrznych.
Funkcja fopen ma teraz N atrybutu.
Funkcja _open ma teraz atrybut _O_NOINHERIT.
Funkcja atoi zwraca teraz INT_MAX i ustawia wartość errno ERANGE na przepełnienie. W poprzednich wersjach zachowanie przepełnienia było niezdefiniowane.
Rodzina printf funkcji obsługuje szesnastkowe dane wyjściowe zmiennoprzecinkowe zaimplementowane zgodnie ze standardem ANSI C99 przy użyciu specyfikatorów typów formatu %a i %A.
Rodzina printf obsługuje teraz prefiks "ll" (długi) rozmiar.
Funkcja _controlfp została zoptymalizowana pod kątem lepszej wydajności.
Dodano wersje debugowania niektórych funkcji.
Dodano _chgsignl i _cpysignl (długie podwójne wersje).
Dodano _locale_t typ do tabeli typów.
Dodano nowe makro makro _countof do obliczania liczby elementów w tablicy.
W każdym temacie funkcji dodano sekcję dotyczącą odpowiedników programu .NET Framework.
Kilka funkcji ciągów ma teraz możliwość obcinania ciągów, a nie kończy się niepowodzeniem, gdy bufory wyjściowe są zbyt małe; zobacz _TRUNCATE.
_set_se_translator teraz wymaga użycia opcji kompilatora /EHa .
fpos_t program jest teraz __int64 w obszarze /Za (dla kodu C) i gdy centrum stDC jest ustawione ręcznie (dla kodu C++). Kiedyś był to structelement .
_CRT_DISABLE_PERFCRIT_LOCKS może poprawić wydajność we/wy pojedynczych programów.
Nazwy POSIX zostały przestarzałe na rzecz nazw zgodnych ze standardem ISO C++ (na przykład zamiast _getchgetch).
Nowe opcje łącza .obj są dostępne dla trybu czystego
_recalloc łączy funkcje elementów realloc i calloc.

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

Compiler

Informacje na temat uruchamiania zarządzanych rozszerzeń dla aplikacji języka C++ skompilowanej przy użyciu kompilatora bieżącej wersji w poprzedniej wersji środowiska uruchomieniowego.
Rozszerzenia zarządzane dla języka C++ — często zadawane pytania.
Dodano przewodnik pokazujący sposób przenoszenia istniejącej aplikacji natywnej do używania rozszerzeń zarządzanych dla języka C++: Przewodnik: Przenoszenie istniejącej natywnej aplikacji C++ do współdziałania ze składnikami programu .NET Framework.
Teraz możesz utworzyć delegata w metodzie typu wartości.
Zgodność kompilatora ze standardem C++ została znacznie rozszerzona dla programu Visual C++ .NET 2003.
/arch Dodano opcję kompilatora.
/Gf jest przestarzały i zostanie usunięty w następnej wersji programu Visual C++.
/G7 Dodano opcję kompilatora.
Opcja kompilatora /GS została rozszerzona, aby chronić zmienne lokalne przed przepełnień buforu bezpośredniego.
Opcja kompilatora /noBool została usunięta. Kompilator umożliwia bool teraz wyświetlanie tylko jako słowa kluczowego (a nie identyfikatora) w pliku kodu źródłowego języka C++.
Typ long long jest teraz dostępny jako uwaga typedef__int64 , że nie ma jeszcze obsługi long long w CRT.
Opcja /Zm kompilatora określa teraz wstępnie skompilowany limit alokacji pamięci nagłówka.
_InterlockedCompareExchange wewnętrznie udokumentowane.
_InterlockedDecrement wewnętrznie udokumentowane.
_InterlockedExchange wewnętrznie udokumentowane.
_InterlockedExchangeAdd wewnętrznie udokumentowane.
_InterlockedIncrement wewnętrznie udokumentowane.
dodano _ReadWriteBarrier wewnętrzny.

Atrybuty

implements Atrybut jest teraz udokumentowany.

Funkcje konsolidatora

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

/ASSEMBLYDEBUG
/ASSEMBLYLINKRESOURCE
DELAYSIGN
/KEYFILE
/KEYCONTAINER
/SAFESEH

MASM

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

Zobacz też

Przewodnik po przenoszeniu i uaktualnianiu pakietu Visual C++