'const int' vs. 'int const' como parámetros de función en C ++ y C

Considerar:

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

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

¿Son estas dos funciones iguales en todos los aspectos o hay alguna diferencia?

Estoy interesado en una respuesta para el lenguaje C, pero si hay algo interesante en el lenguaje C ++, me gustaría saberlo también.

const Ty T constson idénticos. Con los tipos de puntero se vuelve más complicado:

1. const char* es un puntero a una constante char
2. char const* es un puntero a una constante char
3. char* const es un puntero constante a a (mutable) char

En otras palabras, (1) y (2) son idénticos. La única forma de hacer el puntero (en lugar del puntero) constes usar un sufijo- const.

Esta es la razón por la que muchas personas prefieren colocar siempre consten el lado derecho del tipo (estilo "East const"): hace que su ubicación en relación con el tipo sea consistente y fácil de recordar (también anecdóticamente parece facilitar la enseñanza a los principiantes ).

El truco consiste en leer la declaración al revés (de derecha a izquierda):

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

Ambos son lo mismo. Por lo tanto:

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

El truco de leer al revés es especialmente útil cuando se trata de declaraciones más complejas como:

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

No hay diferencia. Ambos declaran que "a" es un número entero que no se puede cambiar.

El lugar donde comienzan a aparecer las diferencias es cuando usas punteros.

Ambos:

const int *a
int const *a

declare "a" como un puntero a un número entero que no cambia. Se puede asignar "a", pero no "* a".

int * const a

declara que "a" es un puntero constante a un número entero. Se puede asignar "* a", pero no "a".

const int * const a

declara que "a" es un puntero constante a un entero constante. No se puede asignar "a" ni "* a".

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 tiene razón en que las declaraciones son las mismas, aunque podría ser necesario un poco más de explicación del caso del puntero.

"const int * p" es un puntero a un int que no permite cambiar el int a través de ese puntero. "int * const p" es un puntero a un int que no se puede cambiar para que apunte a otro int.

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

const intes idéntico a int const, como es cierto con todos los tipos escalares en C. En general, declarar un parámetro de función escalar como constno es necesario, ya que la semántica de llamada por valor de C significa que cualquier cambio en la variable es local a su función envolvente.

Esta no es una respuesta directa, sino un consejo relacionado. Para mantener las cosas en orden, siempre uso la convección "poner consten el exterior", donde por "exterior" me refiero al extremo izquierdo o al extremo derecho. De esa manera no hay confusión: la constante se aplica a lo más parecido (ya sea el tipo o el *). P.ej,

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

Son iguales, pero en C ++ hay una buena razón para usar siempre const a la derecha. Serás consistente en todas partes porque las funciones miembro const deben declararse de esta manera:

int getInt() const;

Cambia el thispuntero en la función de Foo * consta Foo const * const. Mira aquí.

Si, son iguales por solo int

y diferente para int*

Creo que en este caso son iguales, pero aquí hay un ejemplo donde el orden importa:

const int* cantChangeTheData;
int* const cantChangeTheAddress;