'const int' vs. 'int const' come parametri di funzione in C ++ e C

Tener conto di:

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

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

Queste due funzioni sono uguali in ogni aspetto o c'è una differenza?

Mi interessa una risposta per il linguaggio C, ma se c'è qualcosa di interessante nel linguaggio C ++, vorrei saperlo anch'io.

const Te T constsono identici. Con i tipi di puntatore diventa più complicato:

1. const char* è un puntatore a una costante char
2. char const* è un puntatore a una costante char
3. char* const è un puntatore costante a (mutabile) char

In altre parole, (1) e (2) sono identici. L'unico modo per creare il puntatore (piuttosto che le punte) constè usare un suffisso- const.

Questo è il motivo per cui molte persone preferiscono mettere sempre constsul lato destro del tipo (stile "East const"): rende coerente e facile da ricordare la sua posizione rispetto al tipo (sembra anche aneddoticamente rendere più facile insegnare ai principianti ).

Il trucco è leggere la dichiarazione al contrario (da destra a sinistra):

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

Entrambi sono la stessa cosa. Perciò:

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

Il trucco della lettura all'indietro è particolarmente utile quando hai a che fare con dichiarazioni più complesse come:

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

Non c'è differenza. Entrambi dichiarano "a" un numero intero che non può essere modificato.

Il punto in cui iniziano ad apparire le differenze è quando usi i puntatori.

Entrambi:

const int *a
int const *a

dichiarare "a" come puntatore a un numero intero che non cambia. "a" può essere assegnato, ma "* a" no.

int * const a

dichiara "a" come puntatore costante a un numero intero. "* a" può essere assegnato, ma "a" no.

const int * const a

dichiara "a" come puntatore costante a un numero intero costante. Non è possibile assegnare né "a" né "* 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 ha ragione sul fatto che le dichiarazioni sono le stesse, anche se potrebbe essere necessaria una spiegazione un po 'più del caso del puntatore.

"const int * p" è un puntatore a un int che non consente la modifica di int tramite quel puntatore. "int * const p" è un puntatore a un int che non può essere modificato per puntare a un altro int.

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

const intè identico a int const, come è vero con tutti i tipi scalari in C. In generale, dichiarare un parametro di funzione scalare come constnon è necessario, poiché la semantica di chiamata per valore di C significa che qualsiasi modifica alla variabile è locale alla sua funzione che lo racchiude.

Questa non è una risposta diretta ma un suggerimento correlato. Per mantenere le cose dritte, uso sempre la convezione "messo constfuori", dove per "esterno" intendo l'estrema sinistra o l'estrema destra. In questo modo non c'è confusione: la const si applica alla cosa più vicina (il tipo o il *). Per esempio,

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

Sono gli stessi, ma in C ++ c'è una buona ragione per usare sempre const a destra. Sarai coerente ovunque perché le funzioni membro const devono essere dichiarate in questo modo:

int getInt() const;

Cambia il thispuntatore nella funzione da Foo * consta Foo const * const. Vedere qui.

Sì, sono gli stessi per solo int

e diverso per int*

Penso che in questo caso siano gli stessi, ma ecco un esempio in cui l'ordine è importante:

const int* cantChangeTheData;
int* const cantChangeTheAddress;