Const ИНТ против Int сопзЬ в качестве параметра функции в C++ и C

Question

Быстрый вопрос:

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

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

Являются ли эти две функции одинаковы в каждом аспекте, или есть разница? Я интересуюсь ответом на C-язык, но если есть что-то интересное в случае C++, которое я хотел бы знать.

Answer 1

const T и T const идентичны. Однако обратите внимание на приоритет указателя:

char const* - указатель на постоянный символ (массив), а char* const - постоянный указатель на изменяемый символ (массив).

Answer 2

Да, они одинаковы для всего int

и различен для int*

Answer 3

Я думаю, что в этом случае они одинаковы, но вот пример, где вопросы порядка:

const int* cantChangeTheData; 
int* const cantChangeTheAddress; 

Answer 4

Пракаш является правильным, что заявления, то же самое, хотя и немного больше объяснений по делу указателя может быть в порядке.

«const int * p» - это указатель на int, который не позволяет изменять int с помощью этого указателя. «int * const p» - это указатель на int, который нельзя изменить, чтобы указать на другой int.

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

Answer 5

Нет никакой разницы. Оба объявляют «a» целым числом, которое невозможно изменить.

Место, где различия появляются, - это когда вы используете указатели.

Оба эти:

const int *a 
int const *a 

объявить «а» быть указателем на целое число, которое не меняется. «a» может быть назначено, но «* a» не может.

int * const a 

объявляет «a» постоянным указателем на целое число. «* a» может быть назначено, но «a» не может.

const int * const a 

объявляет «a» постоянным указателем на постоянное целое число. Ни «a», ни «* 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

Хитрость заключается в том, чтобы прочитать объявление в обратном направлении (справа налево):

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

И одно и то же.Поэтому:

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

Показание назад трюк особенно полезно, когда вы имеете дело с более сложными деклараций, таких как:

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

Это не является прямым ответом, но связанный наконечник. Чтобы все было в порядке, я всегда использую конвекцию «положить const снаружи», где «снаружи» я имею в виду дальний левый или правый правый. Таким образом, нет путаницы - константа относится к ближайшей вещи (либо к типу, либо к *). Например,

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 идентичен int const, как это имеет место со всеми скалярными типами в C. В общем, объявлении параметре скалярной функции, как const не требуется, поскольку вызов по значению семантики C означает, что любое изменения в переменной локальны для ее закрывающей функции.

Answer 9

Это то же самое, но в C++ есть веская причина всегда использовать const справа. Вы будете соответствовать везде, поскольку функция сопза членов должен быть объявлена ​​следующим образом:

int getInt() const; 

Он изменяет this указателя в функции от Foo * const к Foo const * const. See here.