Операторы указателей
Оператор указателя структуры -> перегружается как нестатическая функция-член класса. Перегруженный оператор указателя структуры является унарным оператором, действующим на свой левый операнд. Аргумент должен быть либо объектом класса, либо ссылкой на этот тип. Оператор может возвращать либо указатель на объект класса, либо объект класса, для которого определен operator->, либо ссылку на класс, для которого определен operator->.
В следующем примере мы перегрузим оператор указателя структуры внутри класса t_ptr. Объекты типа t_ptr выступают в качестве указателей с управляемый доступом к объектам типа triple.
В файле triple.cpp
//Перегружаем оператор указателя структуры #include <iostream.h>
class triple {
public:
triple(int a, int b, int c) ( i = a; j = b; k = c; }
void print() { cout << "\ni = " << i << ", j = "
<<j<<”,k=”<<k;}
private:
int i,j,k;
};
triple unauthor(0, 0, 0);
class t_ptr { public:
t_ptr(bool f, triple* p) { access = f; ptr = p;}
triple* operator->();
private:
bool access;
triple* ptr;
};
triple* t_ptr::operator->()
{
if (access)
return (ptr) ;
else {
cout « "\nНесанкционированный доступ";
return &unauthor;
}
}
Перегруженный оператор -> проверяет переменную t_ptr: : access; в том случае, если результат теста — истина, доступ предоставляется. Следующий код иллюстрирует это:
int main()
{
triple а(1. 2, 3), b(4, 5, 6);
t_ptr ta(false, &a), tb(true, &b);
ta -> print (); // доступ запрещен
tb -> print (); //доступ предоставлен
}
Указатель на член класса
Указатель на член класса отличается от указателя на класс. Указатель на тип члена класса выглядит как Т::*, где Т – имя класса. В С++ есть два оператора, служащих для разыменования указателя на член класса. Вот они:
.*
->*
В конструкциях объект. *указатель_на_член и указатель->*указатель_ на_ член сначала производится доступ к объекту, а затем доступ к указанному члену и его разыменование.
В следующем фрагменте показано применение этих операторов.
В файле showhide.cpp
//Указатель на член класса #include <iostream.h>
class X { public:
int visible; //видимая
void print()
{ cout « "\nhide = " « hide
« " visible = " « visible; }
void reset() { visible = hide; }
void set(int i) { hide = i; } private:
int hide; //спрятанная
};
typedef void (X::*pfcn)();
int main()
{
X a, b, *pb = &b;
int X::*pXint = &X::visible;
pfcn pF = &X::print ;
a.set(8); a.reset();
b.set(4); b.reset ();
a.print() ;
a.*pXint += 1;
a.print() ;
cout « "\nb.visible = “ << pb ->*pXint;
(b.*pF)();
рF = &Х::reset;
(a.*pF)();
a.print();
cout « endl;
}
Вот что будет выведено:
hide = 8 visible = 8 hide = 8 visible = 9 b.visible = 4
hide = 4 visible = 4 hide = 8 visible = 8
Разбор программы showhide
• typedef void (X: : *pfcn) () ;
Здесь сказано, что pfcn является именем типа указателя на член класса X, базовый тип которого— функция без аргументов, возвращающая void. Функции-члены Х::print и Х::reset соответствуют этому базовому типу.
• int X::*pXint = &Х::visible;
pfcn pF = &X::print;
Здесь объявляется переменная pXint, которая будет указателем на член класса X, базовый тип которого — int. Она инициализуется так, чтобы указывать на член Х::visible. Указатель pF инициализуется указателем на функцию-член
Х::print.
• a.*pXint += 1;
Это то же самое, что и ++а. visible.
• cout « "\nb.visible = " « pb ->*pXint;
(b.*pF) () ;
Выражение указателя равносильно pb -> visible. Вызов функции равносилен pb.print ().
• pF = &X: :reset;
(a.*pF)() ;
Указателю pF присвоен адрес X::reset. Вызов функции равнозначен а. reset ().
Рассмотрим распределение памяти для представления некоторого объекта. Объект имеет базовый адрес и какие-то нестатические члены, которые смещены относительно этого базового адреса. То есть указатель на член класса используется как смеще-1ие, он не является истинным указателем; истинный указатель имеет в качестве значения обычный адрес памяти. Статические члены не являются смещениями, а раз так, то указатель на статический член — истинный указатель.