Ist Lesbarkeit ein triftiger Grund, const nicht in (Referenz-) Parametern zu verwenden?

Beim Schreiben einiger Funktionen habe ich in Parametern wie diesen ein const-Schlüsselwort gefunden:

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

verursacht in IDE oder vim häufig das Teilen einer Zeile in zwei Zeilen. Daher möchte ich alle const-Schlüsselwörter in den Parametern entfernen:

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

ist das ein triftiger grund, const nicht zu verwenden? Ist es wartbar, die Parameterobjekte manuell unverändert zu lassen?

Die Lesbarkeit ist ein wichtiger Grund, um die Verwendung von Leerzeichen zu erlernen:

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

Dort werden die Parameter nicht mit dem Funktionsumfang verwechselt. Wenn Sie sie in einer anderen Zeile suchen, müssen Sie sie nicht neu positionieren, wenn Sie den Namen myFunctionin einen aussagekräftigeren Namen ändern . Die Position der Parameter nicht zu ändern, wenn sie nicht geändert wurden, ist etwas, das Benutzer von Versionsverwaltungs-Diff-Tools zu schätzen wissen.

constbedeutet etwas. Wirf es nicht raus, nur weil dir der Raum und die Ideen ausgehen. Lesbarkeit ist das A und O, aber Dinge in ihrem Namen zu brechen, gibt einfach auf.

Tatsächlich geht das Problem der Lesbarkeit definitiv in die andere Richtung. Erstens können Sie Ihre Run-On-Linie mithilfe von Leerzeichen trivial lösen . Durch das Entfernen constwird die Zeile jedoch nicht nur kürzer, sondern die Bedeutung des Programms wird vollständig geändert.

Herb Sutter bezeichnet den constin Bezug auf constals den wichtigsten,const weil ein Verweis constauf eine vorübergehende binden und seine Lebensdauer verlängern kann. Für einen Wertverweis auf non- constcannot benötigen Sie eine separate Variable.

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

Für die Benutzerfreundlichkeit bedeutet dies, dass Sie alle diese temporären Variablen einführen müssen, um Ihre Funktion aufrufen zu können. Das ist für die Lesbarkeit nicht besonders gut, da diese Variablen bedeutungslos sind und nur existieren, weil Ihre Signatur falsch ist.

Einfache Antwort ist "nein".

Die lange Antwort lautet, dass das constSchlüsselwort Teil des Vertrags ist, den die Funktion anbietet. es sagt Ihnen, dass das Argument nicht geändert wird. In dem Moment, in dem Sie die constGarantie entfernen , erlischt das Fenster. Denken Sie daran , dass Sie die Konstantheit vernünftigerweise nicht halten können (oder jede andere Eigenschaft) von etwas mit Dokumentation, Konventionen oder Richtlinien - wenn die Konstantheit nicht durch den Compiler erzwungen wird, jemand wird denken , dass sie ihre Arbeit erleichtern können , wenn sie Geige mit der Parameter "nur ein bisschen". Erwägen:

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

void fnb(const Foo& foo);

Abgesehen von der Tatsache, dass die letztere Version prägnanter ist, bietet sie auch einen stärkeren Vertrag und lässt den Compiler Ihnen helfen, Ihre Absichten aufrechtzuerhalten. Ersteres hindert die fna(Foo&)Funktion nicht daran, den übergebenen Parameter zu ändern.

Wie in @CandiedOrange answer können Sie den Code mit Leerzeichen auslegen und die Lesbarkeit verbessern.

Durch das Entfernen des constSchlüsselworts wird die Lesbarkeit beeinträchtigt, da constInformationen an den Reader und den Compiler übermittelt werden.
Die horizontale Länge des Codes zu reduzieren ist gut (niemand mag es, seitwärts zu scrollen), aber es gibt mehr constals nur Text. Sie könnten es umschreiben:

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

Das ändert den Vertrag nicht, erfüllt aber die Notwendigkeit, die Leitungslänge zu reduzieren. Wahrlich, ich würde das obige Snippet als weniger lesbar betrachten und mich dafür entscheiden, mehr Leerzeichen zu verwenden, wie bereits in CandiedOranges Antwort erwähnt.

constist eine Funktionalität des Codes selbst. Sie würden die Funktion nicht als Nichtmitglied festlegen, um den MyClass::Abschnitt der Deklaration zu entfernen. Entfernen Sie also nicht dieconst

Ist Lesbarkeit ein triftiger Grund, const nicht in Parametern zu verwenden?

Nein. Das Weglassen constkann die Funktionalität ändern, den Schutz verlieren constund möglicherweise weniger effizienten Code erstellen.

Ist es wartbar, die Parameterobjekte manuell unverändert zu lassen?

Anstatt Zeit damit zu verbringen, Code manuell zu formatieren

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

Verwenden Sie automatische Formatierungswerkzeuge . Schreiben Sie die Funktion gemäß den funktionalen Anforderungen und lassen Sie die Präsentation automatisch formatieren. Das manuelle Anpassen der Formatierung ist nicht so effizient wie das Verwenden der automatischen Formatierung und das Verwenden der gespeicherten Zeit, um andere Aspekte des Codes zu verbessern.

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

So lange wie möglich ist es besser, const sichtbar zu halten. Es verbessert die Codewartung erheblich (es ist kein Rätselraten, ob diese Methode meine Argumente ändert).

Wenn eine Methode viele Argumente enthält, muss ich über die Erstellung eines projektbasierten Jarons (Matrix, Employee, Rectangle, Account) nachdenken, der viel kürzer und verständlicher ist (wodurch eine lange Liste von Argumenten für Methoden entfällt).