Почему оператор стрелки в C ++ не является псевдонимом *.?

В c ++ оператор * может быть перегружен, например, с помощью итератора, но оператор стрелки (->) (. *) Не работает с классами, которые перегружают оператор *. Я полагаю, что препроцессор может легко заменить все экземпляры -> на (* left) .right, и это сделает итераторы более привлекательными для реализации. Есть ли практическая причина отличаться -> или это просто особенность языка / дизайнеров?

Правило, foo->barравное (*foo).barтолько для встроенных операторов.

Унарный operator *не всегда имеет семантику разыменования указателя. Я мог бы создать библиотеку, в которой это означало бы перестановку матриц, совпадения парсера с нулем или более или почти все что угодно.

Это сделало бы язык более утомительным, если бы все, что перегружало унарный код operator *, внезапно получило бы operator ->то, о чем вы не просили, с семантикой, которая может не иметь смысла.

operator -> может быть перегружен отдельно, поэтому, если вы хотите его, вы можете перегрузить его с минимальными усилиями.

Также обратите внимание, что такая перегрузка будет обладать некоторыми довольно интересными свойствами, такими как автоматическая цепочка operator ->вызовов, пока один в цепочке не возвратит необработанный указатель. Это очень полезно для умных указателей и других типов прокси.

#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <string>
#include <iostream>
#include <ostream>

struct Foo
{
    boost::shared_ptr<std::string> operator -> () const
    {
        return boost::make_shared<std::string>("trololo");
    }
};

int main()
{
    Foo foo;
    std::cerr << foo->size() << std::endl;
}

«Язык программирования C ++» описывает тот факт, что эти операторы могут быть разными, но также говорит:

Если вы предоставляете более одного из этих операторов, возможно, было бы целесообразно обеспечить эквивалентность, так же, как это разумно, чтобы гарантировать ++xи x+=1иметь тот же эффект, что и x=x+1для простой переменной xнекоторого класса if ++, + =, =, и + предоставляются.

Таким образом, кажется, что разработчики языка предоставили отдельные точки перегрузки, потому что вы могли бы хотеть перегрузить их по-другому, а не предполагать, что вы всегда хотите, чтобы они были одинаковыми.

Как правило, C ++ предназначен для обеспечения гибкости, поэтому перегрузки *и ->разделены. Хотя это довольно необычно, если вы хотите достаточно сильно, вы можете написать эти перегрузки, чтобы делать совершенно разные вещи (например, может иметь смысл для предметно-ориентированного языка, реализованного внутри C ++).

Тем не менее, итераторы сделать поддержку либо использование. В древних реализациях вы можете найти библиотеку, которая требует (*iter).whateverвместо iter->whatever, но если это так, то это ошибка в реализации, а не характеристика языка. Учитывая объем работы, связанной с реализацией всех стандартных контейнеров / алгоритмов / итераторов, неудивительно, что некоторые ранние выпуски были несколько неполными, но на самом деле они никогда не предназначались для этого.