разлика между 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
}

получава грешка, защото []operator of 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 - правите имплицитно прехвърляне на non-const към const обект, като по този начин можете да замените:

const A temp = *this;                                // implicit cast

с

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

това също работи:

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

и тъй като можете да направите изрично предаване - вече не се нуждаете от temp, така че:

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

това ще върне non-const ref към char от този const-cast обект, който извиква претоварен operator[] :) Точно поради тази причина не можете да използвате

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

защото това е неконстантен обект; следователно ще го накара да извика функция без разходи (да претовари operator[]), което ще причини безкрайна рекурсия.

Дано има смисъл.

Извикахме различна функция 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] ще извика функцията non-const:

char &operator[](int);

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

Какво се прави в non-const функция?

Така че нека видим връзката между не-константна функция и константна функция. Във вашата програма неконстантната функция се реализира чрез извикване на константна функция.

Обикновено неконстантен обект не може да извика функцията const директно. Но можем да променим атрибута с 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 в non-const функция може да бъде заменен по следния начин:

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)[позиция] вътре в неконстантната версия на оператора, тя извиква неконстантната версия, която отново извиква неконстантната версия на оператора и се превръща в безкраен цикъл. Правейки това кастинг, вие по същество извиквате const версията на същия оператор.

РЕДАКТИРАНЕ: Хм... изглежда, че проблемът не е такъв, какъвто изглежда. Имате ли копиращ конструктор за този клас? Предполагам, че това е причината за този проблем.

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

За да стане по-ясно ... static_cast<const TextBlock>(*this)[position]; Разбивката на горното твърдение би била:

• Преобразувайте *this в const TextBlock
• Създайте временна променлива за задържане на const TextBlock (конструктор за копиране, наречен предаване на const TextBlock)
• Извикайте operator[] на временната променлива, която НЕ е const, защото е била временна.
• Временната променлива преминава през горния процес.

Вашите оператори имат различни типове вътрешни параметри

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]);
}