Почему правило правильности const не работает для встроенных библиотек?

Здесь есть недоразумение об ограничении const функций-членов.

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

Важное примечание: public B,C может быть не тем, о чем вы думаете: это означает, что D наследует публично от B и конфиденциально от C. Если вы хотите, чтобы он наследовал публично из C вы должны заявить public B, public C.

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

class D {
public:
    int fun2();
    int fun3() const;
};

Что это заявляет? Существует класс под названием D. Есть две функции-члена fun2 и fun3, каждая из которых принимает скрытый параметр this и никаких других параметров.

Держись! Скрытый параметр? Ну да. Вы можете использовать this внутри функции; его ценность должна исходить откуда-то. Все нестатические функции-члены имеют этот скрытый параметр. Однако не все нестатические функции-члены имеют одинаковый тип скрытого параметра. Если бы я показывал скрытый параметр, объявления выглядели бы следующим образом:

int D::fun2(D * this);
int D::fun3(const D * this);

Обратите внимание, как const существует внутри этого псевдо-объявления? Это эффект объявления функции-члена const: this указывает на объект const, а не на объект const.

1127 Теперь вернемся к вопросу. Может ли fun3 позвонить fun2? Ну, fun3 передаст свой указатель this (указатель на const-объект) в fun2, который ожидает указатель на объект. Это означало бы потерю константности, поэтому это не разрешается.

Может ли fun3 позвонить abs? Ну, fun3 передаст целое число в abs. Здесь нет проблем. Проблема заключается в потере постоянства this. Пока вы этого избегаете, у вас все хорошо.

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

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

Учитывайте это

#include <iostream>

int f(int num) { return num+1; }
int fr(int& num) { return num+1; }
int fcr(const int& num) { return num+1; }

class D
{
public:
    int value= 0;

public:
    void f1() { value++; }
    int f2() const { return value; }
    int f3() { return value; }
    static void f4() { std::cout << "Hello" << std::endl; }
    void f5() const;
};

void D::f5() const
{
    // Prohibited:
    // f1(); // modifies this
    // f3(); // might modify this
    // value++; // modifies this->value, thus modifies this
    // value= 2; // modifies this->value, thus modifies this
    // value= abs(value); // modifies this->value, thus modifies this
    // fr(value); // takes value by reference and might modify it
    // 
    // Permitted:
    f2(); // const function, does not modify this
    std::cout << value << std::endl; // independent function, does not modify this; read access to this->value is const
    std::cout << abs(value) << std::endl; // independent function, does not modify this; read access to this->value is const
    f4(); // static function, does not modify this
    f(value); // function, does not modify this; takes value as read only (makes copy)
    fcr(value); // function, does not modify this; takes value as read only by reference

    D otherObject;
    otherObject.f1(); // modifies otherObject (non const), does not modify this
}

int main()
{
    const D d;
    d.f5();
}

Всякий раз, когда вы вызываете функцию-член, например, f4() внутри f5(), вы передаете неявный указатель this, эквивалентный this->f4(). Внутри f5(), как и в const, это не тип D*, а const D*. Таким образом, вы не можете сделать value++ (эквивалентно this->value++ для const D*. Но вы можете вызвать abs, printf или что-то еще, что не берет this и пытается изменить его). [1122 ]

Когда вы берете this->value, если тип this равен D*, это тип int, и вы можете изменить его. Если вы сделаете то же самое с const D*, его тип станет const int, вы не сможете изменить его, но сможете скопировать и получить доступ к нему как к константной ссылке для чтения.