Const метод, который изменяет * это без const_cast

Рассмотрим следующее:

int i = 3;

i - это объект, имеющий тип int . Это не cv-квалифицированный (не const или volatile , или оба).

Теперь мы добавляем:

const int& j = i;
const int* k = &i;

j - это ссылка, которая относится к i , а k - указатель, который указывает на i . (С этого момента мы просто объединяем «ссылаться на» и «указывает на», чтобы просто «указать на».)

На данный момент у нас есть две переменные с квалификацией cv, j и ] k , которые указывают на объект, не квалифицированный cv. Это упоминается в § 7.1 / 3:

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

Это означает, что компилятор должен учитывать, что j и k квалифицированы cv, даже если они указывают на объект, не квалифицированный cv. (Итак, j = 5 и * k = 5 недопустимы, хотя i = 5 допустимо.)

Теперь мы рассмотрим удаление ] const из тех:

const_cast<int&>(j) = 5;
*const_cast<int*>(k) = 5;

Это допустимо (§см. 5.2.11), но является ли это неопределенным поведением? Нет. См. §7.1 5.1 / 4:

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

Помните, что i равно не const , и что j и k оба указывают на i . Все, что мы сделали, это сказали системе типов удалить квалификатор const из типа, чтобы мы могли изменить объект, на который указывает объект, а затем изменили i с помощью этих переменных.

Это в точности то же самое, что и действие:

int& j = i; // removed const with const_cast...
int* k = &i; // ..trivially legal code

j = 5;
*k = 5;

И это тривиально законно. Теперь мы считаем, что i было вместо этого:

const int i = 3;

Что теперь с нашим кодом?

const_cast<int&>(j) = 5;
*const_cast<int*>(k) = 5;

Теперь он приводит к неопределенному поведению , потому что i является Константный объект. Мы сказали системе типов удалить const , чтобы мы могли изменить объект, на который указывает объект, , а затем изменили объект с квалификацией const . Это не определено, как указано выше.

Опять же, более очевидно, как:

int& j = i; // removed const with const_cast...
int* k = &i; // ...but this is not legal!

j = 5;
*k = 5;

Обратите внимание, что простое выполнение этого:

const_cast<int&>(j);
*const_cast<int*>(k);

Совершенно законно и определено, поскольку никакие объекты с квалификацией const не изменяются; мы просто возимся с системой типов.

Теперь подумайте:

struct foo
{
    foo() :
    me(this), self(*this), i(3)
    {}

    void bar() const
    {
        me->i = 5;
        self.i = 5;
    }

    foo* me;
    foo& self;
    int i;
};

Что const на баре делает с членами? Это делает доступ к ним через так называемый cv-квалифицированный путь доступа . (Это достигается путем изменения типа this с T * const на cv T const * , где cv - это cv- квалификаторы функции.)

Итак, каковы типы элементов во время выполнения bar ? Это:

// const-pointer-to-non-const, where the pointer points cannot be changed
foo* const me;

// foo& const is ill-formed, cv-qualifiers do nothing to reference types
foo& self; 

// same as const int
int const i; 

Конечно, типы не имеют значения, поскольку важна константная квалификация , указывающая на объекты, а не указатели. (Если бы k выше было const int * const , последнее const не имеет значения.) Теперь рассмотрим:

int main()
{
    foo f;
    f.bar(); // UB?
}

В пределах бара , оба me и self указывают на неконстантный foo , поэтому, как и в случае с int i выше, мы имеем четко определенное поведение . Если бы у нас было:

const foo f;
f.bar(); // UB!

У нас был бы UB, как и в случае с const int , потому что мы бы изменяли объект с квалификацией const.

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

И просто чтобы добавить апелляцию к авторитету, рассмотрим уловку const_cast Скотта Мейерса, использованную для преобразования константной функции в неконстантную функцию:

struct foo
{
    const int& bar() const
    {
        int* result = /* complicated process to get the resulting int */
        return *result; 
    }

    int& bar()
    {
        // we wouldn't like to copy-paste a complicated process, what can we do?
    }

};

Он предлагает:

int& bar(void)
{
    const foo& self = *this; // add const
    const int& result = self.bar(); // call const version
    return const_cast<int&>(result); // take off const
}

Или как это обычно пишут:

int& bar(void)
{
    return const_cast<int&>( // (3) remove const from result
            static_cast<const foo&>(*this) // (1) add const to this
            .bar() // (2) call const version
            ); 
}

Обратите внимание, что это опять же совершенно законно и четко определено. В частности, поскольку эта функция должна вызываться для неконстантного foo , мы совершенно безопасно убираем константную квалификацию из типа возвращаемого значения int & boo () const .

(Если только кто-то не выстрелит в себя вызовом const_cast + в первую очередь.)

Подведем итог:

struct foo
{
    foo(void) :
    i(),
    self(*this), me(this),
    self_2(*this), me_2(this)
    {}

    const int& bar() const
    {
        return i; // always well-formed, always defined
    }

    int& bar() const
    {
        // always well-formed, always well-defined
        return const_cast<int&>(
                static_cast<const foo&>(*this).
                bar()
                );
    }

    void baz() const
    {
        // always ill-formed, i is a const int in baz
        i = 5; 

        // always ill-formed, me is a foo* const in baz
        me = 0;

        // always ill-formed, me_2 is a const foo* const in baz
        me_2 = 0; 

        // always well-formed, defined if the foo pointed to is non-const
        self.i = 5;
        me->i = 5; 

        // always ill-formed, type points to a const (though the object it 
        // points to may or may not necessarily be const-qualified)
        self_2.i = 5; 
        me_2->i = 5; 

        // always well-formed, always defined, nothing being modified
        // (note: if the result/member was not an int and was a user-defined 
        // type, if it had its copy-constructor and/or operator= parameter 
        // as T& instead of const T&, like auto_ptr for example, this would 
        // be defined if the foo self_2/me_2 points to was non-const
        int r = const_cast<foo&>(self_2).i;
        r = const_cast<foo* const>(me_2)->i;

        // always well-formed, always defined, nothing being modified.
        // (same idea behind the non-const bar, only const qualifications
        // are being changed, not any objects.)
        const_cast<foo&>(self_2);
        const_cast<foo* const>(me_2);

        // always well-formed, defined if the foo pointed to is non-const
        // (note, equivalent to using self and me)
        const_cast<foo&>(self_2).i = 5;
        const_cast<foo* const>(me_2)->i = 5;

        // always well-formed, defined if the foo pointed to is non-const
        const_cast<foo&>(*this).i = 5;
        const_cast<foo* const>(this)->i = 5;
    }

    int i;

    foo& self;
    foo* me;
    const foo& self_2;
    const foo* me_2;
};

int main()
{
    int i = 0;
    {
        // always well-formed, always defined
        int& x = i;
        int* y = &i;
        const int& z = i;
        const int* w = &i;

        // always well-formed, always defined
        // (note, same as using x and y)
        const_cast<int&>(z) = 5;
        const_cast<int*>(w) = 5;
    }

    const int j = 0;
    {
        // never well-formed, strips cv-qualifications without a cast
        int& x = j;
        int* y = &j;

        // always well-formed, always defined
        const int& z = i;
        const int* w = &i;

        // always well-formed, never defined
        // (note, same as using x and y, but those were ill-formed)
        const_cast<int&>(z) = 5;
        const_cast<int*>(w) = 5;
    }

    foo x;
    x.bar(); // calls non-const, well-formed, always defined
    x.bar() = 5; // calls non-const, which calls const, removes const from
                 // result, and modifies which is defined because the object
                 // pointed to by the returned reference is non-const,
                 // because x is non-const.

    x.baz(); // well-formed, always defined

    const foo y;
    y.bar(); // calls const, well-formed, always defined
    const_cast<foo&>(y).bar(); // calls non-const, well-formed, 
                               // always defined (nothing being modified)
    const_cast<foo&>(y).bar() = 5; // calls non-const, which calls const,
                                   // removes const from result, and
                                   // modifies which is undefined because 
                                   // the object pointed to by the returned
                                   // reference is const, because y is const.

    y.baz(); // well-formed, always undefined
}

_{Я имею в виду стандарт ISO C ++ 03.}