Khả năng đọc là một lý do hợp lệ để không sử dụng const trong các tham số (tham chiếu)?

Khi viết một số hàm, tôi tìm thấy một từ khóa const trong các tham số như thế này:

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

thường gây ra việc chia một dòng thành 2 dòng trong IDE hoặc vim, vì vậy tôi muốn xóa tất cả các từ khóa const trong tham số:

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

Đó có phải là một lý do hợp lệ để không sử dụng const? Có thể duy trì để giữ các đối tượng tham số không thay đổi bằng tay?

Khả năng đọc là một lý do hợp lệ để học cách sử dụng khoảng trắng:

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

Nằm ở đằng kia, các tham số sẽ không bị nhầm lẫn với phần thân của hàm. Bằng cách định vị chúng trên một dòng khác, bạn sẽ không phải định vị lại chúng khi bạn đổi tên myFunctionthành một cái gì đó mô tả hơn. Không thay đổi vị trí tham số khi chúng không thay đổi là điều mà người dùng công cụ diff kiểm soát nguồn sẽ đánh giá cao.

constcó một ý nghĩa nào đó. Đừng vứt nó đi chỉ vì bạn hết không gian và ý tưởng. Khả năng đọc là vua nhưng phá vỡ mọi thứ trong tên của nó chỉ là từ bỏ.

Trên thực tế, vấn đề dễ đọc chắc chắn đi theo hướng khác. Đầu tiên, bạn có thể giải quyết một cách tầm thường dòng chạy của mình bằng cách sử dụng khoảng trắng . Nhưng loại bỏ constkhông chỉ làm cho dòng ngắn hơn, nó thay đổi hoàn toàn ý nghĩa của chương trình.

Herb Sutter đề cập đến consttài liệu tham khảo constlà quan trọng nhấtconst bởi vì một tài liệu tham khảo constcó thể liên kết với tạm thời và kéo dài tuổi thọ của nó. Một tham chiếu giá trị đến không constthể, bạn cần một biến riêng.

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

Điều này có nghĩa là khả năng sử dụng là bạn sẽ phải giới thiệu tất cả các biến tạm thời này chỉ để có thể gọi hàm của bạn. Điều đó không tốt cho khả năng đọc, vì các biến này là vô nghĩa và chỉ tồn tại vì chữ ký của bạn sai.

Câu trả lời đơn giản là "không".

Câu trả lời dài là consttừ khóa là một phần của hợp đồng mà hàm cung cấp; nó cho bạn biết rằng đối số sẽ không được sửa đổi. Khoảnh khắc bạn gỡ bỏ constbảo đảm ra khỏi cửa sổ. Hãy nhớ rằng bạn không thể duy trì hợp lý độ chụm (hoặc bất kỳ thuộc tính nào khác) của một thứ gì đó bằng cách sử dụng tài liệu, quy ước hoặc hướng dẫn - nếu hằng số không được thực thi bởi trình biên dịch, ai đó sẽ nghĩ rằng họ có thể làm cho công việc của họ dễ dàng hơn nếu họ sử dụng tham số "chỉ một chút thôi". Xem xét:

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

void fnb(const Foo& foo);

Ngoài thực tế là phiên bản sau ngắn gọn hơn, nó cũng cung cấp hợp đồng mạnh hơn và cho phép trình biên dịch giúp bạn duy trì ý định của mình. Cái trước không làm gì để ngăn fna(Foo&)chức năng sửa đổi tham số bạn truyền cho nó.

Như trong câu trả lời @CandiedOrange, bạn có thể sử dụng khoảng trắng để bố trí mã và tăng cường khả năng đọc.

Xóa consttừ khóa sẽ loại bỏ khả năng đọc vì consttruyền thông tin đến người đọc và trình biên dịch.
Giảm độ dài mã ngang là tốt (không ai thích cuộn sang một bên) nhưng có nhiều thứ consthơn là văn bản. Bạn có thể viết lại nó:

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

Điều này không thay đổi hợp đồng nhưng đáp ứng nhu cầu giảm chiều dài đường dây. Thực sự tôi sẽ coi đoạn trích trên là ít đọc hơn và sẽ chọn sử dụng nhiều khoảng trắng hơn như đã được đề cập trong câu trả lời của CandiedOrange.

constlà một chức năng của chính mã. Bạn sẽ không làm cho hàm không phải là thành viên để xóa MyClass::phần khai báo, vì vậy đừng xóaconst

Là khả năng đọc là một lý do hợp lệ để không sử dụng const trong các tham số?

Không. Bỏ qua constcó thể thay đổi chức năng, mất các biện pháp bảo vệ constvà có khả năng tạo mã kém hiệu quả hơn.

Có thể duy trì để giữ các đối tượng tham số không thay đổi bằng tay?

Thay vì dành thời gian tự tạo mã

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

Sử dụng các công cụ định dạng tự động . Viết hàm theo các yêu cầu chức năng của nó và để tự động định dạng xử lý bản trình bày. Điều chỉnh định dạng thủ công không hiệu quả bằng sử dụng định dạng tự động và sử dụng thời gian đã lưu để cải thiện các khía cạnh khác của mã.

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

Càng lâu càng tốt để giữ const. Nó cải thiện bảo trì mã rất nhiều (không cần phỏng đoán để xem phương thức này có thay đổi đối số của tôi không).

Nếu tôi thấy nhiều đối số trong một phương thức, nó buộc tôi phải xem xét việc tạo jaron dựa trên dự án (Ma trận, Nhân viên, Hình chữ nhật, Tài khoản) sẽ ngắn hơn nhiều, dễ hiểu hơn (loại bỏ danh sách dài các đối số cho các phương thức).