Apakah keterbacaan merupakan alasan yang valid untuk tidak menggunakan parameter const dalam (referensi)?

Saat menulis beberapa fungsi, saya menemukan kata kunci const dalam parameter seperti ini:

void MyClass::myFunction(const MyObject& obj,const string& s1,const string& s2,const string& s3){
}

sering menyebabkan pemisahan baris menjadi 2 baris dalam IDE atau vim, jadi saya ingin menghapus semua kata kunci const dalam parameter:

void MyClass::myFunction(MyObject& obj,string& s1,string& s2,string& s3){
} 

apakah itu alasan yang sah untuk tidak menggunakan const? Apakah dapat dipertahankan untuk menjaga objek parameter tidak berubah secara manual?

Keterbacaan adalah alasan yang valid untuk belajar menggunakan spasi putih:

void MyClass::myFunction(
        const MyObject& obj,
        const string& s1,
        const string& s2,
        const string& s3
) {
    return;
}

Terletak di sana parameter tidak akan bingung dengan tubuh fungsi. Dengan menempatkan mereka pada baris yang berbeda, Anda tidak perlu memposisikan ulang ketika Anda mengubah nama myFunctionmenjadi sesuatu yang lebih deskriptif. Tidak mengubah posisi parameter ketika mereka belum berubah adalah sesuatu yang akan dihargai oleh pengguna alat kontrol sumber.

constberarti sesuatu. Jangan membuangnya hanya karena Anda kehabisan ruang dan ide. Keterbacaan adalah raja tetapi melanggar hal-hal dalam namanya hanya menyerah.

Sebenarnya, masalah keterbacaan jelas mengarah ke arah lain. Pertama, Anda dapat dengan mudah menyelesaikan run-on line Anda dengan menggunakan spasi . Tetapi menghapus consttidak hanya membuat garis lebih pendek, itu benar-benar mengubah arti dari program.

Herb Sutter merujuk constpada referensi constsebagai yang paling pentingconst karena referensi untuk constdapat mengikat untuk sementara dan memperpanjang masa pakainya. Referensi nilai non const-tidak bisa, Anda memerlukan variabel terpisah.

void foo_const(std::string const& );
void foo_nc(std::string& );

std::string some_getter();

foo_const(some_getter());      // OK
foo_const("Hello there"); // OK

foo_nc(some_getter()); // error
foo_nc("Nope");   // error

std::string x = some_getter(); // have to do this
foo_nc(x);                     // ok
std::string msg = "Really??";  // and this
foo_nc(msg);                   // ok

Apa artinya ini bagi kegunaan adalah bahwa Anda harus memperkenalkan semua variabel sementara ini hanya untuk dapat memanggil fungsi Anda. Itu tidak bagus untuk dibaca, karena variabel-variabel ini tidak ada artinya dan hanya ada karena tanda tangan Anda salah.

Jawaban sederhana adalah "tidak".

Jawaban panjangnya adalah bahwa constkata kunci adalah bagian dari kontrak yang ditawarkan fungsi; itu memberitahu Anda bahwa argumen tidak akan diubah. Saat Anda menghapus constjaminan itu keluar dari jendela. Ingatlah bahwa Anda tidak dapat secara wajar menjaga ketegaran (atau properti lainnya) dari sesuatu yang menggunakan dokumentasi, konvensi, atau pedoman - jika ketegaran tidak ditegakkan oleh kompiler, seseorang akan berpikir bahwa mereka dapat membuat pekerjaan mereka lebih mudah jika mereka mengutak-atik parameter "hanya sedikit". Mempertimbangkan:

// parameter "foo" is not modified
void fna(Foo& foo);

void fnb(const Foo& foo);

Terlepas dari kenyataan bahwa versi terakhir lebih ringkas, itu juga memberikan kontrak yang lebih kuat, dan memungkinkan kompiler membantu Anda mempertahankan niat Anda. Yang pertama tidak melakukan apa pun untuk mencegah fna(Foo&)fungsi memodifikasi parameter yang Anda berikan.

Seperti dalam jawaban @CandiedOrange, Anda dapat menggunakan spasi putih untuk meletakkan kode dan meningkatkan keterbacaan.

Menghapus constkata kunci menghilangkan keterbacaan karena constmengkomunikasikan informasi kepada pembaca dan kompiler.
Mengurangi panjang kode horizontal itu baik (tidak ada yang suka menggulir ke samping) tetapi ada lebih constdari sekadar teks. Anda dapat menulis ulang:

typedef string str;
typedef MyObject MObj;
void MyClass::myFunction(const MObj& o,const str& s1,const str& s2,const str& s3)

Yang tidak mengubah kontrak tetapi memenuhi kebutuhan untuk mengurangi panjang garis. Sungguh saya akan menganggap potongan di atas kurang dapat dibaca dan akan memilih untuk menggunakan lebih banyak ruang putih seperti yang telah disebutkan dalam jawaban CandiedOrange.

constadalah fungsi dari kode itu sendiri. Anda tidak akan menjadikan fungsi sebagai non-anggota untuk menghapus MyClass::bagian dari deklarasi, jadi jangan hapusconst

Apakah keterbacaan merupakan alasan yang valid untuk tidak menggunakan const dalam parameter?

Tidak. Mengabaikan constdapat mengubah fungsionalitas, kehilangan perlindungan, constdan berpotensi membuat kode yang kurang efisien.

Apakah dapat dipertahankan untuk menjaga objek parameter tidak berubah secara manual?

Daripada menghabiskan waktu memformat kode secara manual

void MyClass::myFunction(const MyObject& obj,const string& s1,const string& s2,const string& s3){
  //
}

Gunakan alat pemformatan otomatis . Tulis fungsi sesuai persyaratan fungsionalnya dan biarkan pemformatan otomatis menangani presentasi. Menyesuaikan pemformatan secara manual tidak seefisien menggunakan pemformatan otomatis dan menggunakan waktu yang disimpan untuk meningkatkan aspek kode lainnya.

void MyClass::myFunction(const MyObject& obj, const string& s1, const string& s2, 
    const string& s3) {
  // 
}

Selama mungkin lebih baik untuk menjaga agar konst terlihat. Ini meningkatkan pemeliharaan kode banyak (tidak ada dugaan untuk melihat apakah metode ini mengubah argumen saya).

Jika saya melihat banyak argumen dalam suatu metode, itu memaksa saya untuk mempertimbangkan pembuatan jaron berbasis proyek (Matriks, Karyawan, Persegi Panjang, Akun) yang akan jauh lebih pendek, lebih mudah dipahami (menghilangkan daftar panjang argumen untuk metode).