Я розумію , більшість перевантаження операторів, за винятком операторів доступу члена ->, .*, і ->*т.д.

Зокрема, що передається цим операторським функціям, а що потрібно повернути?

Як функція оператора (наприклад operator->(...)) знає, до якого члена відноситься? Чи може це знати? Це навіть потрібно знати?

Нарешті, чи є якісь міркування щодо суперечності, які потрібно враховувати? Наприклад, при перевантаженні чогось подібного operator[], як правило, вам знадобиться як версія const, так і non-const. Чи вимагають оператори доступу членів const та non-const версії?

->

Це єдиний справді хитрий. Це повинна бути нестатична функція члена, і вона не бере аргументів. Повернене значення використовується для здійснення пошуку члена.

Якщо значення повернення - це інший об'єкт типу класу, а не покажчик, то наступний пошук членів також обробляється operator->функцією. Це називається "поведінкою збивання". Мова зв'язує operator->дзвінки, поки останній не поверне вказівник.

struct client
    { int a; };

struct proxy {
    client *target;
    client *operator->() const
        { return target; }
};

struct proxy2 {
    proxy *target;
    proxy &operator->() const
        { return * target; }
};

void f() {
    client x = { 3 };
    proxy y = { & x };
    proxy2 z = { & y };

    std::cout << x.a << y->a << z->a; // print "333"
}

->*

Цей лише хитрий у тому, що в цьому немає нічого особливого. Чи не перевантажений версія вимагає об'єкт покажчика на тип класу на лівому боці і об'єкт покажчика типу елемента праворуч. Але коли ви перевантажуєте це, ви можете приймати будь-які вподобані вам аргументи і повертати все, що завгодно. Це навіть не повинно бути нестатичним членом.

Іншими словами, це один просто нормальний бінарний оператор , як +, -, і /. Дивіться також: Чи вільний оператор -> * перевантажує зло?

.* і .

Вони не можуть бути перевантажені. Вже є вбудоване значення, коли ліва частина класу типу. Можливо, було б мало сенсу мати можливість визначити їх за вказівником з лівого боку, але комітет з мовної розробки вирішив, що це буде більше заплутаним, ніж корисним.

Перевантаження ->, ->*, .і .*може заповнити тільки в тих випадках , коли вираз буде визначено, воно ніколи не може змінити значення виразу , яке буде дійсним, без перевантаження.

Оператор -> особливий.

"Він має додаткові, нетипові обмеження: він повинен повернути об'єкт (або посилання на об'єкт), який також має оператор перенаправлення вказівника, або він повинен повернути вказівник, який може бути використаний для вибору, на що вказує стрілка оператора перенаправлення. " Брюс Еккель: Мислення CPP Vol-one: оператор->

Додатковий функціонал передбачений для зручності, тому вам не доведеться телефонувати

a->->func();

Ви можете просто зробити:

a->func();

Це робить оператора -> відмінним від інших перевантажень оператора.

Ви не можете перевантажувати доступ учасників .(тобто друга частина того, що ->робить). Однак ви можете перевантажити унарні разименованія оператора *(тобто перша частина того, що ->робить).

Оператор C ++ ->- це об'єднання двох кроків, і це зрозуміло, якщо ви вважаєте, що x->yце рівносильно (*x).y. C ++ дозволяє налаштувати, що робити з (*x)частиною, коли xце екземпляр вашого класу.

Смисловість для ->перевантаження дещо дивна, оскільки C ++ дозволяє або повернути звичайний покажчик (що він буде використовуватися для пошуку загостреного об'єкта), або повернути екземпляр іншого класу, якщо цей клас також надає ->оператора. У другому випадку пошук оберегованого об'єкта продовжується з цього нового примірника.

->Оператор не знає , що елемент на який вказує на, він просто надає об'єкт для виконання фактичного доступу учасника на.

Крім того, я не бачу причин, чому ви не можете надати версії const та non-const.

Коли ви перевантажуєте оператор -> () (тут ніяких аргументів не передано), те, що компілятор насправді робить, викликає -> рекурсивно, поки він не поверне фактичний покажчик на тип. Потім використовується правильний член / метод.

Це корисно, наприклад, для створення класу розумних покажчиків, який інкапсулює фактичний покажчик. Перезавантажений оператор-> викликається, робить все, що він робить (наприклад, блокування для безпеки потоку), повертає внутрішній покажчик, а потім компілятор викликає -> для цього внутрішнього вказівника.

Що стосується constness - на нього відповідають у коментарях та інші відповіді (ви можете, і повинні, надати і те, і інше).