'const int' vs. 'int const' als Funktionsparameter in C ++ und C.

Erwägen:

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

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

Sind diese beiden Funktionen in jeder Hinsicht gleich oder gibt es einen Unterschied?

Ich bin an einer Antwort für die C-Sprache interessiert, aber wenn die C ++ - Sprache etwas Interessantes enthält, würde ich es auch gerne wissen.

const Tund T constsind identisch. Mit Zeigertypen wird es komplizierter:

1. const char* ist ein Zeiger auf eine Konstante char
2. char const* ist ein Zeiger auf eine Konstante char
3. char* const ist ein konstanter Zeiger auf a (veränderlich) char

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

Aus diesem Grund ziehen es viele Menschen vor, immer constauf die rechte Seite des Typs zu setzen („East const“ -Stil): Dadurch wird seine Position relativ zum Typ konsistent und leicht zu merken (es scheint auch anekdotisch einfacher zu sein, Anfängern beizubringen ).

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

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 dasselbe. Deshalb:

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

Der Trick zum Rückwärtslesen ist besonders praktisch, wenn Sie mit komplexeren Deklarationen wie den folgenden umgehen:

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 deklarieren "a" als eine Ganzzahl, die nicht geändert werden kann.

Die Stelle, an der Unterschiede auftreten, ist die Verwendung von Zeigern.

Beide:

const int *a
int const *a

Deklarieren Sie "a" als Zeiger auf eine Ganzzahl, die sich nicht ändert. "a" kann zugewiesen werden, "* a" jedoch nicht.

int * const a

deklariert "a" als konstanten Zeiger auf eine Ganzzahl. "* a" kann zugewiesen werden, "a" jedoch nicht.

const int * const a

deklariert "a" als konstanten Zeiger 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 hat Recht, dass die Deklarationen gleich sind, obwohl eine etwas ausführlichere Erklärung des Zeigerfalls angebracht sein könnte.

"const int * p" ist ein Zeiger auf ein int, mit dem das int nicht über diesen Zeiger geändert werden kann. "int * const p" ist ein Zeiger auf ein int, das nicht geändert werden kann, um auf ein anderes int zu zeigen.

Siehe https://isocpp.org/wiki/faq/const-correctness#const-ptr-vs-ptr-const .

const intist identisch mit int const, wie es bei allen Skalartypen in C der Fall ist. Im Allgemeinen ist das Deklarieren eines Skalarfunktionsparameters als constnicht erforderlich, da die Call-by-Value-Semantik von C bedeutet, dass alle Änderungen an der Variablen lokal für die umschließende Funktion sind.

Dies ist keine direkte Antwort, sondern ein verwandter Tipp. Um die Dinge gerade zu halten, verwende ich immer die Konvektion " constaußen angelegt", wobei mit "außen" ganz links oder ganz rechts gemeint ist. Auf diese Weise gibt es keine Verwirrung - die Konstante gilt für die nächste Sache (entweder den Typ oder die *). 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

Sie sind die gleichen, aber in C ++ gibt es einen guten Grund, immer rechts const zu verwenden. Sie werden im Einklang überall da konstanten Elementfunktionen müssen auf diese Weise erklärt werden:

int getInt() const;

Es ändert den thisZeiger in der Funktion von Foo * constnach Foo const * const. Siehe hier.

Ja, sie sind nur für gleich int

und anders für int*

Ich denke in diesem Fall sind sie gleich, aber hier ist ein Beispiel, wo Ordnung wichtig ist:

const int* cantChangeTheData;
int* const cantChangeTheAddress;