Pembaruan Profil Seumur Hidup di Visual Studio 2019 Pratinjau 2

Profil Seumur Hidup Pedoman Inti C ++, yang merupakan bagian dari Pedoman Inti C ++ , bertujuan untuk mendeteksi masalah seumur hidup, seperti petunjuk dan referensi yang menggantung, dalam kode C ++. Ia menggunakan jenis informasi yang sudah ada di sumber bersama dengan beberapa kontrak sederhana antara fungsi untuk mendeteksi cacat pada waktu kompilasi dengan anotasi minimal.

Ini adalah kontrak dasar yang diharapkan diikuti oleh kode oleh profil:

1. Jangan gunakan pointer yang berpotensi menggantung.
2. Jangan melewatkan pointer yang berpotensi menggantung ke fungsi lain.
3. Jangan kembalikan pointer yang berpotensi menggantung dari fungsi apa pun.

Untuk informasi lebih lanjut tentang sejarah dan tujuan profil, lihat posting blog Herb Sutter tentang versi 1.0 .

Apa yang Baru di Visual Studio 2019 Pratinjau 2

Dalam Pratinjau 2, kami telah mengirimkan rilis pratinjau dari Lifetime Profile Checker yang mengimplementasikan versi yang diterbitkan dari Lifetime Profile . Pemeriksa ini adalah bagian dari C ++ Core Checkers di Visual Studio.

• Dukungan untuk iterator, string_views, dan span.
• Deteksi yang lebih baik dari tipe Pemilik kustom dan Pointer yang memungkinkan tipe kustom yang berperilaku seperti Kontainer, Pointer Pemilik, atau Pointer Non-Pemilik untuk berpartisipasi dalam analisis.
• Aturan default yang sadar jenis untuk kondisi pra dan pasca panggilan fungsi membantu mengurangi kesalahan positif dan meningkatkan akurasi.
• Dukungan yang lebih baik untuk tipe agregat.
• Kebenaran umum dan peningkatan kinerja.
• Beberapa analisis nullptr sederhana.

Mengaktifkan Aturan Pemeriksa Profil Seumur Hidup

Aturan pemeriksa tidak diaktifkan secara default. Jika Anda ingin mencoba aturan baru, Anda harus memperbarui aturan analisis kode yang dipilih untuk proyek Anda. Anda dapat memilih “C ++ Core Check Lifetime Rules” - yang hanya mengaktifkan aturan Lifetime Profile - atau Anda dapat memodifikasi set aturan yang ada untuk mengaktifkan peringatan 26486 hingga 26489.

Cuplikan layar halaman properti Analisis Kode yang menunjukkan C ++ Core Periksa aturan Aturan Seumur Hidup dipilih.

Peringatan akan muncul di Daftar Kesalahan ketika analisis kode dijalankan (Analisis> Menjalankan Analisis Kode), atau jika Anda mengaktifkan Analisis Kode Latar Belakang, kesalahan seumur hidup akan muncul di editor dengan coretan hijau.

Cuplikan layar memperlihatkan peringatan Pemeriksa Profil Seumur Hidup dengan coretan hijau dalam kode sumber.

Contohnya

Pointer menggantung

Contoh paling sederhana - menggunakan pointer menggantung - adalah tempat terbaik untuk memulai. Di sini px menunjuk ke x dan kemudian x meninggalkan ruang lingkup meninggalkan px menggantung. Saat px digunakan, peringatan dikeluarkan.

 void simple_test() { int* px; { int x = 0; px = &x; } *px = 1; // error, dangling pointer to 'x' } 

Menggantung penunjuk keluaran

Pointer yang menggantung juga tidak diperbolehkan. Dalam hal ini, parameter ppx dianggap sebagai parameter output. Dalam hal ini, ini diatur ke titik x yang keluar dari ruang lingkup di akhir fungsi. Ini membuat *ppx menggantung.

 void out_parameter(int x, int** ppx) // *ppx points to 'x' which is invalid { *ppx = &x; } 

Menggantung tampilan string

Dua contoh terakhir jelas, tetapi contoh sementara dapat memperkenalkan bug halus. Bisakah Anda menemukan bug di kode berikut?

 std::string get_string(); void dangling_string_view() { std::string_view sv = get_string(); auto c = sv.at(0); } 

Dalam kasus ini, tampilan string sv dibuat dengan instance string sementara yang dikembalikan dari get_string() . String sementara kemudian dihancurkan yang meninggalkan tampilan string referensi objek yang tidak valid.

Menggantung iterator

Masalah sulit lain seumur hidup terjadi ketika menggunakan iterator yang tidak valid ke dalam wadah. Dalam kasus di bawah ini, panggilan ke push_back dapat menyebabkan vektor untuk mengalokasikan kembali penyimpanan yang mendasarinya yang membatalkan iterator it .

 void dangling_iterator() { std::vector<int> v = { 1, 2, 3 }; auto it = v.begin(); *it = 0; // ok, iterator is valid v.push_back(4); *it = 0; // error, using an invalid iterator } 

Satu hal yang perlu diperhatikan tentang contoh ini adalah tidak ada penanganan khusus untuk 'std :: vector :: push_back'. Perilaku ini tidak sesuai dengan aturan profil default. Satu aturan mengklasifikasikan wadah sebagai 'Pemilik'. Kemudian, ketika metode non-const dipanggil pada Pemilik, memori yang dimiliki diasumsikan tidak valid dan iterator yang menunjuk pada memori yang dimiliki juga dianggap tidak valid.

Pemilik yang Dimodifikasi

Profil ini bersifat preskriptif dalam panduannya. Itu mengharapkan kode Anda yang menggunakan sistem jenis idiomatis ketika mendefinisikan parameter fungsi. Dalam contoh berikut ini, std::unique_ptr , tipe 'Pemilik', diteruskan ke fungsi lain dengan referensi non-const. Menurut aturan profil, Pemilik yang disahkan oleh referensi non-const diasumsikan dimodifikasi oleh callee.

 void use_unique_ptr(std::unique_ptr<int>& upRef); void assumes_modification() { auto unique = std::make_unique<int>(0); // Line A auto ptr = unique.get(); *ptr = 10; // ok, ptr is valid use_unique_ptr(unique); *ptr = 10; // error, dangling pointer to the memory held by 'unique' at Line A } 

Dalam contoh ini, kita mendapatkan pointer mentah, ptr , ke memori yang dimiliki oleh unique . Kemudian unique diteruskan ke fungsi use_unique_ptr oleh referensi non-const. Karena ini adalah non-const penggunaan unique mana fungsi bisa melakukan apa saja, analisis mengasumsikan bahwa unique 'entah bagaimana batal (misalnya unique_ptr :: reset) yang akan menyebabkan ptr menjuntai.

Lebih banyak contoh

Ada banyak kasus lain yang dapat dideteksi analisis. Cobalah di Visual Studio dengan kode Anda sendiri dan lihat apa yang Anda temukan. Lihat juga blog Herb untuk lebih banyak contoh dan, jika Anda penasaran, bacalah makalah Profil Seumur Hidup.

Masalah yang diketahui

Implementasi saat ini tidak sepenuhnya mendukung analisis seperti yang dijelaskan dalam makalah Profil Seumur Hidup. Berikut adalah kategori luas yang tidak diterapkan dalam rilis ini.

• Anotasi - Makalah ini memperkenalkan anotasi (yaitu [[gsl::lifetime-const]] ) yang tidak didukung. Secara praktis ini berarti bahwa jika aturan analisis default tidak berfungsi untuk kode Anda, tidak banyak yang dapat Anda lakukan selain menekan positif palsu.
• Pengecualian - Jalur penanganan pengecualian, termasuk konten blok catch , saat ini tidak dianalisis.
• Aturan Default untuk Tipe STL - Sebagai pengganti anotasi lifetime-const , makalah ini merekomendasikan bahwa untuk fungsi anggota kontainer STL yang langka di mana kami ingin menimpa default, kami memperlakukannya seolah-olah diberi penjelasan. Sebagai contoh, satu kelebihan std::vector::at bukan const karena ia dapat mengembalikan referensi non-const - namun kita tahu bahwa memanggilnya adalah lifetime-const karena tidak membatalkan memori vektor. Kami belum menyelesaikan pekerjaan untuk melakukan anotasi tersirat dari semua jenis wadah STL ini.
• Capture Lambda - Jika variabel stack ditangkap dengan referensi dalam lambda, kami saat ini tidak mendeteksi apakah lambda meninggalkan ruang lingkup variabel yang diambil.
  
  

   auto lambda_test() { int x; auto captures_x = [&x] { return x; }; return captures_x; // returns a dangling reference to 'x' } 

Bungkus

Cobalah Pemeriksa Profil Seumur Hidup di Visual Studio 2019 Pratinjau 2. Kami berharap ini akan membantu mengidentifikasi masalah seumur hidup di proyek Anda. Jika Anda menemukan positif palsu atau negatif palsu, tolong laporkan sehingga kami dapat memprioritaskan skenario yang penting bagi Anda. Jika Anda memiliki saran atau masalah dengan pemeriksaan ini - atau fitur Visual Studio - baik Laporkan Masalah atau posting di Komunitas Pengembang dan beri tahu kami. Kami juga di Twitter di @VisualC .