c++ - que - const javascript

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

Question

Pregunta rápida:

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 interesado en el caso C ++ también me gustaría saberlo.

Answer 1

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

const int* cantChangeTheData;
int* const cantChangeTheAddress;

Answer 2

El truco es 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 lectura hacia atrá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

Answer 3

Esta no es una respuesta directa, sino un consejo relacionado. Para mantener las cosas en orden, siempre utilizo la convección "poner const en el exterior", donde por "fuera" me refiero a la extrema izquierda o la extrema derecha. De esta forma no hay confusión: la const se aplica a lo más cercano (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

Answer 4

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 usa punteros.

Ambos:

const int *a
int const *a

declara "a" como un puntero a un entero que no cambia. "a" se puede asignar a, pero "* a" no se puede.

int * const a

declara que "a" es un puntero constante a un entero. "* a" se puede asignar a, pero "a" no se puede asignar.

const int * const a

declara que "a" es un puntero constante a un entero constante. Ni "a" ni "* a" pueden asignarse.

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;
}

Answer 5

Prakash tiene razón en que las declaraciones son las mismas, aunque podría ser necesaria una explicación un poco más del caso del puntero.

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

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

Answer 6

Sí, son iguales solo por int

y diferente para int*

Answer 7

Son lo mismo, 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 de const deben declararse de esta manera:

int getInt() const;

Cambia this puntero en la función de Foo * const a Foo const * const . Mira aquí.

Answer 8

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

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

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

Esta es la razón por la que muchas personas prefieren poner siempre const el lado derecho del tipo (estilo "East const"): hace que su ubicación relativa al tipo sea consistente y fácil de recordar (también parece que, de manera anecdótica, parece más fácil enseñarle principiantes).

Answer 9

const int es idéntico a int const , como ocurre con todos los tipos escalares en C. En general, no es necesario declarar un parámetro de función escalar como const , ya que la semántica de call-by-value de C significa que cualquier cambio en la variable es local a su función adjunta.