Ключевое слово константы C++ - использует подробно?

Во-первых, это просто деталь реализации, и , если вы поместите туда const , не помещайте его в набор объявлений (заголовок). Поместите его только в файл реализации:

// header
void MyFunction(int age, House &purchased_house);

// .cpp file
void MyFunction(const int age, House &purchased_house);
{
    ...
}

Независимо от того, является ли параметр константой в определении, это чисто деталь реализации и не должна быть частью интерфейса.

Я нечасто видел подобные вещи, и я тоже не делаю этого. Параметр const сбивал бы меня с толку чаще, чем помогал бы, потому что я бы сразу же сопоставил с шаблоном-провалил бы его до "const int & age" :) Конечно, дело совсем не в том, чтобы иметь const на другом уровне:

// const is a *good* thing here, and should not be removed,
// and it is part of the interface
void MyFunction(const string &name, House &purchased_house);
{
    ...
}

В этом случае константа будет влиять на то, может ли функция изменять аргумент вызывающего объекта. Const в этом смысле следует использовать как можно чаще,

Вы не только указываете, что он не изменится, но и не позволяете вашему коду думать, что это возможно, и это будет обнаружено во время компиляции.

См. Мейерс и «Эффективный C ++» по этому поводу и действительно свободно используйте const, особенно с семантикой передачи по ссылке.

В случае атомарных переменных эффективность не имеет значения, но ясность кода все же выигрывает.

Вы правы, единственная цель "const int age" состоит в том, что возраст нельзя изменить. Однако это может сбивать с толку большинство программистов. Поэтому, если этот подход не используется широко в вашем коде, я бы посоветовал опустить const.

Одним из преимуществ использования const является то, что вы не можете случайно изменить значение age в середине MyFunction (в событие, которое вы забыли, не было передано по ссылке). Одним из «недостатков» является то, что вы не можете переработать age с помощью кода вроде foo.process (++ age); .

Второй вариант лучше. В первом можно случайно изменить переменную возраста.

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

С другой стороны, rreferences и нетривиальные типы объектов всегда должны использовать const, если нет будут любые изменения, внесенные в объект. Теоретически это могло бы позволить некоторую оптимизацию, но большой выигрыш - это контракт, о котором я упоминал выше. Обратной стороной, конечно же, является то, что он может сделать ваш интерфейс намного больше, и его сложно модернизировать в существующую систему (или со сторонним API, не использующим const везде).

Ну, как уже говорили другие, с точки зрения языка C ++, указанная выше const не влияет на сигнатуру функции, т.е. тип функции остается тем же независимо от того, присутствует ли там const или нет. Единственный эффект, который он оказывает на уровне абстрактного языка C ++, заключается в том, что вы не можете изменять этот параметр внутри тела функции.

Однако на более низком уровне модификатор const применяется к значению параметра может иметь некоторые преимущества оптимизации при наличии достаточно умного компилятора. Рассмотрим две функции с одним и тем же набором параметров (для простоты)

int foo(const int a, const double b, const long c) {
   /* whatever */
}

void bar(const int a, const double b, const long c) {
   /* whatever */
}

Скажем, где-то в коде они вызываются следующим образом

foo(x, d, m);
bar(x, d, m);

Обычно компиляторы подготавливают кадр стека с аргументами перед вызовом функции. В этом случае стек обычно готовится дважды: по одному на каждый вызов. Но умный компилятор может понять, что, поскольку эти функции не изменяют свои локальные значения параметров (объявленные с помощью const ), набор аргументов, подготовленный для первого вызова, можно безопасно повторно использовать для второго вызова. Таким образом, он может подготовить стек только один раз.

Это довольно редкая и непонятная оптимизация, которая может работать только тогда, когда определение функции известно в момент вызова (либо та же единица трансляции, либо расширенная глобально- оптимизирующий компилятор), но иногда стоит упомянуть.

Неправильно говорить, что он «бесполезен» или «не действует», даже если это может иметь место с типичным компилятором.

Еще одно соображение, о котором стоит упомянуть, имеет другую природу. Существуют стандарты кодирования, которые требуют, чтобы кодировщики не изменяли начальные значения параметров, например, «не используйте параметры как обычные локальные переменные, значения параметров должны оставаться неизменными на протяжении всей функции». В этом есть смысл, поскольку иногда легче определить, какие значения параметров были изначально заданы функции (в отладчике внутри тела функции). Чтобы обеспечить соблюдение этого стандарта кодирования, люди могут использовать спецификаторы const для значений параметров. Стоит оно того или нет - другой вопрос ...

поскольку иногда это упрощает определение значений параметров, которые были изначально заданы функции (в отладчике, внутри тела функции). Чтобы обеспечить соблюдение этого стандарта кодирования, люди могут использовать спецификаторы const для значений параметров. Стоит оно того или нет - другой вопрос ...

поскольку иногда это упрощает определение значений параметров, которые были изначально заданы функции (в отладчике, внутри тела функции). Чтобы обеспечить соблюдение этого стандарта кодирования, люди могут использовать спецификаторы const для значений параметров. Стоит оно того или нет - другой вопрос ...

Рекомендую прочитать Херб Саттер. Исключительный C ++ . Есть глава «Const-Correctness».

«Фактически, для компилятора сигнатура функции одинакова, независимо от того, включаете ли вы эту константу перед параметром значения или нет».

Это означает, что эта сигнатура

void print(int number);

фактически то же самое, что и этот:

void print(int const number);

Итак, для компилятора нет разницы, как вы объявляете функцию. И вы не можете перегрузить его, поместив ключевое слово const перед параметром, передаваемым по значению.

Прочтите, что рекомендует Херб Саттер:

«Избегайте константных параметров передачи по значению в объявлениях функций. параметр const в определении той же функции, если он не будет изменен ».

Он рекомендует избегать этого:

void print(int const number);

Поскольку эта константа сбивает с толку, многословна и избыточна.

Но в определении вы должны сделать это (если вы не измените параметр):

void print(int const number)
{
   // I don't want to change the number accidentally here
   ...
}

Итак, вы убедитесь, что даже после 1000 строк тела функции номер всегда остается нетронутым. Компилятор запретит вам передавать число как неконстантную ссылку на другую функцию.

Вы должны использовать const для параметра, если (и только если) вы будете использовать его для любой другой локальной переменной, которая не будет изменена:

const int age_last_year = age - YEAR;

Иногда бывает удобно отмечать локальные переменные как const, где это возможно, поскольку это означает, что вы можете посмотреть объявление и узнать значение, не думая о промежуточном коде. Вы можете легко изменить его в будущем (и убедитесь, что вы не нарушили код в функции, и, возможно, измените имя переменной, если теперь она представляет что-то немного другое, которое можно изменить, в отличие от предыдущего неизменяемого вещь).

В отличие от этого, он делает код более подробным, и в короткой функции почти всегда очень очевидно, какие переменные меняются, а какие нет.

Итак, либо:

void MyFunction(const int age, House &purchased_house)
{
    const int age_last_year = age - YEAR;
}

, либо:

void MyFunction(int age, House &purchased_house)
{
    int age_last_year = age - YEAR;
}

Вот несколько замечательных статей и книга, которые я нашел, объясняющие преимущества использования const:

• C ++ const Корректность

• Совет от экспертов C ++: будьте Const-Correct

• Эффективно C ++ от Скотта Мейерса

---

Могу я предложить вам следующую максиму?

Если объект / переменная может быть квалифицирована как постоянная, так и должно быть. В худшем - ничего не будет стоить. В лучшем случае вы будете документировать роль объекта / переменной в своем коде, и это даст компилятору возможность еще больше оптимизировать ваш код.

Некоторые компиляторы не используют возможности оптимизации с использованием 'const 'и это привело к тому, что многие эксперты пренебрегли использованием постоянных параметров по значению, когда их можно было использовать. Это требует большей строгости, но вреда от этого не будет. В худшем случае, вы ничего не теряете, но и ничего не получаете, и в лучшем случае вы выиграете от использования этого подхода.

---

Для тех, кто, похоже, не понимает полезности константы в параметре по значению функции / метода ... вот короткий пример, объясняющий, почему:

.cpp

void WriteSequence(int const *, const int);

int main()
{
    int Array[] = { 2, 3, 4, 10, 12 };
    WriteSequence(Array, 5);
}


#include <iostream>
using std::cout;
using std::endl;
void WriteSequence(int const *Array, const int MAX)
{
    for (int const * i = Array; i != Array + MAX; ++i)
      cout << *i << endl;
}

Что бы произошло, если бы я удалил константу перед int MAX и написал бы MAX + 1 внутри вот так?

void WriteSequence(int Array[], int MAX)
{
    MAX += MAX;
    for (int * i = Array; i != Array + MAX; ++i)
      cout << *i << endl;
}

Ваша программа вылетит! Итак, зачем кому-то писать «MAX + = MAX;» ? Возможно, человеческая ошибка, возможно, программист в тот день плохо себя чувствовал или, возможно, программист просто не знал, как писать код C / C ++. Если бы у вас была const, код бы даже не компилировался!

Безопасный код - это хороший код, и ничего не стоит добавлять «const», когда он у вас есть! передается по значению, так как вы не будете изменять объект вызывающего абонента. "

Неверно.

Речь идет о самодокументировании вашего кода и ваши предположения.

Если в вашем коде много людей работает на нем и ваши функции нетривиально то вы должны отметить "const" все, что вы Можно. При написании промышленной силы код, вы всегда должны предполагать, что ваши коллеги психопаты пытаются чтобы доставить тебя любым способом (тем более, что часто ты сам в будущем).

Кроме того, как кто-то упомянул раньше это могло помочь компилятору немного оптимизировать (хотя это длинный план).

Вот ссылка: ответ .