Подрывает ли этот код систему типов C ++?

Метод oops () не может изменять постоянство объекта. Более того, он этого не делает. Это ваша анонимная функция. Эта анонимная функция находится не в контексте объекта, а в контексте метода main (), которому разрешено изменять объект.

Ваша анонимная функция не изменяет указатель this на oops () (который определен как const и, следовательно, не может быть изменен), а также никоим образом не наследует некоторую неконстантную переменную из этого указателя this. Сам по себе не имеет этого указателя. Он просто игнорирует указатель this и изменяет переменную bc основного контекста (которая как бы передается как параметр в ваше закрытие). Эта переменная не является константой, поэтому ее можно изменить. Вы также можете передать любую анонимную функцию, изменяющую совершенно несвязанный объект. Эта функция не знает, что она меняет объект, который ее хранит.

Если бы вы объявили это как

const BreakConst bc = ...

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

Изменить: Другими словами: атрибут const привязан к конкретному l-значению (ссылке), обращающемуся к объекту. Он не привязан к самому объекту.

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

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

Из [7.1.6.1] CV-квалификаторы:

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

За исключением того, что любой член класса, объявленный изменяемым (7.1.1), может быть изменен, любая попытка изменить константный объект во время его жизни (3.8) приводит к неопределенному поведению.

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

Учтите также это:

#include <iostream>
using namespace std;

class B;

class A
{
    friend class B;
    B* pb;
    int val;
public:
    A(B& b); 
    void callinc() const;
    friend ostream& operator<<(ostream& s, const A& a)
    { return s << "A value is " << a.val; }
};

class B
{
    friend class A;
    A* pa;
public:
    void incval() const { ++pa->val; }
};

inline A::A(B& b) :pb(&b), val() { pb->pa = this; }
inline void A::callinc() const { pb->incval(); }


int main()
{
    B b;
    const A a(b);  // EDIT: WAS `A a(b)`
    cout << a << endl;
    a.callinc();
    cout << a << endl;
}

Это не C ++ 11, но делает то же самое: дело в том, что const не является транзитивным.

callinc() не меняет себя a и incval не меняет b. Обратите внимание, что в main вы даже можете объявить const A a(b); вместо A a(b);, и все будет компилироваться одинаково.

Это работает десятилетиями, и в вашем примере вы просто делаете то же самое: просто вы заменили класс B на лямбда.

ИЗМЕНИТЬ

Изменен main (), чтобы отразить комментарий.

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

Функция const просто помогает от случайного неправильного использования. Он не предназначен для предотвращения взлома специального программного обеспечения. Это то же самое, что и частное и защищенное членство, кто-то всегда может взять адрес объекта и увеличить память для доступа к внутренним компонентам класса, нет способа остановить это.

Итак, да, вы можете обойти const. По крайней мере, вы можете просто изменить объект на уровне памяти, но это не означает, что const не работает.