'const int' vs. 'int const' como parâmetros de função em C ++ e C

Considerar:

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

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

Essas duas funções são iguais em todos os aspectos ou há uma diferença?

Estou interessado em uma resposta para a linguagem C, mas se houver algo interessante na linguagem C ++, gostaria de saber também.

const Te T constsão idênticos. Com os tipos de ponteiro, fica mais complicado:

1. const char* é um ponteiro para uma constante char
2. char const* é um ponteiro para uma constante char
3. char* const é um ponteiro constante para um (mutável) char

Em outras palavras, (1) e (2) são idênticos. A única maneira de fazer a ponta (em vez da ponta) consté usar um sufixo- const.

É por isso que muitas pessoas preferem sempre colocar constdo lado direito do tipo (estilo "Const do Leste"): isso torna sua localização em relação ao tipo consistente e fácil de lembrar (também anedoticamente parece tornar mais fácil de ensinar para iniciantes )

O truque é ler a declaração de trás para frente (da direita para a esquerda):

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 são a mesma coisa. Portanto:

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

O truque da leitura reversa é especialmente útil quando você está lidando com declarações mais complexas, 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

Não há diferença. Ambos declaram que "a" é um número inteiro que não pode ser alterado.

O lugar onde as diferenças começam a aparecer é quando você usa ponteiros.

Ambos estes:

const int *a
int const *a

declare "a" como um ponteiro para um inteiro que não muda. "a" pode ser atribuído, mas "* a" não.

int * const a

declara "a" como um ponteiro constante para um inteiro. "* a" pode ser atribuído, mas "a" não.

const int * const a

declara "a" como um ponteiro constante para um número inteiro constante. Nem "a" nem "* a" podem ser atribuídos.

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 está correto ao dizer que as declarações são as mesmas, embora um pouco mais de explicação sobre o caso do ponteiro possa ser necessário.

"const int * p" é um ponteiro para um int que não permite que o int seja alterado por meio desse ponteiro. "int * const p" é um ponteiro para um int que não pode ser alterado para apontar para outro int.

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

const inté idêntico a int const, como é verdadeiro com todos os tipos escalares em C. Em geral, declarar um parâmetro de função escalar como constnão é necessário, uma vez que a semântica de chamada por valor de C significa que quaisquer alterações na variável são locais para sua função envolvente.

Esta não é uma resposta direta, mas uma dica relacionada. Para manter as coisas retas, sempre uso a convecção "colocar constdo lado de fora", onde por "fora" quero dizer extrema esquerda ou extrema direita. Dessa forma, não há confusão - a const se aplica à coisa mais próxima (o tipo ou o *). Por exemplo,

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

Eles são iguais, mas em C ++ há um bom motivo para sempre usar const à direita. Você será consistente em todos os lugares porque as funções-membro const devem ser declaradas desta forma:

int getInt() const;

Ele muda o thisponteiro na função de Foo * constpara Foo const * const. Veja aqui.

Sim, eles são iguais por apenas int

e diferente para int*

Acho que, neste caso, são iguais, mas aqui está um exemplo em que a ordem é importante:

const int* cantChangeTheData;
int* const cantChangeTheAddress;