Продай меня за правильность констант

Так почему же всегда рекомендуется использовать const как можно чаще? Мне кажется, что использование const может быть больше проблемой, чем помочь в C ++. Но опять же, я подхожу к этому с точки зрения Python: если вы не хотите, чтобы что-то изменялось, не меняйте это. С учетом сказанного, вот несколько вопросов:

1. Кажется, что каждый раз, когда я помечаю что-то как const, я получаю сообщение об ошибке и мне приходится где-то менять какую-то другую функцию, чтобы она тоже была const. Тогда это заставляет меня менять другую функцию в другом месте. Разве это становится легче с опытом?

2. Являются ли преимущества использования сопза действительно достаточно , чтобы компенсировать проблемы? Если вы не собираетесь изменять объект, почему бы просто не написать код, который его не меняет?

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

Это исчерпывающая статья о «корректности констант»: https://isocpp.org/wiki/faq/const-correctness .

Короче говоря, использование const - хорошая практика, потому что ...

1. Он защищает вас от случайного изменения переменных, которые не предполагается изменять,
2. Он защищает вас от случайного присвоения переменных и

3. Компилятор может его оптимизировать. Например, вы защищены от

   if( x = y ) // whoops, meant if( x == y )

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

Вы правы в том, что может быть сложно последовательно использовать константную корректность, но конечный код более краток и безопаснее для программирования. Когда вы много занимаетесь разработкой на C ++, преимущества этого быстро проявляются.

Вот фрагмент кода с распространенной ошибкой, от которой вас может защитить корректность const:

void foo(const int DEFCON)
{
   if (DEFCON = 1)     //< FLAGGED AS COMPILER ERROR! WORLD SAVED!
   {
       fire_missiles();
   }
}

Кажется, что каждый раз, когда я помечаю что-то как const, я получаю сообщение об ошибке и мне приходится где-то менять какую-то другую функцию, чтобы она тоже была const. Тогда это заставляет меня менять другую функцию где-то еще. Разве это становится легче с опытом?

По опыту, это полный миф. Конечно, это происходит, когда неконстантно-правильный код находится с константно-правильным кодом. Если вы с самого начала разрабатываете const-corrective, это НИКОГДА не должно быть проблемой. Если вы делаете что-то const, а затем что-то еще не компилируется, компилятор сообщает вам что-то чрезвычайно важное, и вы должны найти время, чтобы исправить это должным образом .

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

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

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

Мои причины быть правильными:

• Он сообщает клиентам вашей функции, что вы не будете изменять переменную или объект.
• Принятие аргументов по константной ссылке дает вам эффективность передачи по ссылке с безопасностью передачи по значению.
• Написание ваших интерфейсов как правильных констант позволит клиентам использовать их. Если вы пишете свой интерфейс так, чтобы он принимал неконстантные ссылки, клиентам, использующим константу, потребуется отбросить константу, чтобы работать с вами. Это особенно раздражает, если ваш интерфейс принимает неконстантные char *, а ваши клиенты используют std :: strings, поскольку вы можете получить только от них const char *.
• Использование const заставит компилятор поддерживать вашу честность, чтобы вы по ошибке не изменили то, что не должно измениться.

Моя философия заключается в том, что если вы собираетесь использовать придирчивый язык с проверками времени компиляции, используйте его как можно лучше. const- это принудительный способ передать то, что вы имеете в виду, компилятор ... он лучше, чем комментарии или doxygen. Вы платите цену, почему бы не получить ценность?

Программирование на C ++ без const похоже на вождение без ремня безопасности.

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

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

Для встроенного программирования, используя const разумное при объявлении глобальных структур данных может сэкономить много оперативной памяти, заставляя постоянные данные располагаться в ПЗУ или флэш-памяти без копирования в ОЗУ во время загрузки.

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

При работе с другими программистами над крупными проектами constправильное использование помогает предотвратить удушение другими программистами.

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

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

Пример:

#include <iostream>

class HelloWorld {
    bool hw_called;

public:
    HelloWorld() : hw_called(false) {}

    void hw() const {
        std::cout << "Hello, world! (const)\n";
        // hw_called = true;  <-- not allowed
    }

    void hw() {
        std::cout << "Hello, world! (non-const)\n";
        hw_called = true;
    }
};

int
main()
{
    HelloWorld hw;
    HelloWorld* phw1(&hw);
    HelloWorld const* phw2(&hw);

    hw.hw();    // calls non-const version
    phw1->hw(); // calls non-const version
    phw2->hw(); // calls const version
    return 0;
}

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

В большей части кода, который я пишу, усилия стоили того, потому что мы часто используем композицию:

class A { ... }
class B { A m_a; const A& getA() const { return m_a; } };

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

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

Скажем, у вас есть переменная в Python. Вы знаете, что вы не должны , чтобы изменить его. Что, если вы случайно сделаете это?

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

Существует хорошая статья здесь о Const в C ++. Это довольно прямое мнение, но надеюсь, что оно кому-то поможет.

Когда вы используете ключевое слово «const», вы определяете другой интерфейс для своих классов. Есть интерфейс, который включает все методы, и интерфейс, который включает только константные методы. Очевидно, это позволяет вам ограничить доступ к некоторым вещам, которые вы не хотите изменять.

Да, со временем становится легче.

Мне нравится константная корректность ... теоретически. Каждый раз, когда я пытался применить его строго на практике, он в конце концов ломался, и const_cast начинает постепенно превращаться в уродливый код.

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

Например, представьте себе простой механизм базы данных ... у него есть объекты схемы, таблицы, поля и т. Д. Пользователь может иметь указатель 'const Table', означающий, что им не разрешено изменять саму схему таблицы ... но как насчет манипулирования данные, связанные с таблицей? Если метод Insert () помечен как константа, то внутри он должен отбросить константу, чтобы фактически управлять базой данных. Если он не помечен как const, он не защищает от вызова метода AddField.

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

Вы также можете давать подсказки компилятору с помощью const .... в соответствии со следующим кодом

#include <string>

void f(const std::string& s)
{

}
void x( std::string& x)
{
}
void main()
{
    f("blah");
    x("blah");   // won't compile...
}