Здравствуйте, Red Line, Вы писали:
RL>// Операции с указателем
RL>>>T& operator*() { assert(m_pI != NULL); return *m_pI; }
RL>Я ни как не вразумею, — как нужно читать синтаксис этого оператора.
Проще некуда:
struct Data
{
int x;
void foo();
};
// некоторые функции...
void accept_data(Data d); // входной параметр
void fill_data(Data& d); // выходной параметр
struct SmartPtr
{
Data* p;
Data& operator* () { return *p; }
};
main()
{
Data* p1;
SmartPtr p2;
. . . . .
// обычный указатель // явный доступ к члену умного // то же самое,
// -- обычному указателю // но завёрнутое в оператор разыменования
fill_data(*p1); fill_data(*(p2.p)); fill_data(*p2);
accept_data(*p1); accept_data(*(p2.p)); accept_data(*p2);
}
Видишь, что внешне работа с обычным указателем (левый столбец) выглядит так же, как с умным (правый).
Перекрытый оператор служит именно этой цели: одинаковости внешнего вида.
RL>Мне понятна запись:
RL>RL>С operator + (const C lPar, const C rPar);
RL>
RL>Читаю (в соответствии с тем как Вы меня учили)
RL>Внешний оператор;
RL>двухместный инфиксный оператор (операнд слева — lPar, операнд справа — rPar);
RL>Возможны две формы вызова
RL>явная:
RL>C x,y,z;
RL>z = +(x,y);
RL>и операторная:
RL>С x,y,z;
RL>z = x+y;
RL>Верно?
Неверно!!!
Операторная запись:
z = x+y;
Функциональная запись (если оператор внешний):
z = operator+ (x,y);
Функциональная запись (если оператор — функция-член):
z = x.operator+ (y);
RL>Теперь оператор-член класса:
RL>RL> class С
RL>{
RL> C add(val1, val2);
RL> C operator + (C rPar) const {return add(*this, rPar);}
RL>};
RL>
RL>Оператор-член класса; (подразумевается, что если левый аргумент не указан то это всегда *this)
Он не "если не указан", а всегда не указан. У любого метода объекта есть неявный параметр — указатель на сам объект.
RL>двухместный (бинарный) и вроде бы инфиксный;
RL>Явная форма вызова:
RL>С obj;
RL>C anyPar;
RL>C res;
RL>res = obj.operator + (anyPar);
//равносильно obj+anyPar? Т.е текущий объект складывается с параметром, и что будет
блин не догоняю
((
RL>Операторная форма:
RL>С obj;
RL>C anyPar;
RL>C res;
RL>res = +anyPar;
// правый операднд (параметр) указан явно, а левый есть объект. Какой??? anyPar-объект, а тот что в операторе где????
Ещё раз. Операторная форма записи НИЧЕМ не отличается от операций над арифметическими типами.
Ключевое слово "operator" — это НЕ ОПЕРАТОРНАЯ ФОРМА ЗАПИСИ. А функциональная.
RL>Мне бы хотелось в такой же форме разобрать и эти операторы:
RL>RL> class cPtr
RL>{
RL> private:
RL> T* p;//указатель на искомый интерфейс
RL> public:
RL> operator T*() { return m_pI; }
RL> T& operator*() { return *m_pI; }
RL> T** operator&() { return &m_pI; }
RL> T* operator->() { return m_pI; }
RL>};
RL>
RL>Прошу извинить если надоедаю
Ну и что здесь непонятного? Попробуй поработать за компилятора.
void foo(T* pointer);
void bar(T value);
void xyz(T& reference);
void get(T** address_of_pointer);
main()
{
cPtr ptr;
get(&ptr); get(&(ptr.m_pI));
foo(ptr); foo(ptr.m_pI);
bar(*ptr); bar(*(ptr.m_pI));
xyz(*ptr); xyz(*(ptr.m_pI));
ptr->call(); ptr.m_pI->call();
}
Перекуём баги на фичи!
