Используя 'константу' в функциях класса [дубликат]

Значение заключается в том, что вы гарантируете клиентам, вызывающим Const Function, что состояние объекта не изменится. Поэтому, когда вы говорите, что функция участника - это const, это означает, что вы не изменяете никаких изменений элементов объектов во время вызова функции.

Это совершенно необычно, чтобы не хотеть иметь какие-либо переменные элемента изменились, но если это то, что требует ваш класс, то вам следует сделать все ваши функции участника Const.

Тем не менее, вы, вероятно, хотите, чтобы изменить, по крайней мере, некоторые члены:

class A {
  private: 
    int val;
  public:
    A() : val(0) {}
    void Inc() { val++; }
    int GetVal() const { return val; };
};

Теперь, если я создаю два случая A:

A a1;
const A a2;

, я могу сказать:

a1.GetVal();
a2.GetVal();

Но я могу только сказать:

a1.Inc();

, пытаясь изменить Значение постоянного объекта:

a2.Inc();

дает ошибку компиляции.

Другие ответили на техническую сторону вашего вопроса о функциях членов const, но здесь есть более общая картина -- и это идея const корректности .

Короче говоря, корректность const - это уточнение и приведение в исполнение семантики вашего кода. Возьмём простой пример. Посмотрите на объявление этой функции:

bool DoTheThing(char* message);

Предположим, кто-то другой написал эту функцию, и вам нужно ее вызвать. Знаете ли вы, что DoTheThing() делает с вашим char-буфером? Может быть, он просто записывает сообщение в файл, а может быть, он изменяет строку. Невозможно определить семантику вызова, просто посмотрев на объявление функции. Если функция не изменяет строку, то объявление константируется неверно.

Есть практическое значение и для того, чтобы сделать ваши функции const корректными. А именно, в зависимости от контекста вызова, вы не сможете вызвать const-incorrect функции без некоторой хитрости. Например, предположим, что вы знаете, что DoTheThing() не изменяет содержимое переданной ему строки, и у вас есть такой код:

void MyFunction()
{
  std::string msg = "Hello, const correctness";
  DoTheThing(msg.c_str());
}

Вышеприведенный код не скомпилируется, так как msg.c_str() возвращает const char*. Чтобы этот код скомпилировался, необходимо сделать что-то вроде:

void MyFunction()
{
  std::string msg = "Hello, const correctness";
  DoTheThing(msg.begin());
}

...или даже хуже:

void MyFunction()
{
  std::string msg = "Hello, const correctness";
  DoTheThing(const_cast<char*>(msg.c_str()));
}

, ни один из которых, возможно, не 'лучше', чем исходный код. Но так как DoTheThing() был написан const-incorrect способом, то вы должны согнуть свой код вокруг него.

Если это правда, то следует использовать его везде, потому что я не хочу, чтобы ни одного из переменных элементов быть измененным или измененным любым способом?

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

Ключевое слово const, используемое после метода, указывает на то, что этот метод не изменяет объект, на который он вызывается. Таким образом, этот метод может быть вызван для const-версии объекта.

const, при приложении к нестатическому методу класса сообщает компилятору, что ваша функция не модифицирует внутреннее состояние объекта.

Это полезно двумя способами:

• Если вы делаете код записи, который меняет внутреннее состояние в методе вашего const, компилятор ловит ошибку, перемещая ошибку программирования от времени выполнения для компиляции времени.
• Если код клиента вызывает метод Non-Const на постоянном указателе, компилятор ловит ошибку, обеспечивая сохранение «цепочки не меняющихся вещей».

Обычно вы хотите объявить все неутирующие нестатические методы классов как Const. Это позволяет призвать код использовать Const Qualifier по указателям, и он помогает ловить ошибки.

Типичный C ++: Вы можете объявить переменную классы «Metable», а затем измените его даже из метода Const.