La leggibilità è un motivo valido per non utilizzare i parametri const in (riferimento)?

La leggibilità è un valido motivo per imparare a usare gli spazi bianchi:

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

Trovati là i parametri non verranno confusi con il corpo della funzione. Localizzandoli su una linea diversa non dovrai riposizionarli quando cambi il nome di myFunction in qualcosa di più descrittivo. Non cambiare la posizione dei parametri quando non sono cambiati è qualcosa che gli utenti di strumenti di controllo del codice sorgente apprezzeranno.

const significa qualcosa. Non buttarlo fuori solo perché sei fuori dallo spazio e dalle idee. La leggibilità è il re, ma rompere le cose in esso è solo arrendersi.

In realtà, il problema della leggibilità va decisamente nella direzione opposta. In primo luogo, puoi risolvere banalmente il tuo run-on con l' uso di spazi bianchi . Ma rimuovere const non limita la linea, cambia completamente il significato del programma.

Herb Sutter si riferisce al const in riferimento a const come importantissimo const perché un riferimento a const può legarsi a un temporaneo ed estenderne la durata. Un riferimento di lvalue a non const non può, hai bisogno di una variabile separata.

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

Che cosa significa per usabilità è che dovrai introdurre tutte queste variabili temporanee solo per poter chiamare la tua funzione. Non è eccezionale per la leggibilità, dal momento che queste variabili non hanno senso ed esistono solo perché la tua firma è sbagliata.

La risposta semplice è "no".

La risposta lunga è che la parola chiave const è parte del contratto che la funzione offre; ti dice che l'argomento non verrà modificato. Nel momento in cui rimuovi il const , quella garanzia esce dalla finestra. Ricorda che non puoi mantenere ragionevolmente la costanza (o qualsiasi altra proprietà) di qualcosa usando documentazione, convenzioni o linee guida - se la costanza non è imposta dal compilatore, qualcuno penserà che possono fare il loro lavoro è più facile se giocano con il parametro "solo un po '". Prendere in considerazione:

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

void fnb(const Foo& foo);

Oltre al fatto che quest'ultima versione è più concisa, fornisce anche un contratto più strong e consente al compilatore di aiutarti a mantenere le tue intenzioni. Il primo non fa nulla per impedire alla funzione fna(Foo&) di modificare il parametro che gli passi.

Come nella risposta @CandiedOrange, puoi utilizzare gli spazi bianchi per disporre il codice e migliorare la leggibilità.

Rimozione della parola chiave const rimuove la leggibilità perché const comunica le informazioni al lettore e al compilatore.
La riduzione della lunghezza orizzontale del codice è buona (a nessuno piace scorrere lateralmente) ma c'è di più in const del testo. Potresti riscriverlo:

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

Che non cambia il contratto ma soddisfa la necessità di ridurre la lunghezza della linea. Veramente considererei il snippet precedente meno leggibile e opterei per l'utilizzo di più spazi bianchi come già menzionato nella risposta di CandiedOrange.

const è una funzionalità del codice stesso. Non si renderebbe la funzione non membro per rimuovere la sezione MyClass:: della dichiarazione, quindi non rimuovere const

Is readability a valid reason to not use const in parameters?

No. Se ometti const puoi modificare la funzionalità, perdere le protezioni const e può potenzialmente creare codice meno efficiente.

Is it maintainable to keep the parameter objects unchanged manually?

Invece di perdere tempo manualmente formattare il codice

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

Utilizza gli strumenti di formattazione automatica . Scrivi la funzione in base ai suoi requisiti funzionali e lascia che la formattazione automatica gestisca la presentazione. La regolazione manuale della formattazione non è efficiente come utilizzare la formattazione automatica e utilizzare il tempo risparmiato per migliorare altri aspetti del codice.

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

Il più a lungo possibile è meglio mantenere const visibile. Migliora molto la manutenzione del codice (nessuna congettura per vedere se questo metodo cambia i miei argomenti).

Se vedo molti argomenti in un metodo, mi costringe a considerare la creazione di jaron basati su progetto (Matrix, Employee, Rectangle, Account) che sarebbe molto più breve, più facile da capire (elimina una lunga lista di argomenti ai metodi) .