разница между static_cast‹const A›(*this) и static_cast‹const A&›(*this)

Причина в том, что

const A a();

а также

A b();

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

cout << a[0] << endl;

является законным, но

cout << b[0] << endl;

не является. По этой причине вы должны перегрузить оператор [] для неконстантного объекта. Чтобы избежать копирования кода, автор предлагает использовать функцию для константного объекта, отбрасывая его константность. По этой причине вы получаете:

char& operator[](std::size_t position)
{
     return const_cast <char &>( static_cast <const A &>(*this) [position] );
}

другими словами, вы просто конвертируете свой объект в const

char& operator[](std::size_t position)
{
     const A temp = *this;      //create a const object 
                                    //and assign current object to it
     ....
}

попробуйте использовать []оператор const obj

char& operator[](std::size_t position)
{
     const A temp = *this;      //create a const object 
                                    //and assign current object to it
     return temp[position];     // call an overloaded operator [] 
                                // of the const function
}

получить ошибку, потому что []оператор функции const возвращает const char&, а эта функция возвращает char&. Таким образом, отбросьте постоянство

char& operator[](std::size_t position)
{
     const A temp = *this;      //create a const object 
                                //and assign current object to it
     return const_cast <char &>( temp[position] );
 }

Теперь все готово. Вопрос: «Как

const A temp = *this;
return const_cast <char &> (temp[position]);

стало так:

return const_cast <char &> ( static_cast <const A &> (*this)[position]);

? Причина этого в том, что когда вы используете temp - вы делаете неявное приведение неконстантного к константному объекту, поэтому вы можете заменить:

const A temp = *this;                                // implicit cast

с

const A temp = static_cast <const A &> (*this)        //explicit  

это также работает:

const A temp = const_cast <const A &> (*this) 

и поскольку вы можете сделать явное приведение - вам больше не нужен временный, таким образом:

return const_cast <char &> (static_cast <const A &>(*this)[position]);

это вернет неконстантную ссылку на char из этого константного объекта, который вызывает перегруженный оператор [] :) Именно по этой причине вы не можете использовать

return const_cast <char &> ((*this)[position]);

потому что это неконстантный объект; следовательно, это заставит его вызвать нестоимостную функцию (перегрузить оператор []), что вызовет бесконечную рекурсию.

Надеюсь, это имеет смысл.

Другая функция operator[], которую мы вызывали

Когда вы определяете два объекта, один из них является константным, а другой неконстантным, например: const TextBlock a("Hello"); TextBlock b("World");

Когда вы используете a[0] и b[0], будут вызываться разные типы operator[]. Первый из них -- a[0] будет вызывать функцию const:

const char &operator[](int) const;

Поскольку a является константным объектом, каждая операция над ним не может изменить его значение. Поэтому, когда он использует оператор [], будет вызвана версия const и вернет тип const char&, что также означает, что мы не можем изменить значения ее членов.

С другой стороны, второй -- b[0] вызовет неконстантную функцию:

char &operator[](int);

Объект можно изменить, также как и его член. Итак, эта функция возвращает тип char &, который можно изменить.

Что делается в неконстантной функции?

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

Обычно неконстантный объект не может напрямую вызывать константную функцию. Но мы можем изменить атрибут на static_cast<>. Таким образом, мы можем преобразовать объект b в const TextBlock, чтобы он мог вызывать функцию const.

Мы делаем это в char &operator[](int index), что может уменьшить повторное использование кода.

char & operator[](int position) { // const TextBlock tmp = *this; // return const_cast<char &>(tmp[position]); return const_cast<char &>( (static_cast<const TextBlock &>(*this))[position] ); }

При использовании static_cast<const TextBlock &>(*this) он неявно определяет временный объект, который является преобразованием TextBlock & в const TextBlock ＆ в *this.

После преобразования у нас есть временный объект, и мы назвали его tmp. Таким образом, мы можем использовать tmp[0] для вызова функции const, что мы и делаем.

После возврата из функции const мы получаем значение типа const char &. Но на самом деле мы хотим, чтобы это было char &. Поэтому мы используем const_cast<char &> для удаления атрибута const из возвращаемого значения. После этого мы получаем неконстантную ссылку в char, значения которой мы можем модифицировать.

Собственно, оператор return в неконстантной функции можно заменить так:

const TextBlcok &tmp = *this; return const_cast<char &>tmp[position];

tmp — это временная ссылка на *this (не временный объект). У нас есть неявное преобразование из TextBlock & в const TextBlock & здесь, тогда как в исходном операторе возврата есть явное преобразование.

Не забудьте добавить & в первое выражение, которое означает, что мы используем ссылку на объект вместо реального объекта. Или он вызовет конструктор присваивания для создания нового объекта. Если это произойдет, tmp не будет иметь ничего общего с *this. Это разные объекты, даже если они имеют одинаковое значение. Что бы мы ни изменили в tmp, фактический объект, которым мы хотим управлять, не изменится!

Приведенный ниже код работает — с возвращаемыми значениями, измененными на char, чтобы избежать проблемы, обнаруженной reko_t при возврате ссылки на уже исчезнувшее временное — на g++ 3.4.6.

Чтобы объяснить проблему...

static_cast<const TextBlock>(*this)

... фактически то же самое, что и...

const TextBlock temporary = *this;

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

Ваш компилятор работает с приведенным ниже кодом? (тип позиции стандартизирован на int во избежание двусмысленности).

#include <iostream>

struct A  
{ 

  char operator[](int position)         // now just calls const op[] 
  { 
    return 
        static_cast<const A>(*this)     // add const to *this's type; 
          [position];                   // call const version of op[] 
  } 

  const char operator[](int index) const 
  { 
    return x_[index];
  } 

  char x_[10];
};

int main()
{
  A a;
  strcpy(a.x_, "hello!");
  const A& ca = a;
  std::cout << a[0] << ca[1] << a[2] << ca[3] << a[4] << ca[5] << '\n';
}

char& operator[](std::size_t position) и char& operator[](std::size_t position) const разные. Обратите внимание на «const» после объявления функции. Первая — это «неконстантная» версия оператора, а вторая — это константная версия оператора. Неконстантная операторная функция вызывается, когда экземпляр этого класса не является константным, а константная версия вызывается, когда объект является константным.

const A a;
char c = a[i]; // Calls the const version
A b;
char d = b[i]; // Calls the non-const version

Когда вы говорите (*this)[position] внутри неконстантной версии оператора, она вызывает неконстантную версию, которая снова вызывает неконстантную версию оператора, и получается бесконечный цикл. Выполняя это приведение, вы, по сути, вызываете константную версию того же оператора.

РЕДАКТИРОВАТЬ: Хм... похоже, проблема не в том, чем кажется. У вас есть копирующий конструктор для этого класса? Я предполагаю, что это то, что вызывает эту проблему.

EDIT2: я думаю, что понял. a[i] -> создает временную переменную при приведении const без ссылки (const A) -> temp[position] -> создает временную переменную при приведении const без ссылки -> temp2[position] -> и продолжается.....
в то время как переменная с const приведена с ссылкой (const A&), временная переменная не создается, что позволяет избежать мертвого цикла.

Чтобы было понятнее ... static_cast<const TextBlock>(*this)[position]; Разбивка приведенного выше утверждения будет следующей:

• Преобразовать *this в const TextBlock
• Создайте временную переменную для хранения const TextBlock (конструктор копирования, вызываемый передачей const TextBlock)
• Вызовите оператор [] для временной переменной, которая НЕ является константой, потому что она была временной.
• Временная переменная проходит описанный выше процесс.

У ваших операторов разные типы параметров

char& operator[](std::size_t position)
const char& operator[](int index) const ‹- Также должно быть std::size_t

Это может быть решение, которое вы ищете. Были ли в примере из книги разные типы для inparameter? Помните, что приведение типов работает с возвращаемым значением.

char& operator[](std::size_t index)
{
  std::cout<<"non-const operator"<<std::endl;
  const TextBlock &  ref = *this;
  return const_cast<char&>(ref[index]);
}