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

Переход на C ++ с языка, который не имеет концепции const, довольно сложен, многие не видят смысла.

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

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

Единственное, на что нужно обратить внимание, это точночто ты отмечаешьconst; const char * foo() это не то же самое, чтоchar * foo() const.

const отлично.const это важно.const-корректность является необходимым условием, чтобы API был хорошим.

Тем не менее, есть две проблемы, которые у меня были сconst, несколько раз.

Нет способа пометить переменную какconst задним числом. Вы должны либо объявить код переменной, в этом случае выимеют немедленно инициализировать его. Что делать, если код инициализации содержитif, хотя? У вас есть выбор: пропуститьconst (нежелательно), используя оператор? вместоif (ухудшает читабельность). Я понял, правильно, кстати -const переменные не должны быть инициализированы сразу, они просто должны быть инициализированыдо они сначала читаются, и они должны быть инициализированы ввсе ветвиif.

Нет никакого способа указать, что объект, переданный по ссылке на функцию, не изменится в течение всего времени вызова функции.const T& t делаетне означает, что объект, на который указываетt не изменится, но только то, что ссылкаt не может быть использован, чтобы изменить его. Компилятор все еще должен предполагать, что любой вызов функции, который он не видит вмог бы изменить объект. Это в некоторых случаях, что мешает довольно много оптимизаций.

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

Пример:

class TreeNode {
public:
    TreeNode& getParent() const { return *parent_; }
    TreeNode& getLeft()   const { return *left_;   }
    TreeNode& getRight()  const { return *right_;  }
private:
    //TreeNode has a pointer to the Tree to enable navigation of the tree.
    //Assume that other design constraints mean that this must be a pointer 
    //rather than a reference.
    TreeNode* parent_;
    TreeNode* left_;
    TreeNode* right_;
};
//This function demonstrates the ability for const to be subverted.
TreeNode& remove_const(TreeNode const& toRemoveConstFrom) {
    TreeNode& parent(toRemoveConstFrom.getParent());
    TreeNode& leftChild(parent.getLeft());
    TreeNode& rightChild(parent.getRight());
    return &toRemoveConstFrom == &leftChild ? leftChild : rightChild;
}

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

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

что программисты, которые используют его неправильно, непоследовательно

что язык также позволяет вам использовать const_cast, что в первую очередь лишает смысла использование const.

что все еще возможно подорвать это. то есть все еще законно делать что-то вроде этого:

void foo(const inst& x)
{
   const_cast<int&> x = 3;
}

Вы даже можете использовать такие вещи, какmemset подорвать его без явногоconst_cast.

Это компромисс между применением компиляторомconst и предоставляя некоторую гибкость для неconst осведомленные интерфейсы.

Что приводит к другому ограничению, заключающемуся в том, что оно не было принято повсеместно, что отчасти связано с другой проблемой, которая заключается в использованииconst это предложение "все или ничего". Если вы начнете использовать его, вам нужно будет распространять его по всей базе кода.

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

const является то, что X люди делают Y ". Это не ответы, носимптомы, Это не так плохо сconst, Там ведва что-то не так сconst...Это плохо с людьми, которые не могут RTFM.

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

Я иногда упоминал, что const на самом деле является дешевым способом «разбить» ваш интерфейс на методы только для чтения и методы записи. Это было бы непрактично в C ++. В Java было бы более практично иметь версии коллекций ReadOnly, где они не имеют const и где их типы коллекций более объектно-ориентированы.

const-ness не распространяется: проблема здесь в том, что если я pImpl мой класс, constness не «проверяется» компилятором, то есть мой класс интерфейса может иметь метод «const», вызывающий неконстантный метод в pImpl и компилятор не будет жаловаться. Это потому, что единственное, что мой метод const гарантированно не сделает, это поменяет указатель на другой объект, и мой pImpl никогда не изменится. Это может быть даже указатель const (не указатель на const).

Отсутствие правильного соотношения междуshared_ptr<T> а такжеshared_ptr<const T> тоже может быть проблемой, хотя в целом я видел, что проблема не в этом, но в том, что разработчики обычно вводят typedef для своих shared_ptrs и редко вводят определение shared_ptr для const. И они иногда будут проходитьconst shared_ptr<T> & и подумайте, что они передают общий указатель на const T (как с const T *), которым они не являются.