Kapan saya harus menggunakan string_view di antarmuka?

Saya menggunakan perpustakaan internal yang dirancang untuk meniru perpustakaan C ++ yang diusulkan , dan kadang-kadang dalam beberapa tahun terakhir saya melihat antarmuka berubah dari menggunakan std::stringke string_view.

Jadi saya dengan patuh mengubah kode saya, agar sesuai dengan antarmuka baru. Sayangnya, yang harus saya sampaikan adalah parameter std :: string, dan sesuatu yang merupakan nilai pengembalian std :: string. Jadi kode saya berubah dari sesuatu seperti ini:

void one_time_setup(const std::string & p1, int p2) {
   api_class api;
   api.setup (p1, special_number_to_string(p2));
}

untuk

void one_time_setup(const std::string & p1, int p2) {
   api_class api;
   const std::string p2_storage(special_number_to_string(p2));
   api.setup (string_view(&p1[0], p1.size()), string_view(&p2_storage[0], p2_storage.size()));
}

Saya benar - benar tidak melihat perubahan apa yang saya beli sebagai klien API, selain lebih banyak kode (untuk kemungkinan gagal). Panggilan API kurang aman (karena API tidak lagi memiliki penyimpanan untuk parameternya), mungkin menyimpan program saya 0 bekerja (karena pemindahan optimisasi dapat dilakukan oleh kompiler sekarang), dan bahkan jika itu memang menghemat pekerjaan, itu hanya akan menjadi beberapa alokasi yang tidak dan tidak akan pernah dilakukan setelah startup atau dalam lingkaran besar di suatu tempat. Bukan untuk API ini.

Namun, pendekatan ini tampaknya mengikuti saran yang saya lihat di tempat lain, misalnya jawaban ini :

Sebagai tambahan, karena C ++ 17 Anda harus menghindari melewatkan const std :: string & yang mendukung std :: string_view:

Saya menemukan saran yang mengejutkan, karena tampaknya mengadvokasi secara universal mengganti objek yang relatif aman dengan yang kurang aman (pada dasarnya pointer dan panjang yang dimuliakan), terutama untuk keperluan optimasi.

Jadi kapan seharusnya string_view digunakan, dan kapan seharusnya tidak?

1. Apakah fungsionalitas yang mengambil nilai perlu dimiliki oleh string? Jika demikian gunakan std::string(non-const, non-ref). Opsi ini memberi Anda pilihan untuk secara eksplisit bergerak dalam nilai juga jika Anda tahu bahwa itu tidak akan pernah digunakan lagi dalam konteks panggilan.
2. Apakah fungsinya baru saja membaca string? Jika demikian gunakan std::string_view(const, non-ref) ini karena string_viewdapat menangani std::stringdan char*dengan mudah tanpa masalah dan tanpa membuat salinan. Ini harus mengganti semua const std::string&parameter.

Pada akhirnya Anda seharusnya tidak perlu memanggil std::string_viewkonstruktor seperti Anda. std::stringmemiliki operator konversi yang menangani konversi secara otomatis.

A std::string_viewmembawa beberapa manfaat a const char*ke C ++: tidak seperti std::string, string_view

• tidak memiliki memori,
• tidak mengalokasikan memori,
• dapat menunjuk ke string yang ada di beberapa offset, dan
• memiliki satu tingkat tipuan pointer kurang dari a std::string&.

Ini berarti string_view sering dapat menghindari salinan, tanpa harus berurusan dengan pointer mentah.

Dalam kode modern, std::string_viewharus mengganti hampir semua penggunaan const std::string&parameter fungsi. Ini harus menjadi perubahan yang kompatibel dengan sumber, karena std::stringmenyatakan operator konversi untuk std::string_view.

Hanya karena tampilan string tidak membantu dalam kasus penggunaan spesifik Anda di mana Anda perlu membuat string, tidak berarti bahwa itu adalah ide yang buruk secara umum. Pustaka standar C ++ cenderung dioptimalkan untuk umum daripada untuk kenyamanan. Argumen "kurang aman" tidak berlaku, karena tidak perlu membuat sendiri tampilan string.

Saya menemukan saran yang mengejutkan, karena tampaknya mengadvokasi secara universal mengganti objek yang relatif aman dengan yang kurang aman (pada dasarnya pointer dan panjang yang dimuliakan), terutama untuk keperluan optimasi.

Saya pikir ini sedikit salah mengerti tujuan dari ini. Meskipun ini merupakan "optimasi", Anda harus benar-benar menganggapnya sebagai melepaskan diri dari keharusan menggunakan std::string.

Pengguna C ++ telah membuat lusinan kelas string yang berbeda. Kelas string dengan panjang tetap, kelas yang dioptimalkan SSO dengan ukuran buffer sebagai parameter templat, kelas string yang menyimpan nilai hash yang digunakan untuk membandingkannya, dll. Beberapa orang bahkan menggunakan string berbasis-SAP. Jika ada satu hal yang suka dilakukan oleh programmer C ++, ia menulis kelas string.

Dan itu mengabaikan string yang dibuat dan dimiliki oleh perpustakaan C. Naked char*, mungkin dengan ukuran tertentu.

Jadi, jika Anda menulis pustaka, dan Anda mengambil const std::string&, pengguna sekarang harus mengambil string apa pun yang mereka gunakan dan menyalinnya ke a std::string. Mungkin puluhan kali.

Jika Anda ingin akses ke std::stringantarmuka spesifik string, mengapa Anda harus menyalin string? Itu sia-sia.

Alasan prinsip untuk tidak mengambil string_viewsebagai parameter adalah:

1. Jika tujuan akhir Anda adalah meneruskan string ke antarmuka yang mengambil string yang diakhiri NUL ( fopen, dll). std::stringdijamin akan dihentikan NUL; string_viewbukan. Dan sangat mudah untuk membuat substring view agar non-NUL dihentikan; sub-stringing a std::stringakan menyalin substring keluar ke rentang NUL-dihentikan.

   Saya menulis jenis gaya string_view khusus NUL-dihentikan untuk persis skenario ini. Anda dapat melakukan sebagian besar operasi, tetapi bukan operasi yang melanggar statusnya yang diakhiri NUL (misalnya, memotong dari bagian akhir).

2. Masalah seumur hidup. Jika Anda benar-benar perlu menyalinnya std::stringatau memiliki array karakter yang lebih lama dari panggilan fungsi, yang terbaik adalah menyatakan ini di muka dengan mengambil a const std::string &. Atau hanya std::stringsebagai parameter nilai. Dengan begitu, jika mereka sudah memiliki string seperti itu, Anda dapat mengklaim kepemilikannya segera, dan penelepon dapat pindah ke string jika mereka tidak perlu menyimpan salinannya.