Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?

Здравствуйте, Alexander G, Вы писали:

AG>Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?

Видимо, из-за наличия встроенного operator +

Здравствуйте, Bell, Вы писали:

B>Видимо, из-за наличия встроенного operator +

Но ведь его нет у пользовательских классов.

Здравствуйте, Alexander G, Вы писали:

AG>Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?

Перегрузка — это когда имя одно, а аргументы бывают разных типов.
В этом смысле уже "объявлены" перегрузки оператора плюс с типами

int operator+(int,int);
double operator+(double,double);
...

и ты своим объявлением просто добавляешь еще одну перегрузку этого оператора для твоего типа:

T operator+(T,T);

Так что термин "перегрузка" тут наиболее логичен.

You will always get what you always got
  If you always do  what you always did

Здравствуйте, Bell, Вы писали:

B>Видимо, из-за наличия встроенного operator +

Перегружена ли функция f в следующем примере?:

struct X {
    void f();
};

struct Y {
    void f();
};

Вопрос риторический и ответ разумеется ясен, но нет никакого глубокого смысла в том, что определение operator+ называется перегрузкой, а вышеприведенная ситуация нет.

AG>Но ведь его нет у пользовательских классов.

а зачем ему быть у них? он есть встроенный, ты добавил свой — перегрузка.

I>

I>struct X {
I>    void f();
I>};

I>struct Y {
I>    void f();
I>};
I>

I>Вопрос риторический и ответ разумеется ясен, но нет никакого глубокого смысла в том, что определение operator+ называется перегрузкой, а вышеприведенная ситуация нет.

интересно, мне одному непонятно, при чем тут твой пример?

Здравствуйте, jazzer, Вы писали:

J>Так что термин "перегрузка" тут наиболее логичен.

Вот "логичная" перегрузка:

struct X {
    X& operator=(X const&);
};

А вот еще одна "логичная" перегрузка:

struct Y {
    Y& operator=(Y const&);
};

Причем по той же логике перегружают они не только встроенный operator=, но и друг друга. Это так?

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>интересно, мне одному непонятно, при чем тут твой пример?

Непонятно? Тогда давай продолжим здесь

Автор: igna
Дата: 20.11.09

.

I>Непонятно? Тогда давай продолжим здесь

Автор: igna
Дата: 20.11.09

.
мне кажется, я понял тебя.
вообще, все это не так уж важно, имхо.
мне кажется, что твой пример с нестатической функцией членом (не оператором) — тут о перегрузке говорить и не приходится, т.к.
что ты будешь вызывать ее с ".", что в области видимости класса — там не будет функции из другого класса Y. А вот с операторами — другое дело, т.к. они есть встроенные.

Здравствуйте, igna, Вы писали:

I>Здравствуйте, Bell, Вы писали:

B>>Видимо, из-за наличия встроенного operator +

I>Перегружена ли функция f в следующем примере?:

I>

I>struct X {
I>    void f();
I>};

I>struct Y {
I>    void f();
I>};
I>

I>Вопрос риторический и ответ разумеется ясен, но нет никакого глубокого смысла в том, что определение operator+ называется перегрузкой, а вышеприведенная ситуация нет.

Использование операторов, перегруженных для пользовательских типов, обычно происходит без обращения к "class member access syntax", в отличие от функций-членов. Т.е. при взгляде на код кажется, что перегруженный оператор не является членом класса, а есть перегрузка внешней по отношению к классу функции...
Может быть из-за этого ИМХО, конечно.

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>А вот с операторами — другое дело, т.к. они есть встроенные.

А все-таки, перегружают ли друг друга операторы определенные в разных классах?

I>А все-таки, перегружают ли друг друга операторы определенные в разных классах?
ну так ты можешь посмотреть, как в стандарте это описано — есть у тебя выражение и какие функции составят множество кандидатов?

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>что ты будешь вызывать ее с ".", что в области видимости класса — там не будет функции из другого класса Y.

Ну по той же логике можно было назвать эти две функции перегруженными по this. В конце концов, если функция не виртуальная, различие с функцией не являющейся членом чисто синтаксическое. Сравни:

struct X {};

void f(X);

struct Y {};

void f(Y);

struct X {
    void f();
};

struct Y {
    void f();
};

Почему-то в первом случае имеем перегрузку, во втором — нет.

покажи мне, как ты во втором случае можешь вызвать в С++ эту функцию, чтобы был вообще смысл говорить о перегрузке.

Заменить

struct X {};

void f(X);

struct Y {};

void f(Y);

на

struct X {};

void f(X&);

struct Y {};

void f(Y&);

Здравствуйте, igna, Вы писали:

I>Ну по той же логике можно было назвать эти две функции перегруженными по this. В конце концов, если функция не виртуальная, различие с функцией не являющейся членом чисто синтаксическое.

Там слишком глубокое синтаксическое различие: x.f ищется исключительно в области видимости класса, тогда как f(x) — во всех подходящих пространствах имён, вплоть до ::
Тогда как оператор сразу ищется во всех подходящих областях, вплоть до ::, где его поджидает встроенный оператор (который, кстати, может и подойти — если у класса есть оператор приведения к примитивному типу).

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>покажи мне, как ты во втором случае можешь вызвать в С++ эту функцию, чтобы был вообще смысл говорить о перегрузке.

    x_or_y.f();

Здравствуйте, Кодт, Вы писали:

К>Тогда как оператор сразу ищется во всех подходящих областях, вплоть до ::, где его поджидает встроенный оператор

А если оператор используется в форме вызова функции a.operator=(b), поджидает ли его также встроенный оператор?

Здравствуйте, igna, Вы писали:

I>А если оператор используется в форме вызова функции a.operator=(b), поджидает ли его также встроенный оператор?
Нет, не поджидает. Но в стандарт за пунктами лезть, если честно, влом.