it-swarm.com.de

Ist die Lesbarkeit ein gültiger Grund, const nicht in (Referenz-) Parametern zu verwenden?

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

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

führt häufig dazu, dass eine Zeile in IDE oder vim) in zwei Zeilen aufgeteilt wird. 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?

25
ggrr

Die Lesbarkeit ist ein triftiger Grund, den Umgang mit Leerzeichen zu lernen:

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

Dort drüben werden die Parameter nicht mit dem Funktionskörper verwechselt. Wenn Sie sie in einer anderen Zeile suchen, müssen Sie sie nicht neu positionieren, wenn Sie den Namen myFunction in einen aussagekräftigeren Namen ändern. Die Position der Parameter nicht zu ändern, wenn sie sich nicht geändert haben, ist etwas, das Benutzer des Diff-Tools für die Quellcodeverwaltung zu schätzen wissen.

const bedeutet etwas. Werfen Sie es nicht weg, nur weil Sie keinen Platz und keine Ideen mehr haben. Lesbarkeit ist König, aber Dinge in seinem Namen zu brechen, gibt einfach auf.

181
candied_orange

Tatsächlich geht das Problem der Lesbarkeit definitiv in die andere Richtung. Erstens können Sie Ihre Anlaufzeile trivial durch das Verwendung von Leerzeichen lösen. Das Entfernen von const verkürzt jedoch nicht nur die Zeile, sondern ändert auch die Bedeutung des Programms vollständig.

Herb Sutter bezieht sich auf das const in Bezug auf const als das wichtigste const , da ein Verweis auf const an binden kann eine vorübergehende und verlängern ihre Lebensdauer. Ein l-Wert-Verweis auf non -const kann nicht, Sie benötigen 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. Dies ist für die Lesbarkeit nicht besonders gut, da diese Variablen bedeutungslos sind und nur existieren, weil Ihre Signatur falsch ist.

52
Barry

Einfache Antwort ist "nein".

Die lange Antwort lautet, dass das Schlüsselwort const Teil des Vertrags ist, den die Funktion anbietet. Es sagt Ihnen, dass das Argument nicht geändert wird. In dem Moment, in dem Sie das const entfernen, wird diese Garantie aus dem Fenster entfernt. Denken Sie daran, dass Sie die Konstanz (oder eine andere Eigenschaft) von etwas mithilfe von Dokumentation, Konventionen oder Richtlinien nicht angemessen beibehalten können. Wenn die Konstanz vom Compiler nicht erzwungen wird, glaubt jemand wird, dass er sie erstellen kann Ihre Arbeit wird einfacher, wenn sie mit dem Parameter "nur ein bisschen" herumspielen. 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 Funktion fna(Foo&) nicht daran, den Parameter zu ändern, den Sie an sie übergeben.

Wie in der Antwort von @CandiedOrange können Sie Leerzeichen verwenden, um den Code zu gestalten und die Lesbarkeit zu verbessern.

21
Mael

Entfernen des Schlüsselworts constentfernt die Lesbarkeit weil const Informationen an den Leser und den Compiler übermittelt.
Das Reduzieren der horizontalen Länge des Codes ist gut (niemand scrollt gerne seitwärts), aber const enthält mehr als 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. Wirklich Ich würde das obige Snippet als weniger lesbar betrachten und würde mich dafür entscheiden, mehr Leerzeichen zu verwenden, wie bereits in der Antwort von CandiedOrange erwähnt.

const ist eine Funktionalität des Codes selbst. Sie würden die Funktion nicht zu einem Nichtmitglied machen, um den Abschnitt MyClass:: Der Deklaration zu entfernen. Entfernen Sie also nicht das const

14
Erdrik Ironrose

Ist die Lesbarkeit ein gültiger Grund, const nicht in Parametern zu verwenden?

Nein. Das Weglassen von const kann die Funktionalität ändern, den Schutz verlieren, den const bietet, und möglicherweise weniger effizienten Code erstellen.

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

Anstatt Zeit zu verbringen manuell Code formatieren

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

Verwenden Sie automatische Formatierung Tools. Schreiben Sie die Funktion gemäß ihren funktionalen Anforderungen und lassen Sie die automatische Formatierung die Präsentation übernehmen. Das manuelle Anpassen der Formatierung ist nicht so effizient wie die automatische Formatierung und die Verwendung der gesparten Zeit, um andere Aspekte des Codes zu verbessern.

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