const int vs. int const als functionsparameter in C ++ und C

Schnelle Frage:

int testfunc1 (const int a) { return a; } int testfunc2 (int const a) { return a; } 

Sind diese beiden functionen in jeder Hinsicht gleich oder gibt es einen Unterschied? Ich bin an einer Antwort für die C-Sprache interessiert, aber wenn es etwas Interessantes in der C ++ Sprache gibt, würde ich es gerne wissen.

const T und T const sind identisch. Bei pointerstypen wird es komplizierter:

  1. const char* ist ein pointers auf ein konstantes char
  2. char const* ist ein pointers auf ein konstantes char
  3. char* const ist ein konstanter pointers auf ein (veränderbares) char

Mit anderen Worten, (1) und (2) sind identisch. Die einzige Möglichkeit, den pointers (und nicht den pointers) const besteht darin, ein Suffix- const .

Das ist der Grund, warum viele Leute es vorziehen, const immer auf die richtige Seite des Typs zu setzen (“East const” -Stil): es macht seinen Ort relativ zum Typ konsistent und leicht zu merken (es scheint auch anekdotisch das Unterrichten zu erleichtern) Anfänger).

Der Trick besteht darin, die Deklaration rückwärts (von rechts nach links) zu lesen:

 const int a = 1; // read as "a is an integer which is constant" int const a = 1; // read as "a is a constant integer" 

Beides ist das Gleiche. Deshalb:

 a = 2; // Can't do because a is constant 

Der Lese-Rückwärts-Trick ist besonders praktisch, wenn Sie komplexere Deklarationen wie:

 const char *s; // read as "s is a pointer to a char that is constant" char c; char *const t = &c; // read as "t is a constant pointer to a char" *s = 'A'; // Can't do because the char is constant s++; // Can do because the pointer isn't constant *t = 'A'; // Can do because the char isn't constant t++; // Can't do because the pointer is constant 

Es gibt keinen Unterschied. Beide erklären “a” als eine ganze Zahl, die nicht geändert werden kann.

Der Ort, wo Unterschiede auftreten, ist, wenn Sie pointers verwenden.

Beide:

 const int *a int const *a 

deklarieren Sie “a” als pointers auf eine Ganzzahl, die sich nicht ändert. “a” kann zugewiesen werden, aber “* a” nicht.

 int * const a 

deklariert “a” als konstanten pointers auf eine Ganzzahl. “* a” kann zugewiesen werden, aber “a” nicht.

 const int * const a 

deklariert “a” als konstanten pointers auf eine konstante Ganzzahl. Weder “a” noch “* a” können zugeordnet werden.

 static int one = 1; int testfunc3 (const int *a) { *a = 1; /* Error */ a = &one; return *a; } int testfunc4 (int * const a) { *a = 1; a = &one; /* Error */ return *a; } int testfunc5 (const int * const a) { *a = 1; /* Error */ a = &one; /* Error */ return *a; } 

Prakash ist korrekt, dass die Deklarationen die gleichen sind, obwohl ein wenig mehr Erklärung des pointers-Falles in Ordnung sein könnte.

“const int * p” ist ein pointers auf ein int, das nicht zulässt, dass der int durch diesen pointers geändert wird. “int * const p” ist ein pointers auf ein int, das nicht so geändert werden kann, dass es auf ein anderes int verweist.

Siehe http://www.parashift.com/c++faq-lite/const-correctness.html#faq-18.5 .

const int ist identisch mit int const , was auch für alle skalaren Typen in C gilt. Im Allgemeinen wird die Deklaration eines skalaren functionsparameters als const nicht benötigt, da die Call-by-Value-Semantik von C bedeutet, dass alle Änderungen an der Variablen lokal sind seine umschließende function.

Dies ist keine direkte Antwort, sondern ein verwandter Tipp. Um die Dinge in Ordnung zu halten, benutze ich immer die Konvektion “setze const auf die Außenseite”, wobei “außen” meine ganz links oder ganz rechts bedeutet. Auf diese Weise gibt es keine Verwirrung – das Const gilt für das nächste Ding (entweder den Typ oder das * ). Z.B,

 int * const foo = ...; // Pointer cannot change, pointed to value can change const int * bar = ...; // Pointer can change, pointed to value cannot change int * baz = ...; // Pointer can change, pointed to value can change const int * const qux = ...; // Pointer cannot change, pointed to value cannot change 

Ja, sie sind gleich für nur int

und anders für int*

Ich denke in diesem Fall sind sie gleich, aber hier ist ein Beispiel, wo es auf die Reihenfolge ankommt:

 const int* cantChangeTheData; int* const cantChangeTheAddress; 

Sie sind gleich, aber in C ++ gibt es einen guten Grund, const immer auf der rechten Seite zu verwenden. Sie werden überall konsistent sein, weil konstante Elementfunktionen auf diese Weise deklariert werden müssen:

 int getInt() const; 

Es ändert den this pointers in der function von Foo * const nach Foo const * const . Siehe hier.