¿Es la legibilidad una razón válida para no usar const en los parámetros (de referencia)?

Al escribir algunas funciones, encontré una palabra clave const en parámetros como este:

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

a menudo provoca la división de una línea en 2 líneas en IDE o vim, por lo que quiero eliminar todas las palabras clave constantes en los parámetros:

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

¿Es esa una razón válida para no usar const? ¿Es mantenible mantener los objetos de parámetros sin cambios manualmente?

La legibilidad es una razón válida para aprender a usar espacios en blanco:

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

Ubicados allí, los parámetros no se confundirán con el cuerpo de la función. Al ubicarlos en una línea diferente, no tendrá que reposicionarlos cuando cambie el nombre de myFunctionalgo más descriptivo. No cambiar la posición de los parámetros cuando no han cambiado es algo que los usuarios de la herramienta de control de fuente apreciarán.

constsignifica algo. No lo tires solo porque te quedas sin espacio e ideas. La legibilidad es el rey, pero romper cosas en su nombre es simplemente darse por vencido.

En realidad, el problema de legibilidad definitivamente va en la otra dirección. Primero, puede resolver trivialmente su línea de acceso mediante el uso de espacios en blanco . Pero eliminar constno solo hace que la línea sea más corta, sino que cambia completamente el significado del programa.

Herb Sutter se refiere a la constreferencia constcomo la más importanteconst porque una referencia a constpuede unirse a una temporal y extender su vida útil. Una referencia de valor a no constpuede, necesita una variable separada.

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

Lo que esto significa para la usabilidad es que tendrá que introducir todas estas variables temporales solo para poder llamar a su función. Eso no es bueno para la legibilidad, ya que estas variables no tienen sentido y existen solo porque su firma es incorrecta.

La respuesta simple es "no".

La respuesta larga es que la constpalabra clave es parte del contrato que ofrece la función; le dice que el argumento no se modificará. En el momento en que elimina la constgarantía, esa garantía desaparece. Recuerde que usted no puede sostener la constness (o cualquier otra propiedad) de algo utilizando documentación, convenciones, directrices o - si el constness no se hace cumplir por el compilador, alguien va a pensar que pueden hacer su trabajo más fácil si jugar con el parámetro "solo un poquito". Considerar:

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

void fnb(const Foo& foo);

Además del hecho de que la última versión es más concisa, también proporciona un contrato más sólido y permite que el compilador lo ayude a mantener sus intenciones. El primero no hace nada para evitar que la fna(Foo&)función modifique el parámetro que le pasa.

Como en la respuesta @CandiedOrange, puede usar espacios en blanco para diseñar el código y mejorar la legibilidad.

La eliminación de la constpalabra clave elimina la legibilidad porque constcomunica información al lector y al compilador.
Reducir la longitud horizontal del código es bueno (a nadie le gusta desplazarse hacia los lados), pero hay más constque texto. Podrías reescribirlo:

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

Lo cual no cambia el contrato pero satisface la necesidad de reducir la longitud de la línea. Verdaderamente , consideraría que el fragmento anterior es menos legible y optaría por usar más espacios en blanco como ya se mencionó en la respuesta de CandiedOrange.

constes una funcionalidad del código en sí. No haría que la función no sea miembro para eliminar la MyClass::sección de la declaración, así que no elimine elconst

¿Es la legibilidad una razón válida para no usar const en los parámetros?

No. Omitir constpuede cambiar la funcionalidad, perder las protecciones que constofrece y potencialmente puede crear código menos eficiente.

¿Es mantenible mantener los objetos de parámetros sin cambios manualmente?

En lugar de perder tiempo formateando código manualmente

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

Use herramientas de formateo automático . Escriba la función según sus requisitos funcionales y deje que el formateo automático se encargue de la presentación. Ajustar el formato manualmente no es tan eficiente como usar el formateo automático y usar el tiempo ahorrado para mejorar otros aspectos del código.

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

Mientras sea posible, es mejor mantener visible la constante. Mejora mucho el mantenimiento del código (no hay conjeturas para ver si este método cambia mis argumentos).

Si veo muchos argumentos en un método, me obliga a considerar la creación de jaron basado en proyectos (Matriz, Empleado, Rectángulo, Cuenta) que sería mucho más corto, más fácil de entender (elimina una larga lista de argumentos para los métodos).