Visual C++ mengubah sejarah 2003 hingga 2015

Artikel
03/21/2023

Halaman ini mengumpulkan semua halaman "Apa yang Baru" untuk semua versi Visual C++ dari Visual Studio 2015 kembali ke 2003. Informasi ini disediakan sebagai kenyamanan jika mungkin berguna saat meningkatkan dari versi Visual Studio sebelumnya.

Catatan

Untuk informasi tentang versi Visual Studio saat ini, lihat Apa yang baru untuk Visual C++ di Visual Studio dan Peningkatan Kesuaian di Visual C++ di Visual Studio.

Yang Baru untuk C++ di Visual Studio 2015

Di Visual Studio 2015 dan yang lebih baru, penyempurnaan berkelanjutan pada kesadaran kompilator terkadang dapat mengubah bagaimana pengkompilasi memahami kode sumber yang ada. Ketika ini terjadi, Anda mungkin mengalami kesalahan baru atau berbeda selama build Anda, atau bahkan perbedaan perilaku dalam kode yang sebelumnya dibangun dan tampaknya berjalan dengan benar.

Untungnya, perbedaan ini memiliki sedikit atau tidak berdampak pada sebagian besar kode sumber Anda dan ketika kode sumber atau perubahan lain diperlukan untuk mengatasi perbedaan ini, perbaikan biasanya kecil dan lurus ke depan. Kami telah menyertakan banyak contoh kode sumber yang dapat diterima sebelumnya yang mungkin perlu diubah (sebelumnya) dan perbaikan untuk memperbaikinya (setelah).

Meskipun perbedaan ini dapat memengaruhi kode sumber Anda atau artefak build lainnya, perbedaan tersebut tidak memengaruhi kompatibilitas biner antara pembaruan ke versi Visual C++. Jenis perubahan yang lebih parah, perubahan yang melanggar dapat memengaruhi kompatibilitas biner, tetapi jenis pemutusan kompatibilitas biner ini hanya terjadi di antara versi utama Visual C++. Misalnya, antara Visual C++ 2013 dan Visual C++ 2015. Untuk informasi tentang perubahan mencolok yang terjadi antara Visual C++ 2013 dan Visual C++ 2015, lihat Riwayat perubahan Visual C++ 2003 - 2015.

Peningkatan Kesuaian di Visual Studio 2015
Peningkatan Kesuaian di Visual Studio 2015 Update 1
Peningkatan Kesuaian di Visual Studio 2015 Update 2
Penyempurnaan Kesuaian di Visual Studio 2015 Update 3

Peningkatan Kesuaian di Visual Studio 2015

Opsi /Zc:forScope-

Opsi /Zc:forScope- kompilator tidak digunakan lagi dan akan dihapus dalam rilis mendatang.
```
  Command line warning  D9035: option 'Zc:forScope-' has been deprecated and will be removed in a future release
```
Opsi ini biasanya digunakan untuk memungkinkan kode nonstandar yang menggunakan variabel perulangan setelah titik di mana, sesuai dengan standar, mereka harus keluar dari cakupan. Itu hanya diperlukan ketika Anda mengkompilasi dengan /Za opsi , karena tanpa /Za, menggunakan variabel untuk perulangan setelah akhir perulangan selalu diizinkan. Jika Anda tidak peduli tentang kesuaian standar (misalnya, jika kode Anda tidak dimaksudkan untuk portabel ke pengkompilasi lain), Anda dapat menonaktifkan /Za opsi (atau mengatur properti Nonaktifkan Ekstensi Bahasa ke Tidak). Jika Anda peduli tentang menulis kode portabel dan sesuai standar, Anda harus menulis ulang kode Anda sehingga sesuai dengan standar dengan memindahkan deklarasi variabel tersebut ke titik di luar perulangan.
```
  // 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
  }
```
Opsi pengkompilasi Zg.

Opsi /Zg pengkompilasi (Hasilkan Prototipe Fungsi) tidak lagi tersedia. Opsi kompilator ini sebelumnya tidak digunakan lagi.
Anda tidak dapat lagi menjalankan pengujian unit dengan C++/CLI dari baris perintah dengan mstest.exe. Sebagai gantinya, gunakan vstest.console.exe
kata kunci yang dapat diubah.

Penentu mutable kelas penyimpanan tidak lagi diizinkan di tempat-tempat di mana sebelumnya dikompilasi tanpa kesalahan. Sekarang, kompilator memberikan kesalahan C2071 (kelas penyimpanan ilegal). Menurut standar, penentu yang dapat diubah hanya dapat diterapkan ke nama anggota data kelas, dan tidak dapat diterapkan ke nama yang dinyatakan const atau statis, dan tidak dapat diterapkan ke anggota referensi.

Sebagai contoh, perhatikan kode berikut:
```
  struct S {
      mutable int &r;
  };
```
Versi kompilator Microsoft C++ sebelumnya menerima ini, tetapi sekarang pengkompilasi memberikan kesalahan berikut:
```
  error C2071: 'S::r': illegal storage class
```
Untuk memperbaiki kesalahan, cukup hapus kata kunci redundan mutable .
char_16_t dan char32_t

Anda tidak dapat lagi menggunakan char16_t atau char32_t sebagai alias dalam typedef, karena jenis ini sekarang diperlakukan sebagai bawaan. Pengguna dan penulis pustaka umum untuk mendefinisikan char16_t dan char32_t sebagai alias dan uint16_t uint32_t, masing-masing.
```
  #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;
  }
```
Untuk memperbarui kode Anda, hapus typedef deklarasi dan ganti nama pengidentifikasi lain yang bertabrakan dengan nama-nama ini.
Parameter templat non-jenis

Kode tertentu yang melibatkan parameter templat non-jenis sekarang diperiksa dengan benar untuk kompatibilitas jenis saat Anda memberikan argumen templat eksplisit. Misalnya, kode berikut dikompilasi tanpa kesalahan dalam versi Visual C++sebelumnya.
```
  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>();
  }
```
Pengkompilasi saat ini memberikan kesalahan dengan benar, karena jenis parameter templat tidak cocok dengan argumen templat (parameter adalah penunjuk ke anggota const, tetapi fungsi f non-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'
```
Untuk mengatasi kesalahan ini dalam kode Anda, pastikan bahwa jenis argumen templat yang Anda gunakan cocok dengan jenis parameter templat yang dideklarasikan.
__declspec(align)

Pengkompilasi tidak lagi menerima __declspec(align) fungsi. Ini selalu diabaikan, tetapi sekarang menghasilkan kesalahan kompilator.
```
  error C3323: 'alignas' and '__declspec(align)' are not allowed on function declarations
```
Untuk memperbaiki masalah ini, hapus __declspec(align) dari deklarasi fungsi. Karena tidak berpengaruh, menghapusnya tidak mengubah apa pun.
Penanganan pengecualian

Ada beberapa perubahan pada penanganan pengecualian. Pertama, objek pengecualian harus dapat disalin atau bergerak. Kode berikut dikompilasi di Visual Studio 2013, tetapi tidak dikompilasi di Visual Studio 2015:
```
  struct S {
  public:
      S();
  private:
      S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Masalahnya adalah bahwa konstruktor salinan bersifat privat, sehingga objek tidak dapat disalin seperti yang terjadi dalam perjalanan normal menangani pengecualian. Hal yang sama berlaku ketika konstruktor salinan dinyatakan explicit.
```
  struct S {
      S();
      explicit S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Untuk memperbarui kode Anda, pastikan bahwa konstruktor salinan untuk objek pengecualian Anda bersifat publik dan tidak ditandai explicit.

Menangkap pengecualian berdasarkan nilai juga mengharuskan objek pengecualian dapat disalin. Kode berikut dikompilasi di Visual Studio 2013, tetapi tidak dikompilasi di Visual Studio 2015:
```
  struct B {
  public:
      B();
  private:
      B(const B &);
  };

  struct D : public B {
  };

  int main()
  {
      try
      {
      }
      catch (D d) // error
      {
      }
  }
```
Anda dapat memperbaiki masalah ini dengan mengubah jenis parameter untuk catch menjadi referensi.
```
  catch(D& d)
  {
  }
```
String literal diikuti oleh makro

Pengkompilasi sekarang mendukung literal yang ditentukan pengguna. Sebagai konsekuensinya, string harfiah diikuti oleh makro tanpa spasi yang mengintervensi ditafsirkan sebagai literal yang ditentukan pengguna, yang mungkin menghasilkan kesalahan atau hasil yang tidak terduga. Misalnya, di kompilator sebelumnya, kode berikut berhasil dikompilasi:
```
  #define _x "there"
  char* func() {
      return "hello"_x;
  }
  int main()
  {
      char * p = func();
      return 0;
  }
```
Kompiler menafsirkan ini sebagai string harfiah "hello" diikuti oleh makro, yang diperluas "di sana", dan kemudian dua literal string digabungkan menjadi satu. Di Visual Studio 2015, pengkompilasi menafsirkan ini sebagai literal yang ditentukan pengguna, tetapi karena tidak ada _x harfiah yang ditentukan pengguna yang cocok yang ditentukan, itu memberikan kesalahan.
```
  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?
```
Untuk memperbaiki masalah ini, tambahkan spasi antara string literal dan makro.
Literal string yang berdekatan

Demikian pula dengan sebelumnya, karena perubahan terkait dalam penguraian string, literal string yang berdekatan (baik literal string karakter lebar atau sempit) tanpa spasi putih ditafsirkan sebagai string tunggal yang digabungkan dalam rilis Visaul C++sebelumnya. Di Visual Studio 2015, Anda sekarang harus menambahkan spasi kosong di antara dua string. Misalnya, kode berikut harus diubah:
```
  char * str = "abc""def";
```
Cukup tambahkan spasi di antara dua string.
```
  char * str = "abc" "def";
```
Penempatan baru dan hapus

Perubahan telah dilakukan pada delete operator agar sesuai dengan standar C++14. Detail perubahan standar dapat ditemukan di Alokasi Berukuran C++. Perubahan menambahkan bentuk operator global delete yang mengambil parameter ukuran. Perubahan yang melanggar adalah bahwa jika Sebelumnya Anda menggunakan operator delete dengan tanda tangan yang sama (sesuai dengan operator baru penempatan), Anda akan menerima kesalahan kompilator (C2956, yang terjadi pada titik di mana penempatan baru digunakan, karena itulah posisi dalam kode di mana pengkompilasi mencoba mengidentifikasi operator pencocokan delete yang sesuai).

Fungsi void operator delete(void *, size_t) ini adalah operator penghapusan penempatan yang sesuai dengan fungsi void * operator new(size_t, size_t) baru penempatan di C++11. Dengan dealokasi berukuran C++14, fungsi ini delete sekarang menjadi fungsi dealokasi biasa (operator global delete ). Standar mengharuskan bahwa jika penggunaan penempatan baru mencari fungsi yang sesuai delete dan menemukan fungsi dealokasi yang biasa, program akan terbentuk dengan tidak benar.

Misalnya, kode Anda menentukan penempatan baru dan penghapusan penempatan:
```
  void * operator new(std::size_t, std::size_t);
  void operator delete(void*, std::size_t) noexcept;
```
Masalah terjadi karena kecocokan dalam tanda tangan fungsi antara operator penghapusan penempatan yang telah Anda tentukan, dan operator berukuran delete global baru. Pertimbangkan apakah Anda dapat menggunakan jenis yang berbeda selain size_t untuk penempatan apa pun yang baru dan delete operator. Perhatikan bahwa jenisnya size_t typedef adalah compiler-dependent; ini adalah typedef untuk unsigned int di Visual C++. Solusi yang baik adalah menggunakan jenis enumerasi seperti ini:
```
  enum class my_type : size_t {};
```
Kemudian, ubah definisi penempatan new Anda dan delete untuk menggunakan jenis ini sebagai argumen kedua alih-alih size_t. Anda juga harus memperbarui panggilan ke penempatan baru untuk meneruskan jenis baru (misalnya, dengan menggunakan static_cast<my_type> untuk mengonversi dari nilai bilangan bulat) dan memperbarui definisi dan delete untuk mentransmisikan kembali ke jenis bilangan new bulat. Anda tidak perlu menggunakan enum untuk ini; jenis kelas dengan size_t anggota juga akan berfungsi.

Solusi alternatifnya adalah Anda mungkin dapat menghilangkan penempatan baru sama sekali. Jika kode Anda menggunakan penempatan baru untuk mengimplementasikan kumpulan memori di mana argumen penempatan adalah ukuran objek yang dialokasikan atau dihapus, maka fitur dealokasi berukuran mungkin cocok untuk mengganti kode kumpulan memori kustom Anda sendiri, dan Anda dapat menyingkirkan fungsi penempatan dan hanya menggunakan operator dua argumen delete Anda sendiri alih-alih fungsi penempatan.

Jika Anda tidak ingin segera memperbarui kode, Anda dapat kembali ke perilaku lama dengan menggunakan opsi /Zc:sizedDealloc-pengkompilasi . Jika Anda menggunakan opsi ini, fungsi dua argumen delete tidak ada dan tidak akan menyebabkan konflik dengan operator penghapusan penempatan Anda.
Anggota data union

Anggota data dari serikat tidak dapat lagi memiliki jenis referensi. Kode berikut berhasil dikompilasi di Visual Studio 2013, tetapi menghasilkan kesalahan di Visual Studio 2015.
```
  union U1 {
      const int i;
  };
  union U2 {
     int &i;
  };
  union U3 {
      struct {int &i;};
  };
```
Kode sebelumnya menghasilkan kesalahan berikut:
```
  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
```
Untuk mengatasi masalah ini, ubah jenis referensi baik ke penunjuk atau nilai. Mengubah jenis menjadi penunjuk memerlukan perubahan dalam kode yang menggunakan bidang union. Mengubah kode menjadi nilai akan mengubah data yang disimpan dalam gabungan, yang memengaruhi bidang lain karena bidang dalam jenis gabungan berbagi memori yang sama. Tergantung pada ukuran nilai, nilai juga dapat mengubah ukuran serikat.

Serikat anonim

sekarang lebih sesuai dengan standar. Versi kompilator sebelumnya menghasilkan konstruktor dan destruktor eksplisit untuk serikat anonim. Ini dihapus di Visual Studio 2015.

struct S {
    S();
};

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

Kode sebelumnya menghasilkan kesalahan berikut di 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

Untuk mengatasi masalah ini, berikan definisi Anda sendiri tentang konstruktor dan/atau destruktor.

  struct S {
     // Provide a default constructor by adding an empty function body.
     S() {}
  };

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

Serikat dengan struktur anonim

Untuk menyesuaikan dengan standar, perilaku runtime telah berubah untuk anggota struktur anonim dalam serikat. Konstruktor untuk anggota struktur anonim dalam serikat tidak lagi secara implisit dipanggil ketika serikat tersebut dibuat. Selain itu, destruktor untuk anggota struktur anonim dalam serikat tidak lagi secara implisit dipanggil ketika penyatuan keluar dari cakupan. Pertimbangkan kode berikut, di mana union U berisi struktur anonim yang berisi anggota yang merupakan struktur bernama S yang memiliki 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;
  }

Di Visual Studio 2013, konstruktor untuk S dipanggil saat penyatuan dibuat, dan destruktor untuk S dipanggil ketika tumpukan untuk fungsi f dibersihkan. Tetapi di Visual Studio 2015, konstruktor dan destruktor tidak dipanggil. Pengkompilasi memberikan peringatan tentang perubahan perilaku ini.

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

Untuk memulihkan perilaku asli, beri nama struktur anonim. Perilaku runtime struktur non-anonim sama, terlepas dari versi pengompilasi.

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

Atau, coba pindahkan kode konstruktor dan destruktor ke fungsi baru, dan tambahkan panggilan ke fungsi-fungsi ini dari konstruktor dan destruktor untuk serikat.

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

Resolusi templat

Perubahan telah dilakukan pada resolusi nama untuk templat. Di C++, ketika mempertimbangkan kandidat untuk resolusi nama, bisa jadi satu atau beberapa nama dipertimbangkan karena potensi kecocokan menghasilkan instansiasi templat yang tidak valid. Instansiasi yang tidak valid ini biasanya tidak menyebabkan kesalahan kompilator, prinsip yang dikenal sebagai SFINAE (Kegagalan Penggantian Bukan Kesalahan).

Sekarang, jika SFINAE mengharuskan pengkompilasi untuk membuat instans spesialisasi templat kelas, maka kesalahan apa pun yang terjadi selama proses ini adalah kesalahan kompilator. Di versi sebelumnya, pengkompilasi akan mengabaikan kesalahan tersebut. Sebagai contoh, perhatikan kode berikut:
```
  #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);
  }
```
Jika Anda mengkompilasi dengan pengkompilasi saat ini, Anda mendapatkan kesalahan berikut:
```
  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
          ]
```
Ini karena pada titik pemanggilan pertama is_base_of kelas 'D' belum ditentukan.

Dalam hal ini, perbaikannya adalah tidak menggunakan sifat jenis tersebut sampai kelas telah ditentukan. Jika Anda memindahkan definisi B dan D ke awal file kode, kesalahan akan diatasi. Jika definisi berada dalam file header, periksa urutan pernyataan sertakan untuk file header untuk memastikan bahwa definisi kelas apa pun dikompilasi sebelum templat bermasalah digunakan.
Menyalin konstruktor

Di Visual Studio 2013 dan Visual Studio 2015, kompilator menghasilkan konstruktor salinan untuk kelas jika kelas tersebut memiliki konstruktor pemindahan yang ditentukan pengguna tetapi tidak ada konstruktor salinan yang ditentukan pengguna. Di Dev14, konstruktor salinan yang dihasilkan secara implisit ini juga ditandai "= hapus".

Peningkatan Kesuaian di Visual Studio 2015 Update 1

Kelas dasar virtual privat dan pewarisan tidak langsung

Versi kompilator sebelumnya memungkinkan kelas turunan untuk memanggil fungsi anggota dari kelas dasar yang diturunkan private virtual secara tidak langsung. Perilaku lama ini salah dan tidak sesuai dengan standar C++. Kompilator tidak lagi menerima kode yang ditulis dengan cara ini dan mengeluarkan kesalahan kompilator C2280 sebagai hasilnya.

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

Contoh (sebelumnya)

  class base
  {
  protected:
      base();
      ~base();
  };

  class middle: private virtual base {};class top: public virtual middle {};

  void destroy(top *p)
  {
      delete p;  //
  }

Contoh (setelah)

  class base;  // as above

  class middle: protected virtual base {};
  class top: public virtual middle {};

  void destroy(top *p)
  {
      delete p;
  }

-atau-

  class base;  // as above

  class middle: private virtual base {};
  class top: public virtual middle, private virtual bottom {};

  void destroy(top *p)
  {
      delete p;
  }

Operator baru yang kelebihan beban dan penghapusan operator

Versi kompilator sebelumnya memungkinkan operator non-anggota menghapus operator baru dan non-anggota untuk dinyatakan statis, dan dideklarasikan dalam namespace selain namespace global. Perilaku lama ini menciptakan risiko bahwa program tidak akan memanggil new implementasi atau delete operator yang dimaksudkan programmer, menghasilkan perilaku runtime yang buruk diam-diam. Pengkompilasi tidak lagi menerima kode yang ditulis dengan cara ini dan mengeluarkan kesalahan pengkompilasi C2323 sebagai gantinya.
```
  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.
```
Contoh (sebelumnya)
```
  static inline void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // error C2323
```
Contoh (setelah)
```
  void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // removed 'static inline'
```
Selain itu, meskipun pengkompilasi tidak memberikan diagnostik tertentu, operator sebaris baru dianggap tidak terbentuk.
Memanggil 'operator type()' (konversi yang ditentukan pengguna) pada jenis non-kelas Versi kompiler sebelumnya memungkinkan 'operator type()' untuk dipanggil pada jenis non-kelas sambil mengabaikannya secara diam-diam. Perilaku lama ini menciptakan risiko pembuatan kode buruk senyap, yang mengakibatkan perilaku runtime yang tidak dapat diprediksi. Kompilator tidak lagi menerima kode yang ditulis dengan cara ini dan mengeluarkan kesalahan kompilator C2228 sebagai gantinya.
```
  error C2228: left of '.operator type' must have class/struct/union
```
Contoh (sebelumnya)
```
  typedef int index_t;

  void bounds_check(index_t index);

  void login(int column)
  {
      bounds_check(column.operator index_t());  // error C2228
  }
```
Contoh (setelah)
```
  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'
  }
```
Nama jenis redundan dalam penentu jenis yang dijabarkan Versi kompilator sebelumnya yang diizinkan typename dalam penentu jenis yang dijabarkan; kode yang ditulis dengan cara ini secara semantik salah. Pengkompilasi tidak lagi menerima kode yang ditulis dengan cara ini dan mengeluarkan kesalahan pengkompilasi C3406 sebagai gantinya.
```
  error C3406: 'typename' cannot be used in an elaborated type specifier
```
Contoh (sebelumnya)
```
  template <typename class T>
  class container;
```
Contoh (setelah)
```
  template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case
  class container;
```

Pengurangan jenis array dari daftar inisialisasi Versi kompilator sebelumnya tidak mendukung pengurangan jenis array dari daftar penginisialisasi. Pengompilasi sekarang mendukung bentuk pengurangan jenis ini dan, sebagai hasilnya, panggilan ke templat fungsi menggunakan daftar penginisialisasi sekarang mungkin ambigu atau kelebihan beban yang berbeda mungkin dipilih daripada di versi kompilator sebelumnya. Untuk mengatasi masalah ini, program sekarang harus secara eksplisit menentukan kelebihan beban yang dimaksudkan programmer.

Ketika perilaku baru ini menyebabkan resolusi kelebihan beban untuk mempertimbangkan kandidat tambahan yang sama baiknya dengan kandidat historis, panggilan menjadi ambigu dan kompilator mengeluarkan kesalahan kompilator C2668 sebagai hasilnya.

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

Contoh 1: Panggilan ambigu ke fungsi kelebihan beban (sebelumnya)

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

Contoh 1: panggilan ambigu ke fungsi yang kelebihan beban (setelah)

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

Ketika perilaku baru ini menyebabkan resolusi kelebihan beban untuk mempertimbangkan kandidat tambahan yang lebih cocok daripada kandidat historis, panggilan diselesaikan secara tidak ambigu ke kandidat baru, menyebabkan perubahan perilaku program yang mungkin berbeda dari programmer yang dimaksudkan.

Contoh 2: perubahan resolusi kelebihan beban (sebelumnya)

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

Contoh 2: perubahan resolusi kelebihan beban (setelah)

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

Pemulihan peringatan pernyataan pengalihan

Versi sebelumnya dari kompilator menghapus peringatan yang ada sebelumnya yang terkait dengan switch pernyataan; peringatan ini sekarang telah dipulihkan. Kompiler sekarang mengeluarkan peringatan yang dipulihkan, dan peringatan yang terkait dengan kasus tertentu (termasuk kasus default) sekarang dikeluarkan pada baris yang berisi kasus yang menyinggung, bukan pada baris terakhir pernyataan switch. Akibat dari sekarang mengeluarkan peringatan tersebut pada baris yang berbeda dari di masa lalu, peringatan yang sebelumnya ditekan dengan menggunakan #pragma warning(disable:####) mungkin tidak lagi ditekan seperti yang dimaksudkan. Untuk menekan peringatan ini seperti yang dimaksudkan, mungkin perlu untuk memindahkan #pragma warning(disable:####) arahan ke garis di atas kasus pertama yang berpotensi menyinggung. Berikut ini adalah peringatan yang dipulihkan.

  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

Contoh C4063 (sebelumnya)

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

Contoh C4063 (setelah)

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

Contoh peringatan lain yang dipulihkan disediakan dalam dokumentasinya.

#include: penggunaan penentu direktori induk '..' dalam nama jalur (hanya mempengaruhi /Wall /WX)

Versi kompilator sebelumnya tidak mendeteksi penggunaan penentu direktori induk '..' dalam nama jalur arahan #include . Kode yang ditulis dengan cara ini biasanya dimaksudkan untuk menyertakan header yang ada di luar proyek dengan salah menggunakan jalur relatif proyek. Perilaku lama ini menciptakan risiko bahwa program dapat dikompilasi dengan menyertakan file sumber yang berbeda dari programmer yang dimaksudkan, atau bahwa jalur relatif ini tidak akan portabel ke lingkungan build lainnya. Pengkompilasi sekarang mendeteksi dan memberi tahu pemrogram kode yang ditulis dengan cara ini dan mengeluarkan peringatan kompilator opsional C4464, jika diaktifkan.
```
  warning C4464: relative include path contains '..'
```
Contoh (sebelumnya)
```
  #include "..\headers\C4426.h"  // emits warning C4464
```
Contoh (setelah)
```
  #include "C4426.h"  // add absolute path to 'headers\' to your project's include directories
```
Selain itu, meskipun pengkompilasi tidak memberikan diagnostik tertentu, kami juga menyarankan agar penentu direktori induk ".." harus dicatat digunakan untuk menentukan direktori sertakan proyek Anda.
#pragma optimize() memperluas akhir file header sebelumnya (hanya memengaruhi /Wall /WX)

Versi kompilator sebelumnya tidak mendeteksi perubahan pada pengaturan bendera pengoptimalan yang lolos dari file header yang disertakan dalam unit terjemahan. Kompilator sekarang mendeteksi dan memberi tahu pemrogram kode yang ditulis dengan cara ini dan mengeluarkan peringatan kompilator opsional C4426 di lokasi yang menyinggung #include, jika diaktifkan. Peringatan ini hanya dikeluarkan jika perubahan bertentangan dengan bendera pengoptimalan yang diatur oleh argumen baris perintah ke pengkompilasi.
```
  warning C4426: optimization flags changed after including header, may be due to #pragma optimize()
```
Contoh (sebelumnya)
```
  // C4426.h
  #pragma optimize("g", off)
  ...
  // C4426.h ends

  // C4426.cpp
  #include "C4426.h"  // warning C4426
```
Contoh (setelah)
```
  // 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"
```

Peringatan #pragma yang tidak cocok(push) dan peringatan #pragma (pop) (hanya memengaruhi /Wall /WX)

Versi kompilator sebelumnya tidak mendeteksi #pragma warning(push) perubahan status dipasangkan dengan #pragma warning(pop) perubahan status dalam file sumber yang berbeda, yang jarang dimaksudkan. Perilaku lama ini menciptakan risiko bahwa program akan dikompilasi dengan serangkaian peringatan yang berbeda yang diaktifkan dari programmer yang dimaksudkan, mungkin mengakibatkan perilaku runtime yang buruk senyap. Pengkompilasi sekarang mendeteksi dan memberi tahu pemrogram kode yang ditulis dengan cara ini dan mengeluarkan peringatan kompilator opsional C5031 di lokasi pencocokan #pragma warning(pop), jika diaktifkan. Peringatan ini mencakup catatan yang mereferensikan lokasi yang sesuai #pragma warning(push).

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

Contoh (sebelumnya)

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

Contoh (setelah)

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

Meskipun jarang, kode yang ditulis dengan cara ini terkadang disengaja. Kode yang ditulis dengan cara ini sensitif terhadap perubahan #include secara berurutan; jika memungkinkan, sebaiknya file kode sumber mengelola status peringatan dengan cara mandiri.

Peringatan #pragma yang tidak cocok(push) (hanya memengaruhi /Wall /WX)

Versi kompilator sebelumnya tidak mendeteksi perubahan status yang tidak cocok #pragma warning(push) di akhir unit terjemahan. Pengkompilasi sekarang mendeteksi dan memberi tahu pemrogram kode yang ditulis dengan cara ini dan mengeluarkan peringatan kompilator opsional C5032 di lokasi yang tidak cocok #pragma warning(push), jika diaktifkan. Peringatan ini hanya dikeluarkan jika tidak ada kesalahan kompilasi di unit terjemahan.

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

Contoh (sebelumnya)

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

Contoh (setelah)

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

Peringatan tambahan mungkin dikeluarkan sebagai akibat dari peningkatan #pragma pelacakan status peringatan

Versi sebelumnya dari compiler melacak #pragma warning perubahan status tidak cukup baik untuk mengeluarkan semua peringatan yang dimaksudkan. Perilaku ini menciptakan risiko bahwa peringatan tertentu akan secara efektif ditekan dalam keadaan yang berbeda dari programmer yang dimaksudkan. Pengompilasi sekarang melacak #pragma warning status dengan lebih kuat -- terutama terkait #pragma warning dengan perubahan status di dalam templat -- dan secara opsional mengeluarkan peringatan baru C5031 dan C5032 yang dimaksudkan untuk membantu programmer menemukan penggunaan dan #pragma warning(pop)yang tidak diinginkan.#pragma warning(push)

Sebagai akibat dari peningkatan #pragma warning pelacakan perubahan status, peringatan yang sebelumnya salah ditekan atau peringatan yang terkait dengan masalah yang sebelumnya salah didiagnosis mungkin sekarang dikeluarkan.
Peningkatan identifikasi kode yang tidak dapat dijangkau

Pustaka Standar C++ mengubah dan meningkatkan kemampuan untuk panggilan fungsi sebaris melalui versi kompilator sebelumnya mungkin memungkinkan pengkompilasi untuk membuktikan bahwa kode tertentu sekarang tidak dapat dijangkau. Perilaku baru ini dapat menghasilkan instans peringatan C4720 baru dan lebih sering dikeluarkan.
```
  warning C4720: unreachable code
```
Dalam banyak kasus, peringatan ini mungkin hanya dikeluarkan saat mengkompilasi dengan pengoptimalan diaktifkan, karena pengoptimalan dapat menginline lebih banyak panggilan fungsi, menghilangkan kode redundan, atau memungkinkan untuk menentukan bahwa kode tertentu tidak dapat dijangkau. Kami telah mengamati bahwa instans baru peringatan C4720 sering terjadi di blok try/catch , terutama dalam kaitannya dengan penggunaan std::find.

Contoh (sebelumnya)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // ok
  }
```
Contoh (setelah)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // warning C4702: unreachable code
  }
```
Penghapusan pengoptimalan pow(T, int) unrolling

Versi pustaka standar C++ sebelumnya mendefinisikan pow(T, int) templat fungsi yang akan membatalkan pendaftaran pow panggilan fungsi ke dalam serangkaian operasi perkalian. Teknik ini akan mengumpulkan sejumlah besar ketidakakuratan karena sifat operasi titik mengambang, menyebabkan hasil akhir yang dapat secara signifikan tidak akurat. Di Visual Studio 2015 Update 1, perilaku ini dihapus untuk menghindari hilangnya akurasi yang tidak disengaja saat menggunakan pow fungsi . Namun, versi pow ini jauh lebih cepat daripada perhitungan yang benar. Jika perubahan ini menyebabkan regresi performa yang signifikan dan proyek Anda tidak memerlukan hasil floating point yang tepat (misalnya, proyek Anda sudah dikompilasi dengan /fp:fast), pertimbangkan untuk mengganti panggilan dengan pow fungsi solusi ini:
```
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);
         }
     }
}
```
Implementasi ini identik dengan apa yang disertakan dalam versi Visual Studio sebelumnya.

Peningkatan Kesuaian di Visual Studio 2015 Update 2

Peringatan dan kesalahan tambahan mungkin dikeluarkan sebagai akibat dari dukungan parsial untuk ekspresi SFINAE

Versi kompilator sebelumnya tidak mengurai jenis ekspresi tertentu di dalam decltype penentu karena kurangnya dukungan untuk ekspresi SFINAE. Perilaku lama ini salah dan tidak sesuai dengan standar C++. Kompilator sekarang mengurai ekspresi ini dan memiliki dukungan parsial untuk ekspresi SFINAE karena peningkatan kesesuaian yang sedang berlangsung. Akibatnya, pengkompilasi sekarang mengeluarkan peringatan dan kesalahan yang ditemukan dalam ekspresi yang versi kompiler sebelumnya tidak diurai.

Ketika perilaku baru ini mengurai decltype ekspresi yang menyertakan jenis yang belum dideklarasikan, kompilator mengeluarkan kesalahan kompilator C2039 sebagai hasilnya.
```
  error C2039: 'type': is not a member of 'global namespace'
```
Contoh 1: penggunaan jenis yang tidak dinyatakan (sebelumnya)
```
  struct s1
  {
    template <typename T>
    auto f() -> decltype(s2<T>::type::f());  // error C2039

    template<typename>
    struct s2 {};
  }
```
Contoh 1 (setelah)
```
  struct s1
  {
    template <typename>  // forward declare s2struct s2;

    template <typename T>
    auto f() -> decltype(s2<T>::type::f());

    template<typename>
    struct s2 {};
  }
```
Ketika perilaku baru ini menguraikan decltype ekspresi yang kehilangan penggunaan typename kata kunci yang diperlukan untuk menentukan bahwa nama dependen adalah jenis, pengkompilasi mengeluarkan peringatan kompilator C4346 bersama dengan kesalahan kompilator 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'
```
Contoh 2: nama dependen bukan jenis (sebelumnya)
```
  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
  };
```
Contoh 2 (setelah)
```
  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>()));
  };
```
volatilevariabel anggota mencegah konstruktor dan operator penugasan yang ditentukan secara implisit Versi kompilator sebelumnya memungkinkan kelas yang memiliki volatile variabel anggota untuk memiliki konstruktor salin/pindah default dan operator penugasan salin/pindah default yang dibuat secara otomatis. Perilaku lama ini salah dan tidak sesuai dengan standar C++. Kompilator sekarang mempertimbangkan kelas yang memiliki variabel anggota volatil untuk memiliki operator konstruksi dan penugasan non-sepele yang mencegah implementasi default operator ini dihasilkan secara otomatis. Ketika kelas seperti itu adalah anggota serikat pekerja (atau serikat anonim di dalam kelas), konstruktor salin/pindahkan dan operator penetapan salin/pindah dari serikat pekerja (atau kelas yang berisi serikat tidak dikenal) akan secara implisit didefinisikan sebagai dihapus. Mencoba membangun atau menyalin serikat (atau kelas yang berisi serikat anonim) tanpa secara eksplisit mendefinisikannya adalah kesalahan dan kompilator mengeluarkan kesalahan kompilator C2280 sebagai hasilnya.
```
  error C2280: 'B::B(const B &)': attempting to reference a deleted function
```
Contoh (sebelumnya)
```
  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
```
Contoh (setelah)
```
  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
```
Fungsi anggota statis tidak mendukung kualifikasi cv.

Versi Visual C++ 2015 sebelumnya memungkinkan fungsi anggota statis memiliki kualifikasi cv. Perilaku ini disebabkan oleh regresi di Visual C++ 2015 dan Visual C++ 2015 Update 1; Visual C++ 2013 dan versi Visual C++ sebelumnya menolak kode yang ditulis dengan cara ini. Perilaku Visual C++ 2015 dan Visual C++ 2015 Update 1 salah dan tidak sesuai dengan standar C++. Visual Studio 2015 Update 2 menolak kode yang ditulis dengan cara ini dan mengeluarkan kesalahan kompilator C2511 sebagai gantinya.
```
  error C2511: 'void A::func(void) const': overloaded member function not found in 'A'
```
Contoh (sebelumnya)
```
  struct A
  {
    static void func();
  };

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

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

Deklarasi penerusan enum tidak diperbolehkan dalam kode WinRT (hanya memengaruhi /ZW )

Kode yang dikompilasi untuk Windows Runtime (WinRT) tidak memungkinkan enum jenis untuk diteruskan dideklarasikan, mirip dengan ketika kode C++ terkelola dikompilasi untuk .Net Framework menggunakan /clr sakelar kompiler. Perilaku ini memastikan bahwa ukuran enumerasi selalu diketahui dan dapat diproyeksikan dengan benar ke sistem jenis WinRT. Pengkompilasi menolak kode yang ditulis dengan cara ini dan mengeluarkan kesalahan kompilator C2599 bersama dengan kesalahan kompilator C3197.

  error C2599: 'CustomEnum': the forward declaration of a WinRT enum is not allowed

  error C3197: 'public': can only be used in definitions

Contoh (sebelumnya)

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

Contoh (setelah)

            // forward declaration of CustomEnum removed
  namespace A {
    public enum class CustomEnum: int32
    {
      Value1
    };
  }

  public ref class Component sealed
  {
  public:
    CustomEnum f()
    {
      return CustomEnum::Value1;
    }
  };

Operator non-anggota yang kelebihan beban baru dan penghapusan operator mungkin tidak dinyatakan sebaris (Tingkat 1 (/W1) secara default)

Versi kompilator sebelumnya tidak mengeluarkan peringatan ketika operator non-anggota baru dan fungsi penghapusan operator dinyatakan sebaris. Kode yang ditulis dengan cara ini tidak terbentuk buruk (tidak diperlukan diagnostik) dan dapat menyebabkan masalah memori yang diakibatkan oleh operator baru dan penghapusan yang tidak cocok (terutama ketika digunakan bersama dengan dealokasi berukuran) yang dapat sulit didiagnosis. Kompilator sekarang mengeluarkan peringatan kompilator C4595 untuk membantu mengidentifikasi kode yang ditulis dengan cara ini.
```
  warning C4595: 'operator new': non-member operator new or delete functions may not be declared inline
```
Contoh (sebelumnya)
```
  inline void* operator new(size_t sz)  // warning C4595
  {
    ...
  }
```
Contoh (setelah)
```
  void* operator new(size_t sz)  // removed inline
  {
    ...
  }
```
Memperbaiki kode yang ditulis dengan cara ini mungkin mengharuskan definisi operator dipindahkan dari file header dan ke file sumber yang sesuai.

Penyempurnaan Kesuaian di Visual Studio 2015 Update 3

std::is_convertable sekarang mendeteksi penetapan mandiri (pustaka standar) Versi sebelumnya dari std::is_convertable jenis-sifat tidak mendeteksi penetapan sendiri jenis kelas dengan benar ketika konstruktor salinannya dihapus atau privat. Sekarang, std::is_convertable<>::value diatur dengan benar ke false saat diterapkan ke jenis kelas dengan konstruktor salinan yang dihapus atau privat.

Tidak ada diagnostik kompilator yang terkait dengan perubahan ini.

Contoh
```
  #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");
```
Dalam versi Visual C++sebelumnya, pernyataan statis di bagian bawah contoh ini lulus karena std::is_convertable<>::value salah diatur ke true. Sekarang, std::is_convertable<>::value diatur dengan benar ke false, menyebabkan pernyataan statis gagal.
Salinan sepele default atau dihapus dan memindahkan konstruktor menghormati penentu akses

Versi kompilator sebelumnya tidak memeriksa penentu akses salinan sepele default atau dihapus dan memindahkan konstruktor sebelum memungkinkan mereka dipanggil. Perilaku lama ini salah dan tidak sesuai dengan standar C++. Dalam beberapa kasus, perilaku lama ini menciptakan risiko pembuatan kode buruk senyap, yang mengakibatkan perilaku runtime yang tidak dapat diprediksi. Pengkompilasi sekarang memeriksa penentu akses salinan sepele default atau dihapus dan memindahkan konstruktor untuk menentukan apakah konstruktor dapat dipanggil, dan jika tidak, mengeluarkan peringatan kompilator C2248 sebagai hasilnya.
```
  error C2248: 'S::S' cannot access private member declared in class 'S'
```
Contoh (sebelumnya)
```
  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
  }
```
Contoh (setelah)
```
  class S {
  public:
     S() = default;
  private:
      S(const S&) = default;
  };

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

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

Penghentian dukungan kode ATL yang diatribusikan (Tingkat 1 (/W1) secara default)

Versi sebelumnya dari pengkompilasi yang didukung mengaitkan kode ATL. Sebagai fase berikutnya menghapus dukungan untuk kode ATL atribut yang dimulai di Visual C++ 2008, kode ATL yang diatribusikan telah ditolak. Kompilator sekarang mengeluarkan peringatan kompilator C4467 untuk membantu mengidentifikasi jenis kode yang tidak digunakan lagi ini.

  warning C4467: Usage of ATL attributes is deprecated

Jika Anda ingin terus menggunakan kode ATL yang diatribusikan hingga dukungan dihapus dari pengkompilasi, Anda dapat menonaktifkan peringatan ini dengan meneruskan /Wv:18 argumen baris perintah atau /wd4467 ke pengkompilasi, atau dengan menambahkan #pragma warning(disable:4467) dalam kode sumber Anda.

Contoh 1 (sebelumnya)

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

Contoh 1 (setelah)

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

Terkadang Anda mungkin memerlukan atau ingin membuat file IDL untuk menghindari penggunaan atribut ATL yang tidak digunakan lagi, seperti dalam contoh kode di bawah ini

Contoh 2 (sebelumnya)

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

Pertama, buat file *.idl; file vc140.idl yang dihasilkan dapat digunakan untuk mendapatkan file *.idl yang berisi antarmuka dan anotasi.

Selanjutnya, tambahkan langkah MIDL ke build Anda untuk memastikan bahwa definisi antarmuka C++ dihasilkan.

Contoh 2 IDL (setelah)

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

Kemudian, gunakan ATL langsung dalam file implementasi, seperti dalam contoh kode di bawah ini.

Contoh 2 Implementasi (setelah)

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

File header (PCH) yang telah dikommpilasikan sebelumnya dan direktif #include yang tidak cocok (hanya memengaruhi /Wall /WX)

Versi kompilator sebelumnya menerima direktif yang tidak cocok #include dalam file sumber antara -Yc dan -Yu kompilasi saat menggunakan file header (PCH) yang telah dikompilasi sebelumnya. Kode yang ditulis dengan cara ini tidak lagi diterima oleh pengkompilasi. Kompilator sekarang mengeluarkan peringatan kompilator CC4598 untuk membantu mengidentifikasi direktif yang tidak cocok #include saat menggunakan file PCH.
```
  warning C4598: 'b.h': included header file specified for Ycc.h at position 2 does not match Yuc.h at that position
```
Contoh (sebelumnya):

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"
```
Contoh (setelah)

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"
```
File header (PCH) yang telah dikompresi dan tidak cocok menyertakan direktori (hanya memengaruhi /Wall /WX)

Versi kompilator sebelumnya yang diterima tidak cocok termasuk argumen baris perintah direktori (-I) ke pengkompilasi antara -Yc dan -Yu kompilasi saat menggunakan file header (PCH) yang telah dikompilasi sebelumnya. Kode yang ditulis dengan cara ini tidak lagi diterima oleh pengkompilasi. Pengkompilasi sekarang mengeluarkan peringatan kompilator CC4599 untuk membantu mengidentifikasi argumen baris perintah include directory (-I) yang tidak cocok saat menggunakan file PCH.
```
  warning C4599: '-I..' : specified for Ycc.h at position 1 does not match Yuc.h at that position
```
Contoh (sebelumnya)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h Z.cpp
```
Contoh (setelah)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h -I.. Z.cpp
```

Yang Baru untuk C++ di Visual Studio 2013

Peningkatan Dukungan Standar ISO C/C++

Kompilator

MSVC mendukung fitur bahasa ISO C++11 ini:

Argumen templat default untuk templat fungsi.
Mendelegasikan konstruktor
Operator konversi eksplisit.
Inisialisasi daftar dan inisialisasi seragam.
Literal string mentah.
Templat variadik.
Templat alias.
Fungsi yang dihapus.
Inisialisasi anggota data non-statis (NSDMIs).
Fungsi default. *
Mendukung fitur bahasa ISO C99 ini:
_Bool
Senyawa literal.
Penginisialisasi yang ditunjuk.
Mencampur deklarasi dengan kode.
Konversi literal string ke nilai yang dapat dimodifikasi dapat dilarang dengan menggunakan opsi /Zc:strictStringspengkompilasi baru . Di C++98, konversi dari literal string ke char* (dan literal string lebar ke wchar_t*) tidak digunakan lagi. Di C++11, konversi dihapus sepenuhnya. Meskipun pengkompilasi dapat benar-benar sesuai dengan standar, sebaliknya menyediakan /Zc:strictStrings opsi sehingga Anda dapat mengontrol konversi. Secara default, opsi nonaktif. Perhatikan bahwa ketika Anda menggunakan opsi ini dalam mode debug, STL tidak akan dikompilasi.
rvalue/lvalue Reference Casts. Dengan referensi rvalue, C++11 dapat membedakan dengan jelas antara lvalue dan rvalue. Sebelumnya, kompilator tidak menyediakan ini dalam skenario pengecoran tertentu. Opsi pengkompilasi baru, /Zc:rvalueCast, telah ditambahkan untuk membuat pengkompilasi sesuai dengan C++ Language Working Paper (lihat bagian 5.4, [expr.cast]/1). Perilaku default saat opsi ini tidak ditentukan sama seperti di Visual Studio 2012.

Catatan

Untuk fungsi default, menggunakan =default untuk meminta konstruktor pemindahan anggota dan operator penetapan pemindahan tidak didukung.

Pustaka C99

Deklarasi dan implementasi ditambahkan untuk fungsi yang hilang di header ini: math.h, ctype.h, wctype.h, stdio.h, stdlib.h, dan wchar.h. Juga ditambahkan adalah header baru complex.h, stdbool.h, fenv.h, dan inttypes.h, dan implementasi untuk semua fungsi yang dideklarasikan di dalamnya. Ada header pembungkus C++ baru (ccomplex, cfenv, cinttypes, ctgmath) dan sejumlah lainnya diperbarui (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar, dan cwctype).

Pustaka Templat Standar

Dukungan untuk operator konversi eksplisit C++11, daftar inisialisasi, enum tercakup, dan templat variadik. Semua kontainer sekarang mendukung persyaratan elemen halus C++11. Dukungan untuk fitur C++14 ini:

"Funktor operator transparan" lebih sedikit<>, lebih<> besar, plus<>, mengalikan<>, dan sebagainya.
<make_unique T>(args...) dan make_unique<T[]>(n)
fungsi non-anggota cbegin()/cend(), rbegin()/rend(), dan crbegin()/crend().
<atom> menerima banyak peningkatan performa.
<> type_traits menerima stabilisasi utama dan perbaikan kode.

Memecahkan Perubahan

Dukungan yang ditingkatkan untuk standar ISO C/C++ ini mungkin memerlukan perubahan pada kode yang ada sehingga sesuai dengan C++11 dan dikompilasi dengan benar di Visual C++ di Visual Studio 2013.

Penyempurnaan Pustaka Visual C++

C++ REST SDK ditambahkan. Ini memiliki implementasi C++ modern dari layanan REST.
Dukungan Tekstur AMP C++ ditingkatkan. Sekarang termasuk dukungan untuk mipmap dan mode pengambilan sampel baru.
Tugas PPL mendukung beberapa teknologi penjadwalan dan penelusuran kesalahan asinkron. API baru memungkinkan pembuatan tugas PPL untuk hasil normal dan kondisi pengecualian.

Performa Aplikasi C++

Auto-Vectorizer sekarang mengenali dan mengoptimalkan lebih banyak pola C++ untuk membuat kode Anda berjalan lebih cepat.
Platform ARM dan peningkatan kualitas kode arsitektur mikro Atom.
__vectorcall konvensi panggilan ditambahkan. Teruskan argumen jenis vektor dengan menggunakan konvensi panggilan __vectorcall untuk menggunakan register vektor.
Opsi Linker Baru. Sakelar /Gw (pengkompilasi) dan /Gy (perakit) memungkinkan pengoptimalan linker untuk menghasilkan biner yang lebih ramping.
Dukungan memori bersama C++ AMP untuk mengurangi atau menghilangkan penyalinan data antara CPU dan GPU.

Peningkatan Profile Guided Optimization (PGO)

Peningkatan performa dari pengurangan set aplikasi yang berfungsi yang dioptimalkan dengan menggunakan PGO.
PGO baru untuk pengembangan aplikasi Windows Runtime.

Dukungan Pengembangan Aplikasi Runtime Windows

Dukungan Untuk Jenis Kotak Dalam Struktur Nilai.

Anda sekarang dapat menentukan jenis nilai dengan menggunakan bidang yang bisa null—misalnya, IBox<int>^ dibandingkan intdengan . Ini berarti bahwa bidang dapat memiliki nilai, atau sama dengan nullptr.
Informasi Pengecualian yang Lebih Kaya.

C++/CX mendukung model kesalahan Windows baru yang memungkinkan penangkapan dan penyebaran informasi pengecualian yang kaya di seluruh antarmuka biner aplikasi (ABI); ini termasuk tumpukan panggilan dan string pesan kustom.
Object::ToString() sekarang virtual.

Anda sekarang dapat mengganti ToString dalam jenis ref Windows Runtime yang ditentukan pengguna.
Dukungan untuk API yang tidak digunakan lagi.

API Windows Runtime Publik sekarang dapat ditandai sebagai tidak digunakan lagi dan diberi pesan kustom yang muncul sebagai peringatan build dan dapat memberikan panduan migrasi.
Penyempurnaan Debugger.

Dukungan untuk penelusuran kesalahan interop asli/JavaScript, diagnosis pengecualian Windows Runtime, dan penelusuran kesalahan kode asinkron (Baik Windows Runtime maupun PPL).

Catatan

Selain fitur dan penyempurnaan khusus C++yang dijelaskan di bagian ini, penyempurnaan lain di Visual Studio juga dapat membantu Anda menulis aplikasi Windows Runtime yang lebih baik.

Penyempurnaan Diagnostik

Penyempurnaan Debugger. Dukungan untuk penelusuran kesalahan asinkron dan penelusuran kesalahan Just My Code.
Kategori Analisis Kode. Anda sekarang dapat melihat output yang dikategorikan dari Penganalisis Kode untuk membantu Anda menemukan dan memperbaiki cacat kode.
Diagnostik XAML. Anda sekarang dapat mendiagnosis masalah respons UI dan penggunaan baterai di XAML Anda.
Peningkatan Debugging Grafis dan GPU.
Pengambilan jarak jauh dan pemutaran pada perangkat nyata.
Penelusuran kesalahan C++ AMP dan CPU simultan.
Diagnostik runtime C++ AMP yang disempurnakan.
Penelusuran kesalahan pelacakan shader Komputasi HLSL.

Peningkatan Grafis 3-D

Dukungan Alur Konten Gambar untuk format DDS alfa yang telah dikalikan sebelumnya.
Editor Gambar menggunakan alfa yang telah dikalikan secara internal untuk penyajian, dan dengan demikian menghindari penyajian artefak seperti halo gelap.
Editor Gambar dan Model. Pembuatan filter yang ditentukan pengguna sekarang didukung di Shader Designer di Editor Gambar dan Editor Model.

IDE dan Produktivitas

Pemformatan Kode yang Disempurnakan. Anda dapat menerapkan pengaturan pemformatan lainnya ke kode C++Anda. Dengan menggunakan pengaturan ini, Anda dapat mengontrol penempatan kurung kurawal dan kata kunci baris baru, indentasi, penspasian, dan pembungkusan garis. Kode secara otomatis diformat saat Anda menyelesaikan pernyataan dan blok, dan saat Anda menempelkan kode ke dalam file.

Penyelesaian Penjepit. Kode C++ sekarang secara otomatis menyelesaikan karakter penutup yang sesuai dengan karakter pembuka ini:

{ (kurung kurawal)
[ (kurung siku)
(Tanda kurung)
' (kutipan tunggal)
" (kutipan ganda)

Fitur Penyelesaian Otomatis C++ tambahan.

Menambahkan titik koma untuk jenis kelas.
Melengkapi tanda kurung untuk literal string mentah.
Menyelesaikan komentar multibaris (/* */)

Temukan Semua Referensi sekarang secara otomatis menyelesaikan dan memfilter referensi di latar belakang setelah menampilkan daftar kecocokan tekstual.

Pemfilteran Daftar Anggota Berbasis Konteks. Anggota yang tidak dapat diakses difilter dari daftar anggota IntelliSense. Misalnya, anggota privat tidak ditampilkan dalam daftar anggota kecuali Anda memodifikasi kode yang mengimplementasikan jenis tersebut. Saat daftar anggota terbuka, Anda dapat menekan Ctrl+J untuk menghapus satu tingkat pemfilteran (hanya berlaku untuk jendela daftar anggota saat ini). Anda dapat menekan Ctrl+J lagi untuk menghapus pemfilteran tekstual dan memperlihatkan setiap anggota.

Bantuan Parameter Menggulir. Tanda tangan fungsi yang ditampilkan di tipsalat bantuan parameter sekarang berubah berdasarkan jumlah parameter yang benar-benar Anda ketik, daripada hanya menampilkan tanda tangan semena-mena dan tidak memperbaruinya berdasarkan konteks saat ini. Bantuan parameter juga berfungsi dengan benar saat ditampilkan pada fungsi berlapis.

Alihkan File Header/Kode. Anda sekarang dapat beralih antara header dan file kode yang sesuai dengan menggunakan perintah pada menu pintasan, atau pintasan keyboard.

Jendela Properti Proyek C++ yang Dapat Diubah Ukurannya

Pembuatan otomatis Kode Penanganan Aktivitas di C++/CX dan C++/CLI. Saat Anda mengetik kode untuk menambahkan penanganan aktivitas dalam file kode C++/CX atau C++/CLI, editor dapat secara otomatis menghasilkan instans delegasi dan definisi penanganan peristiwa. Jendela tipsalat muncul saat kode penanganan aktivitas dapat dibuat secara otomatis.

Peningkatan Kesadaran DPI. Pengaturan Kesadaran DPI untuk file manifes aplikasi sekarang mendukung pengaturan "Per Monitor High DPI Aware".

Pengalihan Konfigurasi yang Lebih Cepat. Untuk aplikasi besar, beralih konfigurasi—terutama operasi pengalihan berikutnya—jalankan jauh lebih cepat.

Membangun Efisiensi Waktu. Banyak pengoptimalan dan pemanfaatan multi-inti membuat build lebih cepat, terutama untuk proyek besar. Build bertahap untuk aplikasi C++ yang memiliki referensi ke C++ WinMD juga jauh lebih cepat.

Yang Baru untuk C++ di Visual Studio 2012

Dukungan Standar C++11 yang Ditingkatkan

Pustaka Templat Standar

Dukungan untuk header STL baru: <atom>, <chrono>, <condition_variable>, <sistem file>, <masa depan>, <muteks>, <rasio>, dan <utas>.
Untuk mengoptimalkan penggunaan sumber daya memori, kontainer sekarang lebih kecil. Misalnya, dalam mode rilis x86 dengan pengaturan default, std::vector menyusut dari 16 byte di Visual Studio 2010 hingga 12 byte di Visual Studio 2012, dan std::map menyusut dari 16 byte di Visual Studio 2010 menjadi 8 byte di Visual Studio 2012.
Seperti yang diizinkan tetapi tidak diperlukan oleh Standar C++11, iterator SCARY telah diterapkan.

Penyempurnaan C++11 Lainnya

Berbasis rentang untuk perulangan. Anda dapat menulis perulangan yang lebih kuat yang berfungsi dengan array, kontainer STL, dan koleksi Windows Runtime dalam formulir untuk ( untuk deklarasi rentang : ekspresi ). Ini adalah bagian dari dukungan Bahasa Inti.
Lambda stateless, yang merupakan blok kode yang dimulai dengan pengantar lambda kosong [] dan tidak menangkap variabel lokal, sekarang secara implisit dapat dikonversi ke penunjuk fungsi seperti yang diperlukan oleh Standar C++11.

Dukungan enumerasi terlingkup. Enum-key kelas enum C++ sekarang didukung. Kode berikut menunjukkan bagaimana enum-key ini berbeda dari perilaku enum sebelumnya.

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

Dukungan Pengembangan Aplikasi Runtime Windows

Model UI berbasis XAML asli. Untuk aplikasi Windows Runtime, Anda dapat menggunakan model UI berbasis XAML asli baru.
Ekstensi Komponen Visual C++. Ekstensi ini menyederhanakan konsumsi objek Windows Runtime, yang merupakan bagian yang diperlukan dari aplikasi Windows Runtime. Untuk informasi selengkapnya, lihat Peta strategi untuk aplikasi Windows Runtime menggunakan referensi bahasa C++ dan Visual C++ (C++/CX)
Permainan DirectX. Anda dapat mengembangkan game yang menarik dengan menggunakan dukungan DirectX baru untuk aplikasi Windows Runtime.
Interop XAML/DirectX. Aplikasi Windows Runtime yang menggunakan XAML dan DirectX sekarang beroperasi secara efisien.
Pengembangan DLL Komponen Runtime Windows. Pengembangan DLL komponen membuat lingkungan Windows Runtime dapat diperluas.

Pengkompilasi dan Linker

Vektorizer otomatis. Pengkompilasi menganalisis perulangan dalam kode Anda dan, jika memungkinkan, memancarkan instruksi yang menggunakan daftar vektor dan instruksi yang ada di semua prosesor modern. Ini membuat perulangan berjalan lebih cepat. (Instruksi prosesor dikenal sebagai SSE, untuk Ekstensi SIMD Streaming). Anda tidak perlu mengaktifkan atau meminta pengoptimalan ini karena diterapkan secara otomatis.
Paralelizer otomatis. Pengkompilasi dapat menganalisis perulangan dalam kode Anda dan memancarkan instruksi yang menyebarkan perhitungan di beberapa inti atau prosesor. Ini dapat membuat perulangan berjalan lebih cepat. Anda harus meminta pengoptimalan ini karena tidak diaktifkan secara default. Dalam banyak kasus, ini membantu untuk menyertakan #pragma loop(hint_parallel(N)) dalam kode Anda segera sebelum perulangan yang ingin Anda paralelkan.
Vektorizer otomatis dan paralelizer otomatis dapat bekerja sama sehingga perhitungan tersebar di beberapa inti dan kode pada setiap inti menggunakan register vektornya.

Baru di Visual Studio 2012 Update 1

Targetkan Windows XP saat Anda membuat kode C++. Anda dapat menggunakan pengkompilasi dan pustaka Microsoft C++ untuk menargetkan Windows XP dan Windows Server 2003.

Dukungan Pemrograman Paralel

C++ Accelerated Massive Parallelism (AMP)

C++ AMP mempercepat eksekusi kode C++ Anda dengan memanfaatkan perangkat keras paralel data yang biasanya hadir sebagai GPU pada kartu grafis diskrit. Model pemrograman C++ AMP mencakup array multidimensi, pengindeksan, transfer memori, ubin, dan pustaka fungsi matematika. Dengan menggunakan ekstensi bahasa C++ AMP dan pembatasan kompilator, Anda dapat mengontrol bagaimana data dipindahkan dari CPU ke GPU dan kembali.

Debugging. Pengalaman penelusuran kesalahan untuk aplikasi yang menggunakan C++ AMP untuk menargetkan GPU sama seperti penelusuran kesalahan untuk aplikasi C++ lainnya. Ini termasuk penambahan debugging paralel baru yang disebutkan sebelumnya.

Pembuatan Profil. Sekarang ada dukungan pembuatan profil untuk aktivitas GPU yang didasarkan pada C++ AMP dan model pemrograman berbasis Direct3D lainnya.

Peningkatan Pemrograman Paralel Umum

Dengan perangkat keras yang berpindah ke arsitektur multi-inti dan banyak inti, pengembang tidak dapat lagi mengandalkan kecepatan jam yang terus meningkat dari inti tunggal. Dukungan pemrograman paralel dalam Concurrency Runtime memungkinkan pengembang untuk memanfaatkan arsitektur baru ini. Di Visual Studio 2010, pustaka paralelisasi C++ yang kuat seperti Pustaka Pola Paralel diperkenalkan, bersama dengan fitur untuk memanfaatkan konkurensi dengan mengekspresikan alur aliran data yang canggih. Di Visual Studio 2012, pustaka ini telah diperluas untuk memberikan performa yang lebih baik, kontrol yang lebih baik, dan dukungan yang lebih kaya untuk pola paralel yang paling dibutuhkan pengembang. Luasnya penawaran sekarang meliputi:

Model pemrograman berbasis tugas yang kaya yang mendukung asinkron dan kelanjutan.
Algoritma paralel, yang mendukung paralelisme gabungan fork (parallel_for, parallel_for dengan afinitas, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
Kontainer yang aman konkurensi, yang menyediakan versi struktur data std aman utas seperti priority_queue, antrean, vektor, dan peta.
Pustaka Agen Asinkron, yang dapat digunakan pengembang untuk mengekspresikan alur aliran data yang secara alami terurai menjadi unit bersamaan.
Penjadwal dan manajer sumber daya yang dapat disesuaikan untuk memfasilitasi komposisi pola yang lancar dalam daftar ini.

Penyempurnaan Penelusuran Kesalahan Paralel Umum

Selain jendela Tugas Paralel dan jendela Tumpukan Paralel, Visual Studio 2012 menawarkan jendela Parallel Watch baru sehingga Anda dapat memeriksa nilai ekspresi di semua utas dan proses, serta melakukan pengurutan dan pemfilteran pada hasilnya. Anda juga dapat menggunakan visualizer Anda sendiri untuk memperluas jendela, dan Anda dapat memanfaatkan dukungan multi-proses baru di semua jendela alat.

IDE

Dukungan Templat Visual Studio. Sekarang Anda dapat menggunakan teknologi Templat Visual Studio untuk menulis templat proyek dan item C++.

Beban Solusi Asinkron. Proyek sekarang dimuat secara asinkron—bagian utama solusi terlebih dahulu—sehingga Anda dapat mulai bekerja lebih cepat.

Penyebaran otomatis untuk penelusuran kesalahan jarak jauh. Penyebaran file untuk penelusuran kesalahan jarak jauh di Visual C++ telah disederhanakan. Opsi Sebarkan pada menu konteks proyek secara otomatis menyalin ke komputer jarak jauh file yang ditentukan dalam properti konfigurasi penelusuran kesalahan. Menyalin file secara manual ke komputer jarak jauh tidak lagi diperlukan.

C++/CLI IntelliSense. C++/CLI sekarang memiliki dukungan IntelliSense penuh. Fitur IntelliSense seperti Info Cepat, Bantuan Parameter, Anggota Daftar, dan Penyelesaian Otomatis sekarang berfungsi untuk C++/CLI. Selain itu, penyempurnaan IntelliSense dan IDE lainnya yang tercantum dalam dokumen ini juga berfungsi untuk C++/CLI.

TipsAlat IntelliSense yang lebih kaya. Tipsalat C++ IntelliSense Quick Info sekarang menampilkan informasi gaya komentar dokumentasi XML yang lebih kaya. Jika Anda menggunakan API dari pustaka—misalnya, C++ AMP—yang memiliki komentar dokumentasi XML, maka tipsalat IntelliSense menampilkan lebih banyak informasi daripada hanya deklarasi. Selain itu, jika kode Anda memiliki komentar dokumentasi XML, tipsalat IntelliSense akan menampilkan informasi yang lebih kaya.

Konstruksi Kode C++. Kode kerangka tersedia untuk sakelar, jika lain, untuk perulangan, dan konstruksi kode dasar lainnya, di daftar drop-down Anggota Daftar. Pilih bagian kode dari daftar untuk menyisipkannya ke dalam kode Anda lalu isi logika yang diperlukan. Anda juga dapat membuat potongan kode kustom Anda sendiri untuk digunakan di editor.

Mencantumkan Penyempurnaan Anggota. Daftar drop-down Anggota Daftar muncul secara otomatis saat Anda mengetik kode ke editor kode. Hasil difilter, sehingga hanya anggota yang relevan yang ditampilkan saat Anda mengetik. Anda dapat mengontrol jenis logika pemfilteran yang digunakan oleh Daftar Anggota—dalam kotak dialog Opsi di bawah Editor>Teks C/C++>Tingkat Lanjut.

Pewarnaan Semantik. Jenis, enumerasi, makro, dan token C++ lainnya sekarang memiliki pewarnaan secara default.

Penyorotan Referensi. Memilih simbol sekarang menyoroti semua instans simbol dalam file saat ini. Tekan Ctrl+Shift+Panah Atas atau Ctrl+Shift+Panah Bawah untuk berpindah di antara referensi yang disorot. Anda dapat menonaktifkan fitur ini dalam kotak dialog Opsi, di bawah Editor>Teks C/C++>Tingkat Lanjut.

Peralatan Manajemen Siklus Hidup Aplikasi

Analisis Kode Statis

Analisis statis untuk C++ telah diperbarui untuk memberikan informasi konteks kesalahan yang lebih kaya, aturan analisis yang lebih banyak, dan hasil analisis yang lebih baik. Di jendela Analisis Kode baru, Anda dapat memfilter pesan berdasarkan kata kunci, proyek, dan tingkat keparahan. Saat Anda memilih pesan di jendela, baris dalam kode tempat pesan dipicu disorot di editor kode. Untuk peringatan C++ tertentu, pesan mencantumkan baris sumber yang menunjukkan jalur eksekusi yang mengarah ke peringatan; poin keputusan dan alasan untuk mengambil jalur tertentu tersebut disorot. Analisis kode disertakan dalam sebagian besar edisi Visual Studio 2012. Dalam edisi Professional, Premium, dan Ultimate, semua aturan disertakan. Dalam edisi Ekspres untuk Windows 8 dan Windows Phone, hanya peringatan paling penting yang disertakan. Analisis kode tidak disertakan dalam edisi Ekspres untuk Web. Berikut adalah beberapa penyempurnaan analisis kode lainnya:

Peringatan konkurensi baru membantu Anda menghindari bug konkurensi dengan memastikan bahwa Anda menggunakan disiplin penguncian yang benar dalam program C/C++ multithreaded. Penganalisis mendeteksi potensi kondisi balapan, inversi urutan kunci, pelanggaran kontrak penguncian penelepon/callee, operasi sinkronisasi yang tidak cocok, dan bug konkurensi lainnya.
Anda dapat menentukan aturan C++ yang ingin Anda terapkan ke eksekusi analisis kode dengan menggunakan seperangkat aturan.
Di jendela Analisis Kode, Anda dapat menyisipkan ke dalam kode sumber pragma yang menekan peringatan yang dipilih.
Anda dapat meningkatkan akurasi dan kelengkapan analisis kode statis dengan menggunakan versi baru bahasa anotasi kode sumber (SAL) Microsoft untuk menjelaskan bagaimana fungsi menggunakan parameternya, asumsi yang dihasilkannya tentang mereka, dan jaminan yang dihasilkannya ketika selesai.
Dukungan untuk proyek C++ 64bit.

Kerangka Kerja Pengujian Unit yang Diperbarui

Gunakan kerangka kerja pengujian unit C++ baru di Visual Studio untuk menulis pengujian unit C++. Tambahkan proyek pengujian unit baru ke solusi C++ yang sudah ada dengan menemukan templat Proyek Pengujian Unit C++ di bawah kategori Visual C++ dalam kotak dialog Proyek Baru. Mulai tulis pengujian unit Anda di stub kode TEST_METHOD yang dihasilkan dalam file Unittest1.cpp. Saat kode pengujian ditulis, bangun solusinya. Saat Anda ingin menjalankan pengujian, buka jendela Unit Test Explorer dengan memilih Tampilkan>Penjelajah Uji Unit Windows>Lainnya, lalu, pada menu pintasan untuk kasus pengujian yang Anda inginkan, pilih Jalankan pengujian yang dipilih. Setelah uji coba selesai, Anda dapat melihat hasil pengujian dan informasi pelacakan tumpukan tambahan di jendela yang sama.

Grafik Dependensi Arsitektur

Untuk memahami kode Anda dengan lebih baik, Anda sekarang dapat menghasilkan grafik dependensi untuk biner, kelas, namespace layanan, dan menyertakan file dalam solusi. Pada bilah menu, pilih Arsitektur>Hasilkan Grafik Dependensi, lalu Untuk Solusi atau Untuk Sertakan File untuk menghasilkan grafik dependensi. Setelah pembuatan grafik selesai, Anda dapat menjelajahinya dengan memperluas setiap simpul, mempelajari hubungan dependensi dengan berpindah antar simpul, dan menelusuri kode sumber dengan memilih Tampilkan Konten pada menu pintasan untuk simpul. Untuk menghasilkan grafik dependensi untuk menyertakan file, pada menu pintasan untuk *.cpp file kode sumber atau file header *.h, pilih Hasilkan Grafik Sertakan File.

Penjelajah Arsitektur

Dengan menggunakan Architecture Explorer, Anda dapat menjelajahi aset di solusi C++, proyek, atau file Anda. Pada bilah menu, pilih Arsitektur>Windows>Architecture Explorer. Anda dapat memilih simpul yang Anda minati, misalnya, Tampilan Kelas. Dalam hal ini, sisi kanan jendela alat diperluas dengan daftar namespace layanan. Jika Anda memilih namespace layanan, kolom baru menampilkan daftar kelas, struktur, dan enum di namespace ini. Anda dapat terus menjelajahi aset ini, atau kembali ke kolom di ujung kiri untuk memulai kueri lain. Lihat Menemukan Kode dengan Penjelajah Arsitektur.

Cakupan Kode

Cakupan kode telah diperbarui ke biner instrumen dinamis saat runtime. Ini menurunkan overhead konfigurasi dan memberikan performa yang lebih baik. Anda juga dapat mengumpulkan data cakupan kode dari pengujian unit untuk aplikasi C++. Setelah membuat pengujian unit C++, Anda dapat menggunakan Unit Test Explorer untuk menemukan pengujian dalam solusi Anda. Untuk menjalankan pengujian unit dan mengumpulkan data cakupan kode untuk mereka, di Unit Test Explorer, pilih Analisis Cakupan Kode. Anda dapat memeriksa hasil cakupan kode di jendela Hasil Cakupan Kode—di bilah menu, pilih Uji>Hasil Cakupan Kode Windows>.

Yang Baru untuk C++ di Visual Studio 2010

C++ Compiler dan Linker

kata kunci otomatis. Kata auto kunci memiliki tujuan baru. Gunakan arti default kata auto kunci untuk mendeklarasikan variabel yang jenisnya disimpulkan dari ekspresi inisialisasi dalam deklarasi variabel. Opsi /Zc:auto pengkompilasi memanggil arti baru atau sebelumnya dari auto kata kunci.

decltype Type Specifier. Penentu decltype jenis mengembalikan jenis ekspresi yang ditentukan. Gunakan penentu decltype jenis dalam kombinasi dengan auto kata kunci untuk mendeklarasikan jenis yang kompleks atau hanya diketahui oleh pengkompilasi. Misalnya, gunakan kombinasi untuk mendeklarasikan fungsi templat yang jenis pengembaliannya bergantung pada jenis argumen templatnya. Atau, deklarasikan fungsi templat yang memanggil fungsi lain, lalu mengembalikan jenis pengembalian fungsi yang disebut.

Ekspresi Lambda. Fungsi Lambda memiliki isi fungsi tetapi tidak ada nama. Fungsi Lambda menggabungkan karakteristik terbaik penunjuk fungsi dan objek fungsi. Gunakan fungsi lambda dengan sendirinya, sebagai parameter fungsi templat alih-alih objek fungsi, atau bersama dengan auto kata kunci untuk mendeklarasikan variabel yang jenisnya adalah lambda.

Referensi Rvalue. Deklarator referensi rvalue (&&&) mendeklarasikan referensi ke rvalue. Referensi rvalue memungkinkan Anda menggunakan semantik pemindahan dan penerusan sempurna untuk menulis konstruktor, fungsi, dan templat yang lebih efisien.

static_assert Deklarasi. static_assert Deklarasi menguji pernyataan perangkat lunak pada waktu kompilasi, tidak seperti mekanisme pernyataan lain yang menguji pada waktu proses. Jika pernyataan gagal, kompilasi gagal dan pesan kesalahan yang ditentukan dikeluarkan.

nullptr dan __nullptr Kata Kunci. MSVC memungkinkan Anda menggunakan nullptr kata kunci dengan kode asli atau dengan kode terkelola. Kata nullptr kunci menunjukkan bahwa handel objek, penunjuk interior, atau jenis penunjuk asli tidak menunjuk ke objek. Pengkompilasi menafsirkan nullptr untuk menjadi kode terkelola saat Anda menggunakan /clr opsi pengkompilasi, dan kode asli saat Anda tidak menggunakan opsi ./clr Kata kunci __nullptr khusus Microsoft memiliki arti yang sama seperti nullptr, tetapi hanya berlaku untuk kode asli. Jika Anda mengkompilasi kode C/C++ asli dengan menggunakan /clr opsi pengkompilasi, pengkompilasi tidak dapat menentukan apakah nullptr kata kunci adalah istilah asli atau terkelola. Untuk memperjelas niat Anda kepada pengkompilasi, gunakan kata kunci nullptr untuk menentukan istilah terkelola, dan __nullptr untuk menentukan istilah asli.

/Zc:trigraphs Opsi Pengkompilasi. Secara default, dukungan untuk trigraf dinonaktifkan. /Zc:trigraphs Gunakan opsi pengkompilasi untuk mengaktifkan dukungan trigraf. Trigraf terdiri dari dua tanda tanya berturut-turut (??) diikuti oleh karakter ketiga yang unik. Pengkompilasi menggantikan trigraf dengan karakter tanda baca yang sesuai. Misalnya, pengkompilasi menggantikan ?? = trigraf dengan karakter # (tanda angka). Gunakan trigraf dalam file sumber C yang menggunakan kumpulan karakter yang tidak berisi karakter tanda baca tertentu.

Opsi Pengoptimalan Yang Dipandu Profil Baru. PogoSafeMode adalah opsi pengoptimalan baru yang dipandu profil yang memungkinkan Anda menentukan apakah akan menggunakan mode aman atau mode cepat saat mengoptimalkan aplikasi. Mode aman aman untuk utas, tetapi lebih lambat dari mode cepat. Mode cepat adalah perilaku default.

Opsi Common Language Runtime (CLR) Baru /clr:nostdlib. Opsi baru ditambahkan untuk /clr (Kompilasi Runtime Bahasa Umum). Jika versi yang berbeda dari pustaka yang sama disertakan, kesalahan kompilasi dikeluarkan. Opsi baru memungkinkan Anda mengecualikan pustaka CLR default sehingga program Anda dapat menggunakan versi yang ditentukan.

Direktif pragma baru detect_mismatch. Direktif pragma detect_mismatch memungkinkan Anda menempatkan tag di file Anda yang dibandingkan dengan tag lain yang memiliki nama yang sama. Jika ada beberapa nilai untuk nama yang sama, linker akan mengeluarkan kesalahan.

Intrinsik XOP, Intrinsik FMA4, dan Intrinsik LWP. Fungsi intrinsik baru telah ditambahkan untuk mendukung Intrinsik XOP Ditambahkan untuk Visual Studio 2010 SP1, Intrinsik FMA4 Ditambahkan untuk Visual Studio 2010 SP1, dan Intrinsik LWP Ditambahkan untuk teknologi prosesor Visual Studio 2010 SP1. Gunakan __cpuid, __cpuidex untuk menentukan teknologi prosesor mana yang didukung pada komputer tertentu.

Proyek Visual Studio C++ dan Sistem Build

MSBuild. Solusi dan proyek Visual C++ sekarang dibangun dengan menggunakan MSBuild.exe, yang menggantikan VCBuild.exe. MSBuild adalah alat build berbasis XML yang fleksibel, dapat diperluas, dan sama yang digunakan oleh bahasa dan jenis proyek Visual Studio lainnya. Karena perubahan ini, file proyek Visual Studio C++ sekarang menggunakan format file XML dan memiliki ekstensi nama file .vcxproj. File proyek Visual Studio C++ dari versi Visual Studio yang lebih lama secara otomatis dikonversi ke format file baru.

Direktori VC++. Pengaturan direktori VC++ sekarang terletak di dua tempat. Gunakan halaman properti proyek untuk mengatur nilai per proyek untuk direktori VC++. Gunakan Pengelola Properti dan lembar properti untuk mengatur nilai global per konfigurasi untuk direktori VC++.

Dependensi Proyek-ke-Proyek. Dalam rilis sebelumnya, dependensi yang ditentukan antara proyek disimpan dalam file solusi. Ketika solusi ini dikonversi ke format file proyek baru, dependensi dikonversi ke referensi proyek-ke-proyek. Perubahan ini dapat memengaruhi aplikasi karena konsep dependensi solusi dan referensi proyek-ke-proyek berbeda.

Makro dan Variabel Lingkungan. Makro _ITERATOR_DEBUG_LEVEL baru memanggil dukungan debugging untuk iterator. Gunakan makro ini alih-alih makro _SECURE_SCL dan _HAS_ITERATOR_DEBUGGING yang lebih lama.

Pustaka Visual C++

Pustaka Runtime Konkurensi. Kerangka kerja Concurrency Runtime mendukung aplikasi dan komponen yang berjalan secara bersamaan, dan merupakan kerangka kerja untuk memprogram aplikasi bersamaan di Visual C++. Untuk mendukung pemrograman aplikasi bersamaan, Parallel Patterns Library (PPL) menyediakan kontainer dan algoritma tujuan umum untuk melakukan paralelisme terperinci. Pustaka Agen Asinkron menyediakan model pemrograman berbasis aktor dan antarmuka passing pesan untuk aliran data dan tugas alur yang kasar.

Pustaka C++ Standar. Daftar berikut ini menjelaskan banyak perubahan yang telah dilakukan pada Pustaka C++ Standar.

Fitur bahasa C++ referensi rvalue baru telah digunakan untuk mengimplementasikan semantik pemindahan dan penerusan yang sempurna untuk banyak fungsi di Pustaka Templat Standar. Memindahkan semantik dan penerusan sempurna sangat meningkatkan performa operasi yang mengalokasikan atau menetapkan variabel atau parameter.
Referensi Rvalue juga digunakan untuk mengimplementasikan kelas baru unique_ptr , yang merupakan jenis penunjuk cerdas yang lebih aman daripada auto_ptr kelas . Kelas unique_ptr ini dapat bergerak tetapi tidak dapat disalin, menerapkan semantik kepemilikan yang ketat tanpa memengaruhi keamanan, dan bekerja dengan baik dengan kontainer yang menyadari referensi rvalue. Kelas auto_ptr tidak digunakan lagi.
Lima belas fungsi baru, misalnya, , find_if_not, copy_ifdan is_sorted, telah ditambahkan ke <header algoritma> .
<Di header memori>, fungsi make_shared baru adalah cara yang nyaman, kuat, dan efisien untuk membuat pointer bersama ke objek pada saat yang sama objek dibangun.
Daftar yang ditautkan secara senyap didukung oleh <header forward_list> .
Fungsi anggota , , crbegincend, dan crend baru cbeginmenyediakan const_iterator yang bergerak maju atau mundur melalui kontainer.
Header <system_error> dan templat terkait mendukung pemrosesan kesalahan sistem tingkat rendah. Anggota exception_ptr kelas dapat digunakan untuk mengangkut pengecualian antar utas.
Header <codecvt> mendukung konversi berbagai pengodean karakter Unicode ke pengodean lain.
Header <alokator> menentukan beberapa templat yang membantu mengalokasikan dan membebaskan blok memori untuk kontainer berbasis simpul.
Ada banyak pembaruan untuk <header acak> .

Pustaka Microsoft Foundation Class (MFC)

Fitur Windows 7. MFC mendukung banyak fitur Windows 7, misalnya, antarmuka pengguna Pita (UI), Taskbar, jump list, gambar mini bertab, pratinjau gambar mini, bilah kemajuan, overlay ikon, dan pengindeksan pencarian. Karena MFC secara otomatis mendukung banyak fitur Windows 7, Anda mungkin tidak perlu memodifikasi aplikasi yang ada. Untuk mendukung fitur lain dalam aplikasi baru, gunakan MFC Application Wizard untuk menentukan fungsionalitas yang ingin Anda gunakan.

Kesadaran multi-sentuh. MFC mendukung aplikasi yang memiliki antarmuka pengguna multi-sentuh, misalnya, aplikasi yang ditulis untuk sistem operasi Microsoft Surface. Aplikasi multi-sentuh dapat menangani pesan sentuhan Windows dan pesan gerakan, yang merupakan kombinasi pesan sentuhan. Cukup daftarkan aplikasi Anda untuk peristiwa sentuhan dan gerakan dan sistem operasi akan merutekan peristiwa multi-sentuh ke penanganan aktivitas Anda.

Kesadaran DPI tinggi. Secara default, aplikasi MFC sekarang sadar akan DPI tinggi. Jika aplikasi sadar DPI Tinggi (titik tinggi per inci), sistem operasi dapat menskalakan jendela, teks, dan elemen UI lainnya ke resolusi layar saat ini. Ini berarti bahwa gambar berskala lebih mungkin ditata dengan benar, dan tidak diklip atau dikorekselasi.

Hidupkan ulang Manajer. Manajer mulai ulang secara otomatis menyimpan dokumen dan memulai ulang aplikasi Anda jika tiba-tiba ditutup atau dimulai ulang. Misalnya, Anda dapat menggunakan manajer hidupkan ulang untuk memulai aplikasi Anda setelah ditutup oleh pembaruan otomatis. Untuk informasi selengkapnya tentang cara mengonfigurasi aplikasi Anda untuk menggunakan manajer hidupkan ulang, lihat Cara: Menambahkan Dukungan Restart Manager.

CTaskDialog. Kelas CTaskDialog dapat digunakan alih-alih kotak pesan standar AfxMessageBox . Kelas CTaskDialog menampilkan dan mengumpulkan lebih banyak informasi daripada kotak pesan standar.

SafeInt Library

Pustaka SafeInt baru melakukan operasi aritmatika aman yang memperhitungkan luapan bilangan bulat. Pustaka ini juga membandingkan berbagai jenis bilangan bulat.

Makro Pustaka Templat Aktif (ATL) Baru

Makro baru telah ditambahkan ke ATL untuk memperluas fungsionalitas PROP_ENTRY_TYPE dan PROP_ENTRY_TYPE_EX. PROP_ENTRY_INTERFACE dan PROP_ENTRY_INTERFACE_EX memungkinkan Anda menambahkan daftar CLSID yang valid. PROP_ENTRY_INTERFACE_CALLBACK dan PROP_ENTRY_INTERFACE_CALLBACK_EX memungkinkan Anda menentukan fungsi panggilan balik untuk menentukan apakah CLSID valid.

/analyze Warnings

Sebagian besar /analyze peringatan (Analisis Kode Perusahaan) telah dihapus dari pustaka C Run-Time (CRT), MFC, dan ATL.

Dukungan Animasi dan D2D

MFC sekarang mendukung animasi dan grafik Direct2D. Pustaka MFC memiliki beberapa kelas dan fungsi MFC baru untuk mendukung fungsionalitas ini. Ada juga dua panduan baru untuk menunjukkan cara menambahkan objek D2D dan objek animasi ke proyek. Panduan ini adalah Panduan: Menambahkan Objek D2D ke Proyek dan Panduan MFC: Menambahkan Animasi ke Proyek MFC.

IDE

IntelliSense yang ditingkatkan. IntelliSense untuk Visual C++ telah sepenuhnya dirancang ulang agar lebih cepat, lebih akurat, dan dapat menangani proyek yang lebih besar. Untuk mencapai peningkatan ini, IDE membuat perbedaan antara bagaimana pengembang melihat dan memodifikasi kode sumber, dan bagaimana IDE menggunakan kode sumber dan pengaturan proyek untuk membangun solusi. Karena pemisahan tugas ini, fitur penjelajahan seperti Tampilan Kelas dan kotak dialog Navigasi Ke baru ditangani oleh sistem yang didasarkan pada file database desktop SQL Server (.sdf) baru yang menggantikan file lama tanpa compile browse (.ncb). Fitur IntelliSense seperti Informasi Cepat, Penyelesaian Otomatis, dan Bantuan Parameter mengurai unit terjemahan hanya jika diperlukan. Fitur hibrid seperti jendela Hierarki Panggilan baru menggunakan kombinasi fitur telusuri dan IntelliSense. Karena IntelliSense hanya memproses informasi yang Anda butuhkan saat ini, IDE lebih responsif. Selain itu, karena informasi lebih terbaru, tampilan IDE dan jendela lebih akurat. Akhirnya, karena infrastruktur IDE lebih terorganisir, lebih mampu, dan lebih dapat diskalakan, infrastruktur tersebut dapat menangani proyek yang lebih besar.

Kesalahan IntelliSense yang Ditingkatkan. IDE lebih baik mendeteksi kesalahan yang dapat menyebabkan hilangnya IntelliSense dan menampilkan garis bawah bergelombang merah di bawahnya. Selain itu, IDE melaporkan kesalahan IntelliSense ke Jendela Daftar Kesalahan. Untuk menampilkan kode yang menyebabkan masalah, klik dua kali kesalahan di Jendela Daftar Kesalahan.

#include Fitur Lengkapi Otomatis. IDE mendukung penyelesaian otomatis untuk #include kata kunci. Saat Anda mengetik #include, IDE membuat kotak daftar drop-down file header yang valid. Jika Anda melanjutkan dengan mengetik nama file, IDE akan memfilter daftar berdasarkan entri Anda. Kapan saja, Anda dapat memilih dari daftar file yang ingin Anda sertakan. Ini memungkinkan Anda dengan cepat menyertakan file tanpa mengetahui nama file yang tepat.

Navigasi ke. Kotak dialog Navigasi ke memungkinkan Anda mencari semua simbol dan file dalam proyek Anda yang cocok dengan string tertentu. Hasil pencarian segera direvisi saat Anda mengetik karakter tambahan dalam string pencarian Anda. Bidang Umpan balik hasil memberi tahu Anda jumlah item yang ditemukan dan membantu Anda memutuskan apakah akan membatasi pencarian Anda. Bidang umpan balik Jenis/Cakupan, Lokasi, dan Pratinjau membantu Anda membedakan item yang memiliki nama serupa. Selain itu, Anda dapat memperluas fitur ini untuk mendukung bahasa pemrograman lainnya.

Debugging dan Pembuatan Profil Paralel. Debugger Visual Studio mengetahui Runtime Konkurensi dan membantu Anda memecahkan masalah aplikasi pemrosesan paralel. Anda dapat menggunakan alat profiler konkurensi baru untuk memvisualisasikan perilaku keseluruhan aplikasi Anda. Selain itu, Anda dapat menggunakan jendela alat baru untuk memvisualisasikan status tugas dan tumpukan panggilannya.

Desainer Pita. Perancang Pita adalah editor grafis yang memungkinkan Anda membuat dan memodifikasi UI pita MFC. UI pita akhir diwakili oleh file sumber daya berbasis XML (.mfcribbon-ms). Untuk aplikasi yang sudah ada, Anda dapat mengambil UI pita Anda saat ini dengan menambahkan beberapa baris kode untuk sementara waktu lalu memanggil Perancang Pita. Setelah file sumber daya pita dibuat, Anda bisa mengganti kode UI pita tulisan tangan Anda dengan beberapa pernyataan yang memuat sumber daya pita.

Panggil Hierarki. Jendela Hierarki Panggilan memungkinkan Anda menavigasi ke semua fungsi yang dipanggil oleh fungsi tertentu, atau ke semua fungsi yang memanggil fungsi tertentu.

Alat

Wizard Kelas MFC. Visual C++ 2010 menghadirkan kembali alat Wizard Kelas MFC yang terpandang. MFC Class Wizard adalah cara mudah untuk menambahkan kelas, pesan, dan variabel ke proyek tanpa harus memodifikasi set file sumber secara manual.

Wizard Kontrol ATL. Wizard Kontrol ATL tidak lagi secara otomatis mengisi ProgID bidang. Jika kontrol ATL tidak memiliki ProgID, alat lain mungkin tidak berfungsi dengannya. Salah satu contoh alat yang mengharuskan kontrol memiliki ProgID adalah kotak dialog Sisipkan Kontrol Aktif. Untuk informasi selengkapnya tentang kotak dialog, lihat Menyisipkan kontrol ActiveX.

Referensi Perakitan Makro Microsoft

Penambahan jenis data YMMWORD mendukung operand multimedia 256-bit yang disertakan dalam instruksi Intel Advanced Vector Extensions (AVX).

Yang Baru untuk C++ di Visual Studio 2008

Visual C++ Integrated Development Environment (IDE)

Kotak dialog yang dibuat di aplikasi ATL, MFC, dan Win32 sekarang sesuai dengan panduan gaya Windows Vista. Saat Anda membuat proyek baru dengan menggunakan Visual Studio 2008, semua kotak dialog yang Anda sisipkan ke dalam aplikasi Anda akan sesuai dengan pedoman gaya Windows Vista. Jika Anda mengkompilasi ulang proyek yang Anda buat dengan versi Visual Studio yang lebih lama, kotak dialog apa pun yang ada akan mempertahankan tampilan yang sama dengan yang sebelumnya mereka miliki. Untuk informasi selengkapnya tentang cara menyisipkan kotak dialog ke dalam aplikasi Anda, lihat Editor Dialog.
Wizard Proyek ATL sekarang memiliki opsi untuk mendaftarkan komponen untuk semua pengguna. Dimulai dengan Visual Studio 2008, komponen COM dan pustaka jenis yang dibuat oleh wizard Proyek ATL terdaftar di simpul HKEY_CURRENT_USER registri kecuali Anda memilih Daftarkan komponen untuk semua pengguna.
Wizard Proyek ATL tidak lagi menyediakan opsi untuk membuat proyek ATL yang diatribusikan. Dimulai dengan Visual Studio 2008, wizard Proyek ATL tidak memiliki opsi untuk mengubah status atribut proyek baru. Semua proyek ATL baru yang dibuat wizard sekarang tidak terganggu.
Menulis ke registri dapat dialihkan. Dengan pengenalan Windows Vista, menulis ke area tertentu dari registri memerlukan program untuk berjalan dalam mode yang ditinggikan. Tidak diinginkan untuk selalu menjalankan Visual Studio dalam mode yang ditingkatkan. Pengalihan per pengguna secara otomatis mengalihkan penulisan registri dari HKEY_CLASSES_ROOT ke HKEY_CURRENT_USER tanpa perubahan pemrograman apa pun.
Perancang Kelas sekarang memiliki dukungan terbatas untuk kode C++ asli. Di versi Visual Studio sebelumnya, Perancang Kelas hanya berfungsi dengan Visual C# dan Visual Basic. Pengguna C++ sekarang dapat menggunakan Perancang Kelas, tetapi hanya dalam mode baca-saja. Untuk informasi selengkapnya tentang cara menggunakan Perancang Kelas dengan C++, lihat Bekerja dengan Visual C++ Code di Perancang Kelas.
Wizard proyek tidak lagi memiliki opsi untuk membuat proyek C++ SQL Server. Dimulai dengan Visual Studio 2008, wizard proyek baru tidak memiliki opsi untuk membuat proyek C++ SQL Server. Proyek SQL Server yang dibuat dengan menggunakan versi Visual Studio yang lebih lama masih akan dikompilasi dan berfungsi dengan benar.

Pustaka Visual C++

Umum

Aplikasi dapat terikat ke versi tertentu dari pustaka Visual C++. Terkadang aplikasi bergantung pada pembaruan yang dibuat ke pustaka Visual C++ setelah rilis. Dalam hal ini, menjalankan aplikasi di komputer yang memiliki versi pustaka yang lebih lama dapat menyebabkan perilaku yang tidak terduga. Anda sekarang dapat mengikat aplikasi ke versi pustaka tertentu sehingga tidak akan berjalan di komputer yang memiliki versi pustaka yang lebih lama.

Pustaka STL/CLR

Visual C++ sekarang menyertakan PUSTAKA STL/CLR. Pustaka STL/CLR adalah kemasan Pustaka Templat Standar (STL), subset Pustaka C++ Standar, untuk digunakan dengan C++ dan runtime bahasa umum .NET Framework (CLR). Dengan STL/CLR, Anda sekarang dapat menggunakan semua kontainer, iterator, dan algoritma STL di lingkungan terkelola.

Pustaka MFC

Windows Vista mendukung Kontrol Umum. Lebih dari 150 metode dalam 18 kelas baru atau yang sudah ada telah ditambahkan untuk mendukung fitur di Windows Vista, atau untuk meningkatkan fungsionalitas di kelas MFC saat ini.
Kelas baru CNetAddressCtrl memungkinkan Anda untuk memasukkan dan memvalidasi alamat IPv4 dan IPv6 atau nama DNS.
Kelas baru CPagerCtrl menyederhanakan penggunaan kontrol pager Windows.
Kelas baru CSplitButton menyederhanakan penggunaan kontrol tombol terpisah Windows untuk memilih tindakan default atau opsional.

Pustaka Dukungan C++

C++ memperkenalkan pustaka marshaling. Pustaka marshaling menyediakan cara yang mudah dan dioptimalkan untuk marshal data antara lingkungan asli dan terkelola. Pustaka adalah alternatif untuk pendekatan yang lebih kompleks dan kurang efisien seperti Menggunakan PInvoke. Lihat Gambaran Umum Marshaling di C++ untuk informasi selengkapnya.

ATL Server

ATL Server dirilis sebagai proyek sumber bersama.
Sebagian besar basis kode ATL Server telah dirilis sebagai proyek sumber bersama di CodePlex dan tidak diinstal sebagai bagian dari Visual Studio 2008. Beberapa file yang terkait dengan ATL Server tidak lagi menjadi bagian dari Visual Studio. Untuk daftar file yang dihapus, lihat File Server ATL yang Dihapus.
Kelas pengodean dan pendekodean data dari atlenc.h dan fungsi utilitas dan kelas dari atlutil.h dan atlpath.h sekarang menjadi bagian dari pustaka ATL.
Microsoft akan terus mendukung versi ATL Server yang disertakan dalam rilis Visual Studio sebelumnya selama versi Visual Studio tersebut didukung. CodePlex akan melanjutkan pengembangan kode ATL Server sebagai proyek komunitas. Microsoft tidak mendukung versi CodePlex dari ATL Server.

Pengkompilasi dan Pengtaut Visual C++

Perubahan Pengkompilasi

Kompiler mendukung build inkremental terkelola. Saat Anda menentukan opsi ini, pengkompilasi tidak akan mengkompilasi ulang kode saat rakitan yang direferensikan berubah. Sebaliknya, ia akan melakukan build inkremental. File dikompilasi ulang hanya jika perubahan memengaruhi kode dependen.
Atribut yang terkait dengan ATL Server tidak lagi didukung. Pengkompilasi tidak lagi mendukung beberapa atribut yang terkait langsung dengan ATL Server. Untuk daftar lengkap atribut yang dihapus, lihat Melanggar Perubahan.
Kompiler mendukung mikroarsitektur Intel Core. Kompiler berisi penyetelan untuk microarchitecture Intel Core selama pembuatan kode. Secara default, penyetelan ini aktif dan tidak dapat dinonaktifkan karena juga membantu Pentium 4 dan prosesor lainnya.
Intrinsik mendukung prosesor AMD dan Intel yang lebih baru. Beberapa instruksi intrinsik baru mendukung fungsionalitas yang lebih besar dalam prosesor AMD dan Intel yang lebih baru. Untuk informasi selengkapnya tentang intrinsik baru, lihat Instruksi Ekstensi SIMD Streaming Tambahan 3, Instruksi 4 Ekstensi SIMD Streaming, SSE4A dan Intrinsik Manipulasi Bit Tingkat Lanjut, Intrinsik AES, _mm_clmulepi64_si128, dan __rdtscp.
Fungsi diperbarui __cpuid . Fungsi __cpuid, __cpuidex sekarang mendukung beberapa fitur baru dari revisi terbaru prosesor AMD dan Intel. Intrinsik __cpuidex ini baru dan mengumpulkan lebih banyak informasi dari prosesor terbaru.
Opsi /MP kompilator mengurangi total waktu build. Opsi ini /MP dapat secara signifikan mengurangi total waktu untuk mengompilasi beberapa file sumber dengan membuat beberapa proses yang mengompilasi file secara bersamaan. Opsi ini sangat berguna pada komputer yang mendukung hyperthreading, beberapa prosesor, atau beberapa inti.
Opsi /Wp64 pengkompilasi dan __w64 kata kunci tidak digunakan lagi. Opsi /Wp64 pengkompilasi dan __w64 kata kunci, yang mendeteksi masalah portabilitas 64-bit, tidak digunakan lagi dan akan dihapus dalam versi kompilator di masa mendatang. Alih-alih opsi dan kata kunci pengkompilasi ini, gunakan MSVC yang menargetkan platform 64-bit.
/Qfast_transcendentals menghasilkan kode sebaris untuk fungsi transendental.
/Qimprecise_fwaits menghapus perintah fwait internal untuk mencoba blok saat Anda menggunakan /fp:except opsi pengkompilasi.

Perubahan Linker

Informasi Kontrol Akun Pengguna sekarang disematkan ke dalam file manifes untuk executable oleh linker Visual C++ (link.exe). Fitur ini diaktifkan secara default. Untuk informasi selengkapnya tentang cara menonaktifkan fitur ini, atau cara mengubah perilaku default, lihat /MANIFESTUAC (Menyematkan informasi UAC dalam manifes).
Linker sekarang memiliki /DYNAMICBASE opsi untuk mengaktifkan fitur Pengacakan Tata Letak Ruang Alamat Windows Vista. Opsi ini memodifikasi header yang dapat dieksekusi untuk menunjukkan apakah aplikasi harus diabas ulang secara acak pada waktu pemuatan.

Yang Baru untuk C++ di Visual Studio 2005

Fitur berikut ini baru dalam Visual C++ 2005 Service Pack 1:

Intrinsik untuk x86 dan x64

__halt
__lidt
__nop
__readcr8
__sidt
__svm_clgi
__svm_invlpga
__svm_skinit
__svm_stgi
__svm_vmload
__svm_vmrun
__svm_vmsave
__ud2
__vmx_off
__vmx_vmptrst
__writecr8

Intrinsik untuk x64 Saja

__vmx_on
__vmx_vmclear
__vmx_vmlaunch
__vmx_vmptrld
__vmx_vmread
__vmx_vmresume
__vmx_vmwrite

Kata Kunci Bahasa Baru

__sptr, __uptr

Fitur Pengkompilasi Baru

Pengkompilasi memiliki perubahan yang melanggar dalam rilis ini.

64-bit asli dan lintas kompilator.
/analyze Opsi pengkompilasi (Analisis Kode Perusahaan) telah ditambahkan.
/bigobj opsi pengkompilasi telah ditambahkan.
/clr:pure, /clr:safe, dan /clr:oldSyntax telah ditambahkan. (Kemudian tidak digunakan lagi di Visual Studio 2015 dan dihapus di Visual Studio 2017.)
Opsi pengkompilasi yang tidak digunakan lagi: banyak opsi kompilator tidak digunakan lagi dalam rilis ini; lihat Opsi Pengkompilasi yang Tidak Digunakan Lagi untuk informasi selengkapnya.
Pengintaian ganda dalam kode berkurang /clr ; lihat Double Thunking (C++) untuk informasi selengkapnya.
/EH (Model Penanganan Pengecualian) atau /EHs tidak dapat lagi digunakan untuk menangkap pengecualian yang dinaikkan dengan sesuatu selain lemparan; gunakan /EHa.
/errorReport (Laporkan Kesalahan Kompilator Internal) opsi pengkompilasi telah ditambahkan.
/favor (Optimalkan untuk 64) opsi pengkompilasi telah ditambahkan.
/FA, /Fa opsi pengkompilasi (File Daftar) telah ditambahkan.
/FC (Jalur Lengkap File Kode Sumber dalam Diagnostik) opsi pengkompilasi telah ditambahkan.
/fp (Tentukan opsi kompilator Perilaku Titik Mengambang) telah ditambahkan.
/G (Optimalkan untuk Prosesor) Opsi pengkompilasi opsi telah ditambahkan.
/G (Optimalkan untuk Prosesor) Opsi pengkompilasi opsi telah ditambahkan.
/G3, /G4, /G5, /G6, /G7, dan /GB opsi pengkompilasi telah dihapus. Pengkompilasi sekarang menggunakan "model campuran" yang mencoba membuat file output terbaik untuk semua arsitektur.
/Gf telah dihapus. Gunakan /GF (Hilangkan String Duplikat) sebagai gantinya.
/GL (Pengoptimalan Seluruh Program) sekarang kompatibel dengan /CLRHEADER.
/GR sekarang aktif secara default.
/GS (Pemeriksaan Keamanan Buffer) sekarang memberikan perlindungan keamanan untuk parameter pointer yang rentan. /GS sekarang aktif secara default. /GS sekarang juga berfungsi pada fungsi yang dikompilasi ke MSIL dengan /clr (Kompilasi Runtime Bahasa Umum).
/homeparams Opsi pengkompilasi (Salin Daftarkan Parameter ke Tumpukan) telah ditambahkan.
/hotpatch Opsi pengkompilasi (Buat Gambar Hotpatchable) telah ditambahkan.
Heuristik fungsi sebaris telah diperbarui; lihat inline, __inline, __forceinline dan inline_depth untuk informasi selengkapnya
Banyak fungsi intrinsik baru telah ditambahkan, dan banyak intrinsik yang sebelumnya tidak terdokumentasi sekarang didokumentasikan.
Secara default, setiap panggilan ke baru yang gagal akan melemparkan pengecualian.
/ML dan /MLd opsi pengkompilasi telah dihapus. Visual C++ tidak lagi mendukung dukungan pustaka CRT tunggal yang ditautkan secara statis.
Pengkompilasi menerapkan Pengoptimalan Nilai Pengembalian Bernama, yang diaktifkan saat Anda mengkompilasi dengan /O1, /O2 (Minimalkan Ukuran, Maksimalkan Kecepatan), /Og (Pengoptimalan Global), dan /Ox (Pengoptimalan Penuh).
/Oa opsi pengkompilasi telah dihapus tetapi akan diabaikan secara diam-diam; gunakan pengubah noalias atau restrict__declspec untuk menentukan bagaimana pengkompilasi melakukan aliasing.
/Op opsi pengkompilasi telah dihapus. Gunakan /fp (Tentukan Perilaku Titik Mengambang) sebagai gantinya.
OpenMP sekarang didukung oleh Visual C++.
/openmp (Aktifkan Dukungan OpenMP 2.0) opsi pengkompilasi telah ditambahkan.
/Ow opsi pengkompilasi telah dihapus tetapi akan diabaikan secara diam-diam. Gunakan pengubah noalias atau restrict__declspec untuk menentukan bagaimana pengkompilasi melakukan alias.

Pengoptimalan Yang Dipandu Profil

/QI0f telah dihapus.
/QIfdiv telah dihapus.
/QIPF_B Opsi pengkompilasi (Errata for B CPU Stepping) telah ditambahkan.
/QIPF_C Opsi pengkompilasi (Errata untuk CPU Stepping) telah ditambahkan.
/QIPF_fr32 (Jangan Gunakan Opsi pengkompilasi Upper 96 Floating Point Registers) telah ditambahkan.
/QIPF_noPIC Opsi pengkompilasi (Hasilkan Kode Dependen Posisi) telah ditambahkan.
/QIPF_restrict_plabels (Asumsikan Tidak Ada Fungsi yang Dibuat pada Run Time) opsi pengkompilasi telah ditambahkan.

Dukungan Unicode di Compiler dan Linker

/vd (Nonaktifkan Perpindahan Konstruksi) sekarang memungkinkan Anda menggunakan Operator dynamic_cast pada objek yang sedang dibangun (/vd2)
/YX opsi pengkompilasi telah dihapus. Gunakan /Yc (Buat File Header Yang Telah Dikommpilasikan sebelumnya) atau /Yu (Gunakan File Header Yang Telah Dikommpilasikan sebelumnya) sebagai gantinya. Jika Anda menghapus /YX dari konfigurasi build dan menggantinya tanpa apa-apa, itu dapat menghasilkan build yang lebih cepat.
/Zc:forScope sekarang aktif secara default.
/Zc:wchar_t sekarang aktif secara default.
/Zd opsi pengkompilasi telah dihapus. Informasi penelusuran kesalahan hanya nomor baris tidak lagi didukung. Gunakan /Zi sebagai gantinya (lihat /Z7, /Zi, /ZI (Format Informasi Debug) untuk informasi selengkapnya).
/Zg sekarang hanya valid pada file kode sumber C, dan bukan pada file kode sumber C++.
/Zx Opsi pengkompilasi (Debug Optimized Itanium Code) telah ditambahkan.

Fitur Bahasa Baru

Atributattribute sekarang tidak digunakan lagi.
appdomain__declspec pengubah telah ditambahkan.
__clrcall konvensi panggilan telah ditambahkan.
pengubah declspec (C++) yang tidak digunakan lagi sekarang memungkinkan Anda menentukan string yang akan ditampilkan pada waktu kompilasi, ketika pengguna mencoba mengakses kelas atau fungsi yang tidak digunakan lagi.
dynamic_cast Operator telah melanggar perubahan.
Enum asli sekarang memungkinkan Anda menentukan jenis yang mendasar.
jitintrinsicdeclspec pengubah telah ditambahkan.
noaliasdeclspec pengubah telah ditambahkan.
process__declspec pengubah telah ditambahkan.
abstrak, ambil alih, dan disegel berlaku untuk kompilasi asli.
__restrict kata kunci telah ditambahkan.
restrictdeclspec pengubah telah ditambahkan.
__thiscall sekarang menjadi kata kunci.
__unaligned kata kunci sekarang didokumenkan.
volatile (C++) telah memperbarui perilaku sehubungan dengan pengoptimalan.

Fitur Prapemroseksi Baru

__CLR_VER makro yang telah ditentukan sebelumnya ditambahkan.
Pragma komentar (C/C++) sekarang menerima /MANIFESTDEPENDENCY sebagai komentar linker. Opsi eksestr untuk berkomentar sekarang tidak digunakan lagi.
embedded_idl atribut (Direktif #import ) sekarang mengambil parameter opsional.
fenv_access pragma
float_control pragma
fp_contract pragma
Variabel global tidak akan diinisialisasi dalam urutan variabel dinyatakan jika Anda memiliki variabel global di bagian yang dikelola, tidak dikelola, dan tidak dikelola pragma. Ini adalah potensi perubahan yang melanggar jika, misalnya, variabel global yang tidak dikelola diinisialisasi dengan variabel global terkelola, dan objek terkelola yang sepenuhnya dibangun diperlukan.
Bagian yang ditentukan dengan init_seg sekarang hanya dibaca, dan tidak dibaca/ditulis seperti pada versi sebelumnya.
inline_depth default sekarang adalah 16. Default 16 juga berlaku di Visual C++ .NET 2003.
_INTEGRAL_MAX_BITS makro yang telah ditentukan sebelumnya ditambahkan, lihat Makro yang telah ditentukan sebelumnya.
_M_CEE, _M_CEE_PURE, dan _M_CEE_SAFE makro yang telah ditentukan sebelumnya ditambahkan, lihat Makro yang telah ditentukan sebelumnya.
_M_IX86_FP makro yang telah ditentukan sebelumnya ditambahkan.
_M_X64 makro yang telah ditentukan sebelumnya ditambahkan.
make_public pragma
managed, unmanaged sintaks pragma diperbarui (sekarang memiliki push dan pop)
mscorlib.dll sekarang secara implisit direferensikan oleh Direktif #using di semua /clr kompilasi.
_OPENMP makro yang telah ditentukan sebelumnya ditambahkan.
optimalkan pragma telah diperbarui, dan w bukan parameter yang valid lagi.
atribut no_registry#import telah ditambahkan.
region, endregion pragmas ditambahkan
_VC_NODEFAULTLIB makro yang telah ditentukan sebelumnya ditambahkan.
Makro Variadik sekarang diimplementasikan.
vtordisp tidak digunakan lagi dan akan dihapus dalam rilis Visual C++di masa mendatang.
warning Pragma sekarang memiliki penentu penekanan.

Fitur Linker Baru

Modul (file output MSIL non-assembly) sekarang diizinkan sebagai input ke linker.
/ALLOWISOLATION Opsi linker (Pencarian Manifes) telah ditambahkan.
/ASSEMBLYRESOURCE (Sematkan Sumber Daya Terkelola) telah diperbarui untuk sekarang memungkinkan Anda menentukan nama sumber daya di perakitan, dan untuk menentukan bahwa sumber daya bersifat privat di rakitan.
/CLRIMAGETYPE (Tentukan Jenis Gambar CLR) opsi linker telah ditambahkan.
/CLRSUPPORTLASTERROR (Pertahankan Kode Kesalahan Terakhir untuk Panggilan PInvoke) opsi linker telah ditambahkan.
/CLRTHREADATTRIBUTE Opsi linker (Atur Atribut Utas CLR) telah ditambahkan.
/CLRUNMANAGEDCODECHECK (Tambahkan opsi linker SuppressUnmanagedCodeSecurityAttribute) telah ditambahkan.
/ERRORREPORT (Laporkan Kesalahan Internal Linker) opsi linker telah ditambahkan.
/EXETYPE opsi linker telah dihapus. Linker tidak lagi mendukung pembuatan driver perangkat Windows 95 dan Windows 98. Gunakan DDK yang sesuai untuk membuat driver perangkat ini. Kata kunci EXETYPE tidak lagi valid untuk file definisi modul.
/FUNCTIONPADMIN (Buat Gambar Hotpatchable) opsi linker telah ditambahkan.
/LTCG opsi linker sekarang didukung pada modul yang dikompilasi dengan /clr. /LTCG juga telah diperbarui untuk mendukung pengoptimalan yang dipandu profil.
/MANIFEST (Buat Manifes Perakitan Berdampingan) opsi linker telah ditambahkan.
/MANIFESTDEPENDENCY (Tentukan Dependensi Manifes) opsi linker telah ditambahkan.
/MANIFESTFILE Opsi linker (File Manifes Nama) telah ditambahkan.
/MAPINFO:LINES opsi linker telah dihapus.
/NXCOMPAT (Kompatibel dengan opsi linker Pencegahan Eksekusi Data) telah ditambahkan.
/PGD (Tentukan Database untuk Pengoptimalan Yang Dipandu Profil) opsi penghubung telah ditambahkan.
/PROFILE Opsi linker (Profiler Alat Performa) telah ditambahkan.
/SECTION Opsi linker (Tentukan Atribut Bagian) sekarang mendukung negasi atribut dan tidak lagi mendukung atribut L atau D (terkait VxD).
Dukungan Unicode di Compiler dan Linker
/VERBOSE Opsi linker (Cetak Pesan Kemajuan) sekarang juga menerima ICF dan REF.
/VXD opsi linker telah dihapus. Linker tidak lagi mendukung pembuatan driver perangkat Windows 95 dan Windows 98. Gunakan DDK yang sesuai untuk membuat driver perangkat ini. Kata kunci VXD tidak lagi valid untuk file definisi modul.
/WS opsi linker telah dihapus. /WS digunakan untuk mengubah gambar yang ditargetkan untuk Windows NT 4.0. IMAGECFG.exe -R nama file dapat digunakan alih-alih /WS. IMAGECFG.exe dapat ditemukan di CD-ROM Windows NT 4.0 di SUPPORT\DEBUG\I386\IMAGECFG.EXE.
/WX (Perlakukan Peringatan Linker sebagai Kesalahan) opsi linker sekarang didokumentasikan.

Fitur Utilitas Linker Baru

/ALLOWISOLATION opsi editbin telah ditambahkan
Pernyataan file definisi modul DESCRIPTION dihapus. Linker tidak lagi mendukung pembuatan driver perangkat virtual.
/ERRORREPORT opsi telah ditambahkan ke bscmake.exe, dumpbin.exe, editbin.exe, dan lib.exe.
/LTCG opsi lib telah ditambahkan.
/NXCOMPAT opsi editbin telah ditambahkan.
/RANGE Opsi dumpbin telah ditambahkan.
/TLS Opsi dumpbin telah ditambahkan.
/WS opsi editbin telah dihapus. /WS digunakan untuk mengubah gambar yang ditargetkan untuk Windows NT 4.0. IMAGECFG.exe -R nama file dapat digunakan alih-alih /WS. IMAGECFG.exe dapat ditemukan di CD-ROM Windows NT 4.0 di SUPPORT\DEBUG\I386\IMAGECFG.EXE.
Opsi lib /WX[:NO] telah ditambahkan.

Fitur NMAKE Baru

/ERRORREPORT telah ditambahkan.
/G telah ditambahkan.
Aturan yang telah ditentukan telah diperbarui.
Makro $(MAKE), yang didokumenkan dalam Makro Rekursi, sekarang memberikan jalur lengkap ke nmake.exe.

Fitur MASM Baru

Ekspresi MASM sekarang menjadi nilai 64-bit. Dalam versi sebelumnya ekspresi MASM adalah nilai 32-bit.
Instruksi __asm int 3 sekarang menyebabkan fungsi dikompilasi ke asli.
ALIAS (MASM) sekarang didokumenkan.
/ERRORREPORT opsi ml.exe dan ml64.exe ditambahkan.
. FPO sekarang didokumenkan.
H2INC.exe tidak akan dikirim di Visual C++ 2005. Jika Anda perlu terus menggunakan H2INC, gunakan H2INC.exe dari versi Visual C++sebelumnya.
IMAGEREL operator telah ditambahkan.
operator HIGH32 telah ditambahkan.
operator LOW32 telah ditambahkan.
ml64.exe adalah versi MASM untuk arsitektur x64. Ini merakitan file x64 .asm ke dalam file objek x64. Bahasa rakitan sebaris tidak didukung di pengkompilasi x64. Arahan MASM berikut telah ditambahkan untuk ml64.exe (x64):
.ALLOCSTACK
.ENDPROLOG
.PUSHFRAME
.PUSHREG
.SAVEREG
.SAVEXMM128
. SETFRAME Selain itu, arahan PROC diperbarui dengan sintaksis khusus x64.
Arahan MMWORD telah ditambahkan
/omf (opsi baris perintah ML.exe) sekarang menyiratkan /c. ML.exe tidak mendukung penautan objek format OMF.
Arahan SEGMENT sekarang mendukung atribut tambahan.
SECTIONREL operator telah ditambahkan.
Arahan XMMWORD telah ditambahkan

Fitur CRT Baru

Versi aman dari beberapa fungsi telah ditambahkan. Fungsi-fungsi ini menangani kesalahan dengan cara yang lebih baik dan menerapkan kontrol yang lebih ketat pada buffer untuk membantu menghindari kelemahan keamanan umum. Versi aman baru diidentifikasi oleh akhiran _s .
Versi yang kurang aman yang ada dari banyak fungsi tidak digunakan lagi. Untuk menonaktifkan peringatan penghentian, tentukan _CRT_SECURE_NO_WARNINGS.
Banyak fungsi yang ada sekarang memvalidasi parameternya dan memanggil handler parameter yang tidak valid ketika parameter yang tidak valid diteruskan.
Banyak fungsi yang ada sekarang mengatur errno di mana mereka tidak sebelumnya.
Typedef errno_t dengan bilangan bulat tipe ditambahkan. errno_t digunakan setiap kali jenis pengembalian fungsi atau parameter berurusan dengan kode kesalahan dari errno. errno_terrcodemenggantikan .
Fungsi yang bergantung pada lokal sekarang memiliki versi yang mengambil lokal sebagai parameter daripada menggunakan lokal saat ini. Fungsi baru ini memiliki akhiran _l . Beberapa fungsi baru ditambahkan untuk bekerja dengan objek lokal. Fungsi baru meliputi _get_current_locale, _create_locale dan _free_locale.
Fungsi baru ditambahkan untuk mendukung penguncian dan membuka kunci handel file.
Keluarga _spawn fungsi tidak mengatur ulang errno ke nol pada keberhasilan, seperti yang terjadi pada versi sebelumnya.
printf Versi keluarga fungsi yang memungkinkan Anda menentukan urutan penggunaan argumen.
Unicode sekarang menjadi format teks yang didukung. Fungsi _open ini mendukung atribut _O_TEXTW, _O_UTF8, dan _O_UTF16. Fungsi ini fopen mendukung metode "ccs=ENCODING" untuk menentukan format Unicode.
Versi baru pustaka CRT yang dibangun dalam kode terkelola (MSIL) sekarang tersedia dan digunakan saat mengkompilasi dengan /clr opsi (Kompilasi Runtime Bahasa Umum).
_fileinfo telah dihapus.
Ukuran default untuk time_t sekarang adalah 64 bit, yang memperluas rentang time_t dan beberapa fungsi waktu hingga tahun 3000.
CRT sekarang mendukung pengaturan lokal berdasarkan per utas. Fungsi _configthreadlocale ditambahkan untuk mendukung fitur ini.
Fungsi _statusfp2 dan __control87_2 ditambahkan untuk memungkinkan akses ke dan kontrol kata kontrol titik mengambang pada prosesor titik mengambang x87 dan SSE2.
Fungsi _mkgmtime dan _mkgmtime64 ditambahkan untuk memberikan dukungan untuk mengonversi waktu (struct tm) ke Greenwich Mean Time (GMT).
Perubahan dilakukan pada swprintf dan vswprintf agar lebih sesuai dengan standar.
File header baru, INTRIN. H, menyediakan prototipe untuk beberapa fungsi intrinsik.
Fungsi fopen sekarang memiliki atribut N.
Fungsi _open sekarang memiliki atribut _O_NOINHERIT.
Fungsi atoi sekarang mengembalikan INT_MAX dan mengatur errno ke ERANGE saat overflow. Di versi sebelumnya, perilaku luapan tidak terdefinisi.
Keluarga printf fungsi mendukung output titik pecahan heksadesimal yang diimplementasikan sesuai dengan standar ANSI C99 menggunakan penentu tipe format %a dan %A.
Keluarga printf sekarang mendukung awalan ukuran "ll" (panjang).
Fungsi _controlfp ini telah dioptimalkan untuk performa yang lebih baik.
Versi debug dari beberapa fungsi telah ditambahkan.
Ditambahkan _chgsignl dan _cpysignl (versi ganda panjang).
Menambahkan _locale_t jenis untuk mengetik tabel.
Makro makro _countof baru ditambahkan untuk menghitung jumlah elemen dalam array.
Di setiap topik fungsi, bagian pada setara .NET Framework telah ditambahkan.
Beberapa fungsi string sekarang memiliki opsi untuk memotong string daripada gagal ketika buffer output terlalu kecil; lihat _TRUNCATE.
_set_se_translator sekarang memerlukan penggunaan /EHa opsi pengkompilasi.
fpos_t sekarang __int64 di bawah /Za (untuk kode C) dan ketika STDC diatur secara manual (untuk kode C++). Dulunya adalah struct.
_CRT_DISABLE_PERFCRIT_LOCKS dapat meningkatkan performa I/O program berulir tunggal.
Nama POSIX tidak digunakan lagi demi nama sesuai ISO C++ (misalnya, gunakan _getch daripada getch).
Opsi tautan baru .obj file tersedia untuk mode murni
_recalloc menggabungkan fitur realloc dan calloc.

Yang Baru untuk C++ di Visual Studio 2003

Kompilator

Informasi tentang cara menjalankan Ekstensi Terkelola untuk aplikasi C++ yang dibangun dengan pengkompilasi versi saat ini pada versi runtime sebelumnya.
Ekstensi Terkelola untuk Pertanyaan yang Sering Diajukan C++.
Panduan telah ditambahkan yang menunjukkan cara memindahkan aplikasi asli yang sudah ada untuk menggunakan Ekstensi Terkelola untuk C++: Panduan: Memindahkan Aplikasi C++ Asli yang Ada untuk Beroperasi dengan Komponen .NET Framework.
Sekarang Anda dapat membuat delegasi pada metode jenis nilai.
Kesuaian kompilator dengan standar C++ telah ditingkatkan secara signifikan untuk Visual C++ .NET 2003.
/arch opsi pengkompilasi ditambahkan.
/Gf tidak digunakan lagi dan akan dihapus di versi Visual C++berikutnya.
/G7 opsi pengkompilasi ditambahkan.
Opsi /GS kompilator telah ditingkatkan untuk membantu melindungi variabel lokal dari overruns buffer langsung.
Opsi /noBool pengkompilasi telah dihapus. Pengkompilasi sekarang memungkinkan bool untuk muncul hanya sebagai kata kunci (dan bukan pengidentifikasi) dalam file kode sumber C++.
long long Jenis sekarang tersedia sebagai typedef Catatan __int64 bahwa belum ada dukungan untuk long long di CRT.
Opsi /Zm pengkompilasi sekarang menentukan batas alokasi memori header yang telah dikompilasi sebelumnya.
_InterlockedCompareExchange intrinsik sekarang didokumenkan.
_InterlockedDecrement intrinsik sekarang didokumenkan.
_InterlockedExchange intrinsik sekarang didokumenkan.
_InterlockedExchangeAdd intrinsik sekarang didokumenkan.
_InterlockedIncrement intrinsik sekarang didokumenkan.
_ReadWriteBarrier intrinsik ditambahkan.

Atribut

implements atribut sekarang didokumenkan.

Fitur linker

Sakelar linker berikut telah ditambahkan:

/ASSEMBLYDEBUG
/ASSEMBLYLINKRESOURCE
PENUNDAAN
/KEYFILE
/KEYCONTAINER
/SAFESEH

MASM

Si. Opsi arahan dan /safeseh ml.exe SAFESEH ditambahkan.

Lihat juga

Panduan Porting dan Peningkatan Visual C++

Bagikan melalui

Visual C++ mengubah sejarah 2003 hingga 2015

Yang Baru untuk C++ di Visual Studio 2015

Peningkatan Kesuaian di Visual Studio 2015

Peningkatan Kesuaian di Visual Studio 2015 Update 1

Peningkatan Kesuaian di Visual Studio 2015 Update 2

Penyempurnaan Kesuaian di Visual Studio 2015 Update 3

Yang Baru untuk C++ di Visual Studio 2013

Peningkatan Dukungan Standar ISO C/C++

Kompilator

Pustaka C99

Pustaka Templat Standar

Memecahkan Perubahan

Penyempurnaan Pustaka Visual C++

Performa Aplikasi C++

Peningkatan Profile Guided Optimization (PGO)

Dukungan Pengembangan Aplikasi Runtime Windows

Penyempurnaan Diagnostik

Peningkatan Grafis 3-D

IDE dan Produktivitas

Yang Baru untuk C++ di Visual Studio 2012

Dukungan Standar C++11 yang Ditingkatkan

Pustaka Templat Standar

Penyempurnaan C++11 Lainnya

Dukungan Pengembangan Aplikasi Runtime Windows

Pengkompilasi dan Linker

Baru di Visual Studio 2012 Update 1

Dukungan Pemrograman Paralel

C++ Accelerated Massive Parallelism (AMP)

Peningkatan Pemrograman Paralel Umum

Penyempurnaan Penelusuran Kesalahan Paralel Umum

IDE

Peralatan Manajemen Siklus Hidup Aplikasi

Analisis Kode Statis

Kerangka Kerja Pengujian Unit yang Diperbarui

Grafik Dependensi Arsitektur

Penjelajah Arsitektur

Cakupan Kode

Yang Baru untuk C++ di Visual Studio 2010

C++ Compiler dan Linker

Proyek Visual Studio C++ dan Sistem Build

Pustaka Visual C++

Pustaka Microsoft Foundation Class (MFC)

SafeInt Library

Makro Pustaka Templat Aktif (ATL) Baru

/analyze Warnings

Dukungan Animasi dan D2D

IDE

Alat

Referensi Perakitan Makro Microsoft

Yang Baru untuk C++ di Visual Studio 2008

Visual C++ Integrated Development Environment (IDE)

Pustaka Visual C++

Umum

Pustaka STL/CLR

Pustaka MFC

Pustaka Dukungan C++

ATL Server

Pengkompilasi dan Pengtaut Visual C++

Perubahan Pengkompilasi

Perubahan Linker

Yang Baru untuk C++ di Visual Studio 2005

Intrinsik untuk x86 dan x64

Intrinsik untuk x64 Saja

Kata Kunci Bahasa Baru

Fitur Pengkompilasi Baru

Pengoptimalan Yang Dipandu Profil

Dukungan Unicode di Compiler dan Linker

Fitur Bahasa Baru

Fitur Prapemroseksi Baru

Fitur Linker Baru

Fitur Utilitas Linker Baru

Fitur NMAKE Baru

Fitur MASM Baru

Fitur CRT Baru

Yang Baru untuk C++ di Visual Studio 2003

Kompilator

Atribut

Fitur linker

MASM