Udostępnij za pośrednictwem

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

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

  • /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 mstest.exe. Zamiast tego użyj vstest.console.exe

  • modyfikowalne słowo kluczowe.

    Specyfikator mutable klasy magazynu nie jest już dozwolony w miejscach, w których wcześniej 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że być stosowany do składowych zadeklarowanych jako const lub static, ani nie może być stosowany 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 ani char32_t jako aliasów w definicji typu, ponieważ te typy są teraz traktowane jako wbudowane. Często zdarzało się, że użytkownicy i autorzy bibliotek definiowali char16_t i char32_t jako aliasy odpowiednio dla uint16_t 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 stałego elementu członkowskiego, ale funkcja f nie jest 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 już __declspec(align) przy funkcjach. 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, jak ma to miejsce 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, aby obiekt wyjątku był możliwy do skopiowania. 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 na odniesienie.

      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ągowe, po których następują makra bez odstępów, są interpretowane jako literały zdefiniowane przez użytkownika, co może prowadzić do błędów lub nieoczekiwanych wyników. 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 rozwinięte do "there", a następnie oba literały ciągu zostały połą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 łańcucha znaków

    Podobnie jak poprzednio, ze względu na powiązane zmiany w analizowaniu ciągów, sąsiadujące literały ciągu (literały szerokiego lub wąskiego ciągu znaków) bez żadnych białych znaków zostały zinterpretowane jako pojedynczy połączony ciąg w poprzednich wersjach języka Visual 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 nowejw języku C++11. W przypadku dealokacji o określonym rozmiarze w C++14 ta funkcja delete jest teraz zwykłą funkcją dealokacji (globalny operator delete). Standard wymaga, aby jeśli użycie placement new wyszukuje odpowiednią delete funkcję i znajduje zwykłą funkcję dealokacji, program jest źle sformułowany.

    Załóżmy na przykład, że kod definiuje zarówno placement new, jak i placement delete.

      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 placement delete a nowym globalnym operatorem rozmiarowym delete. Zastanów się, czy można użyć innego typu niż size_t dla operatora placement new oraz operatorów 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ę rozmieszczenia new i delete tak, aby zamiast size_t używać tego typu jako drugiego argumentu. Należy również zaktualizować wywołania do placement new, aby przekazać nowy typ (na przykład, używając static_cast<my_type> do konwersji z wartości liczby całkowitej) oraz zaktualizować definicje new i delete do rzutowania z powrotem na typ 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ć.

    Alternatywnym rozwiązaniem jest całkowite wyeliminowanie placement new. 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 dwuargumentowe delete nie istnieją i nie spowodują konfliktu z Twoim operatorem umieszczania usuwania.

  • 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 wielkości wartości, może także zmienić rozmiar struktury 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;

  • Unie z anonimowymi strukturami

    Aby zachować zgodność ze standardem, zaszła zmiana w zachowaniu środowiska uruchomieniowego dla członków struktur anonimowych w uniach. Konstruktor dla anonimowych elementów w unii nie jest już wywoływany w sposób niejawny po utworzeniu takiej unii. Ponadto destruktor anonimowych elementów struktury w unii nie jest już niejawnie wywoływany, gdy unia opuszcza zakres. Rozważ następujący kod, w którym unia U zawiera anonimową strukturę, a w niej znajduje się składowa, będąca nazwaną strukturą S, która ma destruktor.

      #include <stdio.h>
  struct S {
      S() { printf("Creating S\n"); }
      ~S(){ printf("Destroying S\n"); }
  };
  union U {
      struct {
      S s;
  };
      U() {}
      ~U(){}
  };

  void f()
  {
      U u;
      // Destructor implicitly called here.
  }

  int main()
  {
      f();

      char s[1024];
      printf("Press any key.\n");
      gets_s(s);
      return 0;
  }

    W 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 instancje zwykle nie powodują błędów kompilatora, co jest zasadą znaną jako SFINAE (Niepowodzenie podstawiania nie jest błędem).

    Teraz, jeśli SFINAE wymaga, aby kompilator tworzył instancję specjalizacji szablonu klasy, to wszelkie błędy występujące podczas tego procesu są błędami 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 new zamierzonej delete 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'
  }

  • Zbędna nazwa typu w rozwiniętych specyfikatorach typów Poprzednie wersje kompilatora pozwalały na typename w rozwiniętych specyfikatorach typów; w ten sposób napisany kod 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;

  • Wnioskowanie typu tablic z listy inicjalizacyjnej Poprzednie wersje kompilatora nie obsługiwały wnioskowania typu tablic z listy inicjalizacyjnej. 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 rozwiązanie przeciążenia przez uwzględnienie dodatkowego kandydata, który lepiej pasuje niż kandydat historyczny, wywołanie jednoznacznie odwołuje się do nowego kandydata, co prawdopodobnie różni się od zamierzeń programisty.

    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 instrukcjami switch; zostały one teraz 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 dostępu do dyrektyw #include. Kod napisany w ten sposób zazwyczaj ma na celu użycie nagłówków poza projektem, przy czym używa niepoprawnie ścieżek względnych do 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() rozciąga się poza koniec pliku nagłówkowego (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 teraz wykrywa i powiadamia programistę o kodzie napisanym w ten sposób oraz wyświetla opcjonalne ostrzeżenie C4426 w miejscu problematycznym #include, jeś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 warning(push) i #pragma warning(pop) (dotyczy tylko /Wall/WX)

    Poprzednie wersje kompilatora nie wykrywały zmian stanu #pragma warning(push) sparowanych ze zmianami stanu #pragma warning(pop) w innym pliku źródłowym, co rzadko jest zamierzonym działaniem. 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 teraz wykrywa i powiadamia programistę o kodzie napisanym w ten sposób i, w lokalizacji pasującego #pragma warning(pop), wyświetla opcjonalne ostrzeżenie kompilatora C5031, jeśli ostrzeżenie 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 teraz wykrywa i powiadamia programistę o kodzie napisanym w ten sposób i, jeśli włączone, wyświetla opcjonalne ostrzeżenie kompilatora C5032 w lokalizacji niedopasowanego elementu #pragma warning(push). 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 niedostatecznie dobrze śledziły przesunięcia stanu, aby wydawać wszystkie zamierzone ostrzeżenia. To zachowanie stwarzało ryzyko, że niektóre ostrzeżenia będą faktycznie pomijane w okolicznościach innych niż te, które programista zamierzał. Kompilator teraz śledzi stan #pragma warning w bardziej złożony sposób — szczególnie w kontekście zmian stanu #pragma warning wewnątrz szablonów — i opcjonalnie wyświetla nowe ostrzeżenia C5031 i C5032, które mają pomóc programiście w lokalizowaniu niezamierzonych zastosowań elementów #pragma warning(push) i #pragma warning(pop).

    W wyniku ulepszonego #pragma warning śledzenia zmian stanu, teraz mogą być wydawane ostrzeżenia, które wcześniej były nieprawidłowo pomijane lub związane z problemami błędnie diagnozowanymi.

  • 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 rozwijania

    Poprzednie wersje standardowej biblioteki języka C++ definiowały pow(T, int) szablon funkcji, który rozwijał pow wywołanie funkcji do serii operacji mnożenia. Ta technika spowoduje duże niedokładności ze względu na charakter operacji zmiennoprzecinkowych, powodując znacznie niedokładne wyniki końcowe. 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 niż poprawne obliczenie pow. 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 wyrażenie decltype zawierające typ, który nie został jeszcze zadeklarowany, kompilator zgłasza błąd 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>()));
  };

  • volatile Zmienne składowe uniemożliwiają niejawnie zdefiniowane konstruktory i operatory przypisania Poprzednie wersje kompilatora zezwalały na klasę, która ma volatile zmienne składowe, aby mieć domyślne konstruktory kopiowania/przenoszenia i automatycznie generowane operatory przypisania kopiowania/przenoszenia. 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 odzwierciedlany w systemie 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 new i operator delete, które nie są członkami klasy, nie mogą być zadeklarowane inline (poziom 1 (/W1) domyślnie)

    Poprzednie wersje kompilatora nie wydają ostrzeżenia, gdy niezwiązane z klasą funkcje operatorów new i delete są występujące inline. 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

  • typu klasy, gdy jego konstruktor kopiowania jest usuwany lub prywatny. Teraz wartość std::is_convertable<>::value jest poprawnie ustawiana na false, gdy jest stosowana do typu klasy z prywatnym lub usuniętym 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 Visual C++, statyczne asercje w dolnej części tego przykładu przechodzą, ponieważ std::is_convertable<>::value zostało niepoprawnie ustawione na true. Teraz std::is_convertable<>::value jest poprawnie ustawione na false, co powoduje, że asercje statyczne zawodzą.

  • Domyślne albo usunięte trywialne konstruktory kopiujące i przenoszące przestrzegają specyfikatorów dostępu

    Poprzednie wersje kompilatora nie sprawdzały specyfikatora dostępu dla domyślnych lub usuniętych trywialnych konstruktorów kopiujących i przenoszących 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 teraz sprawdza specyfikator dostępu dla domyślnych lub usuniętych trywialnych konstruktorów kopiujących i przenoszących, aby określić, czy można je wywołać, a jeśli nie, wynikowo generuje ostrzeżenie kompilatora C2248.

      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 kodu ATL z atrybutami (domyślnie poziom 1 (/W1))

    Poprzednie wersje kompilatora obsługiwały przypisany kod ATL. W następnej fazie usuwania obsługi atrybutowanego kodu ATL, który rozpoczął się w programie Visual C++ 2008, atrybutowany kod ATL został oznaczony jako 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ć atrybutowanego kodu ATL, aż do momentu wycofania jego obsługi z kompilatora, możesz wyłączyć to ostrzeżenie, przekazując do kompilatora argumenty wiersza poleceń /Wv:18 lub /wd4467, albo dodając #pragma warning(disable:4467) w kodzie źródłowym.

    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żesz potrzebować lub chcieć utworzyć plik IDL, aby uniknąć użycia przestarzałych atrybutów ATL, jak pokazano 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 niezgodne dyrektywy #include w plikach źródłowych podczas kompilacji -Yc i -Yu przy użyciu prekompilowanych nagłówków (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 zawierające (dotyczy tylko /Wall/WX)

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

Kompilator

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).
  • Funkcje w stanie domyślnym. *
  • Obsługuje te funkcje języka ISO C99:
  • _Bool
  • Literały złożone.
  • Określone inicjalizatory.
  • Mieszanie deklaracji z kodem.
  • Przekształcanie literałów ciągu na wartości modyfikowalne można zablokować przy użyciu nowej opcji kompilatora /Zc:strictStrings. W C++98 konwersja z literałów ciągów na char* (a z literałów szerokich ciągów na wchar_t*) została oznaczona jako 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 w C++11, list inicjatorów, wyliczeń z zakresem oraz 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ątkach.

    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 nadpisać metodę ToString w zdefiniowanych przez użytkownika typach ref Windows Runtime.

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

    Publiczne interfejsy API środowiska wykonawczego systemu Windows można teraz oznaczyć jako przestarzałe i nadać im niestandardową wiadomość, która jest wyświetlana jako ostrzeżenie kompilacji i może zapewniać wskazówki dotyczące migracji.

  • Ulepszenia debugera.

    Obsługa debugowania współdziałania natywnego z JavaScript, diagnozowania wyjątków dla środowiska wykonawczego Windows oraz debugowania kodu asynchronicznego (zarówno dla środowiska wykonawczego 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 działania shadera obliczeniowego HLSL.

Ulepszenia grafiki 3D

  • Obsługa pipeline'u przetwarzania obrazów dla formatu DDS z wstępnie pomnożoną alfą.
  • 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 projektancie cieniowania 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ć rozmieszczanie nawiasów klamrowych i słów kluczowych na nowych wierszach, a także wcięcia, spacje oraz 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.
  • Uzupełnia nawiasy dla surowych 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 członków na podstawie kontekstu. Niedostępni członkowie są odfiltrowywani z list członków 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ąć Ctrl+J, aby usunąć jeden poziom filtrowania (dotyczy tylko bieżącego okna listy elementów członkowskich). Możesz ponownie nacisnąć 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ń. Okno podpowiedzi pojawia się, gdy kod obsługi zdarzeń może być wygenerowany automatycznie.

Ulepszenie obsługi 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, a w szczególności kolejne operacje, przeprowadzane są znacznie szybciej.

Efektywność czasu budowy. Liczne optymalizacje i wykorzystanie wielordzeniowe sprawiają, że kompilacje są szybsze, szczególnie w przypadku dużych projektów. Kompilacje przyrostowe dla aplikacji C++, które mają odwołania do C++ WinMD, są także 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 dozwoleniem (ale nie wymaganiem) 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 środowiska wykonawczego Windows w formie for ( 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. Klasa wyliczeniowa enum w C++ jest teraz obsługiwana. Poniższy kod pokazuje, jak ten klucz wyliczeniowy różni się od wcześniejszego zachowania wyliczeń.

    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ą korzystanie z obiektów Windows Runtime, które stanowią niezbędną część aplikacji Windows Runtime. 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. Aplikacje Windows Runtime, które wykorzystują zarówno XAML, jak i DirectX, teraz współpracują wydajnie.
  • Tworzenie bibliotek DLL składników środowiska uruchomieniowego Windows. Programowanie bibliotek DLL składników sprawia, że środowisko uruchomieniowe Windows jest rozszerzalne.

Kompilator i linker

  • 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-paralelizator. 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 chcesz zrównoleglić.
  • Auto-wektorizer i auto-paralelizator mogą współpracować ze sobą, dzięki czemu obliczenia są rozłożone na wiele rdzeni, a kod na każdym rdzeniu używa rejestrów wektorowych.

Nowość w programie Visual Studio 2012 Update 1

Celuj w Windows XP podczas kompilowania kodu C++. Możesz użyć kompilatora i bibliotek Microsoft C++, aby kompilować dla systemów Windows XP i Windows Server 2003.

Obsługa programowania równoległego

Przyspieszona Masowa Równoległość (AMP) C++

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.

Debugowanie. Środowisko debugowania dla aplikacji, które używają C++ AMP, aby docelować GPU, jest podobne do debugowania innych aplikacji w 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

Przy przejściu sprzętu na architektury wielordzeniowe i wielozadaniowe, deweloperzy nie mogą już polegać na ciągłym zwiększaniu się szybkości zegara pojedynczych rdzeni. Obsługa programowania równoległego w środowisku wykonawczym współbieżności umożliwia programistom 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ą schemat fork-join (parallel_for, parallel_for z koligacją, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
  • Kontenery odporne na współbieżność, które zapewniają bezpieczeństwo wątkowe w wersjach struktur danych std, takich jak priority_queue, queue, vector i map.
  • 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 Parallel Tasks i okna Parallel Stacks, program Visual Studio 2012 oferuje nowe okno Parallel Watch, dzięki czemu można sprawdzić 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.

IntelliSense C++/CLI. Język C++/CLI ma teraz pełną obsługę funkcji IntelliSense. Funkcje IntelliSense, takie jak Szybkie Info, Pomoc dotycząca parametrów, Lista członków 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 instrukcji przełącznika, if-else, pętli for i innych podstawowych konstrukcji kodu w rozwijanej liście Członkowie 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 członków listy. Lista rozwijana Członkowie jest wyświetlana automatycznie podczas pisania kodu w edytorze kodu. Wyniki są filtrowane, dzięki czemu podczas wpisywania są wyświetlani tylko odpowiedni użytkownicy. Możesz kontrolować rodzaj logiki filtrowania używanej przez listę elementów członkowskich — w oknie dialogowym Opcje w >

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 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 tekstu, C/C++, Zaawansowane.

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 Phone uwzględniono 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 swoich parametrów, założenia, które ich dotyczą, oraz gwarancje udzielane 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 wygenerowanym wycinku kodu TEST_METHOD w pliku Unittest1.cpp. Po napisaniu kodu testowego skompiluj rozwiązanie. Jeśli chcesz uruchomić testy, otwórz okno Eksploratora testów jednostkowych wybierając Widok>Inne okna>Eksplorator testów jednostkowych, a następnie w menu skrótów dla żądanego przypadku testowego wybierz 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ć grafy zależności dla plików binarnych, klas, przestrzeni nazw i plików dołączanych w rozwiązaniu. Na pasku menu wybierz Architektura>Generuj graf zależności, a następnie Dla rozwiązania lub Dla pliku dołączenia 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ć graf zależności dla plików dołączanych, w menu skrótów dla pliku kodu źródłowego *.cpp lub pliku nagłówkowego *.h wybierz pozycję Generuj graf zależności 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>systemu Windows>Eksplorator architektury. Możesz wybrać interesujący Cię węzeł, na przykład Widok klasy. W tym przypadku prawa strona okna narzędzia zostaje rozszerzona o listę przestrzeni nazw. Jeśli wybierzesz przestrzeń nazw, nowa kolumna pokaże listę klas, struktur i wyliczeń w tej przestrzeni nazw. Możesz nadal eksplorować te zasoby lub wrócić do kolumny po lewej stronie, aby rozpocząć kolejne zapytanie. Zobacz Znajdź kod 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ę Test>>.

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

Kompilator języka C++ i konsolidator

słowo kluczowe "auto" 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 kluczowe nullptr wskazuje, że uchwyt obiektu, wskaźnik wewnętrzny lub natywny typ wskaźnika nie wskazuje obiektu. Kompilator interpretuje nullptr jako kod zarządzany, kiedy używasz opcji kompilatora /clr, a jako kod natywny, gdy nie używasz opcji /clr. 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. PogoSafeMode to nowa opcja optymalizacji sterowanej profilem, która umożliwia określenie, czy używać trybu bezpiecznego, czy trybu szybkiego podczas optymalizowania aplikacji. Tryb awaryjny 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 dla tej samej nazwy istnieje wiele wartości, linker zgłasza 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, aby 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 MSBuild.exe, co zastępuje 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, jak i specyficzne dla konfiguracji, 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 referencja rvalue w języku C++ 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 przenośna, ale nie kopiowalna, implementuje semantykę ścisłej własności bez wpływu na bezpieczeństwo i dobrze współpracuje z kontenerami, które są świadome odwołań rvalue. Klasa auto_ptr jest przestarzała.
  • Do nagłówka algorytmu find_if_notcopy_if dodano piętnaście nowych funkcji, is_sortedna przykład , <i >.
  • 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 szybkiego dostępu, kartowe miniatury, 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ń.

Świadomość wysokiego DPI. Domyślnie aplikacje MFC są teraz zgodne z wysokimi rozdzielczościami 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 prawdopodobny do poprawnego wyświetlenia, nieprzycięty ani niepikselowany.

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 SafeInt wykonuje bezpieczne operacje arytmetyczne, które odpowiadają za 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 pozwalają na ustalenie funkcji zwrotnej w celu sprawdzenia, czy CLSID jest ważny.

/analyze Ostrzeżenia

Większość /analyze (Enterprise Code Analysis) ostrzeżeń została usunięta z bibliotek C Run-Time (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 Nawiguj Do, są obsługiwane przez system oparty na nowym pliku bazy danych desktopowej SQL Server (.sdf), który zastępuje stary plik przeglądania bez kompilacji (.ncb). Funkcje IntelliSense, takie jak Szybka Informacja, Automatyczne Uzupełnianie i Pomoc dotycząca parametrów, 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 wykrywanie błędów w 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 #include w środowisku IDE zostanie utworzone pole listy rozwijanej z prawidłowymi plikami nagłówkowymi. 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 zmieniają się natychmiast 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 pomagają rozróżniać elementy 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 projektanta 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 klasy 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ż automatycznie pola 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, jest okno dialogowe Wstawianie AKtywnej Kontroli. Aby uzyskać więcej informacji na temat okna dialogowego, zobacz Wstawianie kontrolek ActiveX.

Microsoft Macro Assembler — Dokumentacja

Wprowadzenie typu danych YMMWORD umożliwia obsługę 256-bitowych operandów multimedialnych, które są 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 nieprzypisane.

  • Zapisywanie do rejestru 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.

  • Projektant klas ma teraz ograniczoną obsługę natywnego kodu C++. We wcześniejszych wersjach programu Visual Studio projektant klas pracował tylko z językami Visual C# i Visual Basic. Użytkownicy języka C++ mogą teraz używać Projektanta klas, ale tylko w trybie tylko do odczytu. Aby uzyskać więcej informacji na temat korzystania z projektantaklas w języku C++, zobacz Praca z kodem Visual C++ w Projektancie klas.

  • 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 do serializacji zapewnia łatwy i zoptymalizowany sposób serializacji danych między środowiskami natywnymi i zarządzanymi. Biblioteka jest alternatywą dla bardziej złożonych i mniej wydajnych podejść, takich jak korzystanie z 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ęte 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.
  • Intrinsics 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 strumieniowe SIMD 3, Instrukcje Streaming SIMD Extensions 4, Instrukcje SSE4A i zaawansowaną manipulację bitami, 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 słowo kluczowe __w64 są przestarzałe. Opcja kompilatora /Wp64, jak również słowo kluczowe __w64, 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 linkera

  • Informacje o Kontroli Konta Użytkownika są teraz osadzone w plikach manifestów dla plików wykonywalnych przez linker języka 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 UAC w manifeście).
  • Konsolidator ma teraz opcję /DYNAMICBASE włączenia funkcji Randomizacji Układu Przestrzeni Adresowej w systemie 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

  • __stop
  • __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 w tej wersji zmiany powodujące niekompatybilność.

  • 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 już użyć do przechwycenia wyjątku, który jest zgłaszany z czymś innym niż rzutowanie; użyj /EHa.
  • /errorReport Dodano opcję kompilatora (Zgłoś wewnętrzne błędy kompilatora).
  • /favor Dodano opcję kompilatora optymalizatora 64.
  • /FA /Fa Dodano opcję kompilatora (plik listingu).
  • /FC Dodano opcję kompilatora dla pełnej ścieżki pliku kodu źródłowego w diagnostyce.
  • /fp Dodano opcję kompilatora (Określ zachowanie zmiennoprzecinkowe).
  • /G (Optymalizowanie pod kątem procesora) Dodano opcję kompilatora.
  • /G (Optymalizowanie pod kątem procesora) Dodano opcję kompilatora.
  • /G3, /G4, /G5, /G6, /G7 i /GB opcje kompilatora zostały usunięte. 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 (Optymalizacja całego programu) jest teraz kompatybilna 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.
  • Dodano opcję kompilatora /hotpatch (Utwórz obraz przeznaczony do hotpatchowania).
  • Heurystyka funkcji wbudowanej została zaktualizowana; zobacz inline, __inline, __forceinline i inline_depth aby uzyskać więcej informacji.
  • Dodano wiele nowych funkcji wewnętrznych, a wiele wcześniej nieudokumentowanych funkcji wewnętrznych zostało udokumentowanych.
  • Domyślnie każde wywołanie funkcji new, 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ż bibliotek CRT połączonych statycznie i jednowątkowo.
  • Kompilator zaimplementował optymalizację nazwanych wartości zwracanych, która jest włączona przy kompilacji z /O1, /O2 (Minimalizuj rozmiar, Maksymalizuj szybkość), /Og (Optymalizacje globalne) i /Ox (Pełna optymalizacja).
  • /Oa Opcja kompilatora została usunięta, ale zostanie zignorowana bez komunikatu; użyj modyfikatorów noalias lub restrict__declspec, aby określić sposób aliacji przez kompilator.
  • /Op Opcja kompilatora została usunięta. Użyj /fp (określ zachowanie zmiennoprzecinkowe) zamiast tego.
  • Protokół OpenMP jest teraz obsługiwany przez program Visual C++.
  • /openmp Dodano opcję kompilatora obsługującą OpenMP 2.0.
  • /Ow Opcja kompilatora została usunięta, ale zostanie zignorowana w trybie dyskretnym. Użyj modyfikatorów noalias lub restrict__declspec, aby określić sposób aliasowania 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

  • Atrybut 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.
  • abstrakcyjny, przesłonić i zamknięty 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++) teraz akceptuje /MANIFESTDEPENDENCY jako komentarz linkera. Opcja exestr dodawania komentarzy jest teraz przestarzała.
  • embedded_idl atrybut ( #import dyrektywa) przyjmuje teraz opcjonalny parametr.
  • fenv_access pragma
  • float_control pragma
  • fp_contract pragma
  • 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 przez zarządzaną zmienną globalną, a wymagany jest w pełni skonstruowany obiekt zarządzany.
  • 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.
  • Dodano wstępnie zdefiniowane makro _INTEGRAL_MAX_BITS, patrz Wstępnie zdefiniowane makra.
  • _M_CEE, _M_CEE_PURE i _M_CEE_SAFE dodanych wstępnie zdefiniowanych makr, zobacz Wstępnie zdefiniowane makra.
  • Wstępnie zdefiniowane makro _M_IX86_FP zostało dodane.
  • _M_X64 dodane wstępnie zdefiniowane makro.
  • make_public pragma
  • managed, unmanaged zaktualizowano składnię pragma (teraz ma push i pop)
  • mscorlib.dll jest teraz niejawnie przywołyny przez #using dyrektywę we wszystkich /clr kompilacjach.
  • Dodano wstępnie zdefiniowane makro _OPENMP.
  • 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 tłumienia.

Nowe funkcje konsolidatora

  • Moduły (pliki wyjściowe MSIL, które nie są częścią zestawu) są teraz dozwolone jako dane wejściowe dla linkera.
  • /ALLOWISOLATION Dodano opcję linkera "Manifest Lookup".
  • /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: Określ Typ 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ę linkera Add SuppressUnmanagedCodeSecurityAttribute.
  • /ERRORREPORT Dodano opcję konsolidatora (Zgłoś wewnętrzne błędy konsolidatora).
  • /EXETYPE opcja konsolidatora została usunięta. Linker nie obsługuje już tworzenia systemowych sterowników dla 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ę linkera zgodnego z zapobieganiem wykonywaniu danych.
  • /PGD Została dodana opcja linkera "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 linker akceptuje teraz również ICF i REF.
  • /VXD opcja konsolidatora została usunięta. Linker nie obsługuje już tworzenia systemowych sterowników dla 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. IMAGECFG.exe można znaleźć na dysku CD-ROM systemu Windows NT 4.0 w obszarze 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 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. IMAGECFG.exe można znaleźć na dysku CD-ROM systemu Windows NT 4.0 w obszarze 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 jest udokumentowane w makrach rekursji, teraz daje pełną ścieżkę do 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.
  • .FPO jest teraz udokumentowane.
  • H2INC.exe nie będzie dostarczany w programie Visual C++ 2005. Jeśli musisz nadal używać H2INC, użyj H2INC.exe z poprzedniej wersji programu Visual C++.
  • Został dodany operator IMAGEREL.
  • Operator HIGH32 został dodany.
  • 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 (ML.exe opcja wiersza polecenia) teraz oznacza /c. ML.exe nie obsługuje łączenia obiektów formatu OMF.
  • Dyrektywa SEGMENT obsługuje teraz dodatkowe atrybuty.
  • Został dodany 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, aby uniknąć powszechnych luk w zabezpieczeniach. 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 teraz weryfikuje swoje parametry i uruchamia procedurę obsługi nieprawidłowych parametrów, gdy zostanie przekazany nieprawidłowy parametr.
  • Wiele istniejących funkcji jest teraz ustawionych errno tam, gdzie nie były wcześniej.
  • Dodano typedef errno_t typu liczba całkowita. errno_t jest używany za każdym razem, gdy typ zwracany funkcji lub parametr dotyczą kodów błędów z errno. errno_t zastępuje errcode.
  • Funkcje zależne od ustawień regionalnych mają teraz wersje, które przyjmują te ustawienia jako parametr zamiast używać 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 wartości errno do zera w przypadku powodzenia, w przeciwieństwie do poprzednich wersji.
  • 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 zbudowanych w zarządzanym kodzie (MSIL) i jest ona używana podczas kompilowania z opcją /clr (z użyciem środowiska uruchomieniowego języka wspólnego).
  • _fileinfo został usunięty.
  • Domyślny rozmiar time_t wynosi teraz 64 bity, co rozszerza zakres time_t oraz kilku 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 funkcje _statusfp2 i __control87_2, aby umożliwić dostęp do i kontrolę słowa sterującego zmiennoprzecinkowego zarówno na procesorze zmiennoprzecinkowym x87, jak i SSE2.
  • Dodano funkcje _mkgmtime i _mkgmtime64 w celu zapewnienia obsługi konwersji struktury tm na czas uniwersalny (GMT).
  • Wprowadzono zmiany w swprintf i vswprintf dla lepszej 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.
  • Teraz funkcja atoi zwraca INT_MAX i ustawia errno na ERANGE w przypadku przepełnienia. 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, gdy bufory wyjściowe są zbyt małe, zamiast kończyć się niepowodzeniem; zobacz _TRUNCATE.
  • _set_se_translator teraz wymaga użycia opcji kompilatora /EHa .
  • fpos_t jest teraz __int64 w ramach /Za (dla kodu C) i gdy __STDC__ jest ustawione ręcznie (dla kodu C++). Kiedyś był to structelement .
  • _CRT_DISABLE_PERFCRIT_LOCKS może poprawić wydajność we/wy programów jednowątkowych.
  • Nazwy POSIX zostały wycofane na rzecz nazw zgodnych ze standardem ISO C++ (na przykład użyj _getch zamiast getch).
  • Nowe opcje łączenia plików .obj są dostępne w trybie czystym
  • _recalloc łączy funkcje elementów realloc i calloc.

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

Kompilator

  • 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 na 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 typedef z __int64. Należy zauważyć, że nie ma jeszcze wsparcia dla long long w CRT.
  • Opcja /Zm kompilatora określa teraz wstępnie skompilowany limit alokacji pamięci nagłówka.
  • _InterlockedCompareExchange funkcja wewnętrzna została teraz udokumentowana.
  • Dokumentacja dla funkcji wbudowanej _InterlockedDecrement została opublikowana.
  • _Funkcja _InterlockedExchange została teraz udokumentowana.
  • _InterlockedExchangeAdd wewnętrznie udokumentowane.
  • _Funkcja wbudowana _InterlockedIncrement została udokumentowana.
  • Dodano funkcję wbudowaną _ReadWriteBarrier.

Atrybuty

  • implements Atrybut jest teraz udokumentowany.

Funkcje konsolidatora

Dodano następujące opcje linkera:

  • /ASSEMBLYDEBUG
  • /ASSEMBLYLINKRESOURCE
  • opóźniony podpis
  • /KEYFILE
  • /KONTEKST KLUCZA
  • /SAFESEH

MASM

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

Zobacz też

Przewodnik po przenoszeniu i uaktualnianiu pakietu Visual C++