Последовательность в размещении функций оператора

Question

У меня есть класс, как это:

class A { 
    ...private functions, variables, etc... 
public: 
    ...some public functions and variables... 

    A operator * (double); 
    A operator/(double); 
    A operator * (A); 
    ...and lots of other operators 
} 

Однако, я хочу быть в состоянии делать такие вещи, как 2 * A вместо того, чтобы только быть позволено делать A * 2, и поэтому я должен был бы функции как эти снаружи класса:

A operator * (double, A); 
A operator/(double, A); 
...etc... 

нужно ли все эти операторы вне класса согласованности, или я должен держать половину внутри и снаружи половину?

Answer 1

Так что вы говорите, что, потому что вы должны поставить некоторые операторы (те, которые не имеет A как первые пары) вне класса, возможно, вы должны положить их туда, чтобы люди знали, где их найти? Я так не думаю. Я ожидаю найти операторов внутри класса, если это вообще возможно. Конечно, поместите «внешние» в один и тот же файл, что поможет. И если внешние пользователи нуждаются в доступе к частным переменным-членам, то добавление строк friend - это огромный намек на поиск в другом месте файла для этих операторов.

Могу ли я зайти так далеко, чтобы включить строки friend, даже если бы моя реализация операторов действительно могла быть выполнена с помощью публичных геттеров и сеттеров? Думаю, я бы это сделал. Я думаю о тех операторах, которые действительно являются частью класса. Просто синтаксис языка требует, чтобы они были свободными функциями. Поэтому обычно я использую friend, и я пишу их так, как если бы они были функциями-членами, не используя геттеры и сеттеры. Приятным побочным эффектом является то, что возникающая в результате необходимость в операторах friend заставит их всех указывать в определении класса.

Answer 2

ИМХО, беспокойство не должно быть со стилистической консистенцией, но с консистентной консистенцией; обычно, если функции не нужен доступ к закрытым членам, она не должна быть частью класса. Это не сложное быстрое правило, см. Аргументы для него here.

Так что если ваши операторы не требуют личного доступа, поместите их на улицу. В противном случае, они все должны быть внутри, как так:

class A { 
    ... 
public: 
    ... 
    A operator * (double); 
    A operator/(double); 
    friend A operator * (double, A); 
    friend A operator/(double, A); 
    ... 
}; 

Answer 3

От ваших ответов к комментариям в вопросе кажется, что у вас есть неявное преобразование от double до A в вашем классе. что-то вроде:

class A 
{ 
    // ... 
public: 
    A(double); 

    // ... 
}; 

В этом случае вы можете просто определить свободную функцию для каждого оператора вида:

A operator*(const A&, const A&); 

и он будет использоваться, если одна из сторон является A объектом, а другая сторона неявно конвертируется в A. По этой причине часто предпочтительнее делать симметричные бинарные операторы свободными функциями.

Часто может быть проще реализовать двоичный код * с точки зрения назначения версии *=. В этом случае я хотел бы сделать версию назначения функции члена и определить * как что-то вроде:

A operator*(const A& l, const A& r) 
{ 
    A result(l); 
    result += r; 
    return result; 
} 

Иначе как operator* это явно части вашего класса интерфейса я не буду никаких проблем с принятием его в friend в случае необходимости.