const int vs int const come parametro di funzione in C++ e C

Question

Domanda veloce:

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

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

sono questi due funzioni lo stesso in ogni aspetto o c'è una differenza? Sono interessato a una risposta per il linguaggio C, ma se c'è qualcosa di interessante nel caso C++ mi piacerebbe saperlo.

Answer 1

const T e T const sono identici. Prestare attenzione alla precedenza del puntatore, tuttavia:

char const* è un puntatore a un carattere costante (matrice), mentre char* const è un puntatore costante a un carattere mutabile (matrice).

Answer 2

Sì, sono uguali per appena int

e diverso per int*

Answer 3

Credo che in questo caso sono gli stessi, ma qui è un esempio in cui le questioni di ordine:

const int* cantChangeTheData; 
int* const cantChangeTheAddress; 

Answer 4

Prakash è corretto che le dichiarazioni sono le stesse, anche se un po 'più spiegazione del caso puntatore potrebbe essere in ordine

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

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

Answer 5

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

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

Entrambi questi:

const int *a 
int const *a 

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

int * const a 

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

const int * const a 

dichiara "a" come puntatore costante a un numero intero costante. Né "a" né "* a" possono essere assegnati 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; 
} 

Answer 6

Il trucco è quello di leggere la dichiarazione all'indietro (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.Pertanto:

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

La lettura all'indietro trucco viene particolarmente utile quando hai a che fare con le 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 

Answer 7

Questa non è una risposta diretta, ma un suggerimento relativo. Per mantenere le cose dritte, uso sempre la convezione "metti const all'esterno", dove con "fuori" intendo l'estrema sinistra o l'estrema destra. In questo modo non c'è confusione - il const si applica alla cosa più vicina (o il tipo o lo *). Ad 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 

Answer 8

const int è identico a int const, come è vero con tutti i tipi scalari in C. In generale, dichiarare un parametro di funzione scalare come const non è necessaria, poiché semantica call-by-value di C significa che qualsiasi le modifiche alla variabile sono locali alla sua funzione di chiusura.

Answer 9

Sono uguali, ma in C++ c'è una buona ragione per usare sempre const sulla destra. Sarete coerente in tutto il mondo, perché le funzioni membro const devono essere dichiarati in questo modo:

int getInt() const; 

cambia il puntatore this nella funzione Foo * const-Foo const * const. See here.