'const int' против 'int const' как параметры функции в C ++ и C

Рассматривать:

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

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

Эти две функции одинаковы во всех аспектах или есть разница?

Меня интересует ответ для языка C, но если есть что-то интересное в языке C ++, я бы тоже хотел знать.

const Tи T constидентичны. С типами указателей все становится сложнее:

1. const char* указатель на константу char
2. char const* указатель на константу char
3. char* const постоянный указатель на (изменяемый) char

Другими словами, (1) и (2) идентичны. Единственный способ сделать указатель (а не указатель) const- использовать суффикс- const.

Вот почему многие люди предпочитают всегда ставить constсправа от шрифта (стиль «Восточная константа»): это делает его расположение относительно типа последовательным и легким для запоминания (это также, по некоторым данным, упрощает обучение начинающих. ).

Уловка состоит в том, чтобы прочитать декларацию в обратном порядке (справа налево):

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

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

Различия начинают проявляться при использовании указателей.

Оба эти:

const int *a
int const *a

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

int * const 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;
}

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

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

См. Https://isocpp.org/wiki/faq/const-correctness#const-ptr-vs-ptr-const .

const intидентично int const, как и верно, для всех скалярных типов в C. В общем, объявление параметра скалярной функции как constне требуется, поскольку семантика вызова C по значению означает, что любые изменения в переменной являются локальными для ее включающей функции.

Это не прямой ответ, а соответствующий совет. Чтобы все было прямо, я всегда использую конвекцию «положить 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

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

int getInt() const;

Он изменяет thisуказатель в функции с Foo * constна Foo const * const. Посмотреть здесь.

Да они такие же только int

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

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

const int* cantChangeTheData;
int* const cantChangeTheAddress;