Alexander G:
AG>Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?
Перегрузка оператора и перегрузка функции — разные вещи. Объявляя операторную функцию operator+, ты вводишь новую возможную интерпретацию для выражения вида
+ cast-expression или
additive-expression + multiplicative-expression.
А перегрузка функции имеет место в том случае, если две функции с одинаковым именем объявлены в одном scope:
"When two or more different declarations are specified for a single name in the same scope, that name is said to be overloaded." (см. 13/1)
Здравствуйте, Николай Ивченков, Вы писали:
НИ>Alexander G:
AG>>Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?
НИ>Перегрузка оператора и перегрузка функции — разные вещи. Объявляя операторную функцию operator+, ты вводишь новую возможную интерпретацию для выражения вида
Так речь то вся идёт о том, что в некоторых случаях вводится первая и единственная возможная интерпретация...
Caracrist:
AG>>>Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?
НИ>>Перегрузка оператора и перегрузка функции — разные вещи. Объявляя операторную функцию operator+, ты вводишь новую возможную интерпретацию для выражения вида
C>Так речь то вся идёт о том, что в некоторых случаях вводится первая и единственная возможная интерпретация...
НИ>А перегрузка функции имеет место в том случае, если две функции с одинаковым именем объявлены в одном scope:
НИ>"When two or more different declarations are specified for a single name in the same scope, that name is said to be overloaded." (см. 13/1)
При этом понятие "имя" в самом начале главы 3 определяется так
4 A name is a use of an identifier (2.11), operator-function-id (13.5), literal-operator-id (13.5.8), conversionfunction-
id (12.3.2), or template-id (14.3) that denotes an entity or label (6.6.4, 6.1).
НИ>Перегрузка оператора и перегрузка функции — разные вещи.
Так что не надо заострять внимание на том, что разная.
Of course, the code must be complete enough to compile and link.
Здравствуйте, Lorenzo_LAMAS, Вы писали:
НИ>>А перегрузка функции имеет место в том случае, если две функции с одинаковым именем объявлены в одном scope:
НИ>>"When two or more different declarations are specified for a single name in the same scope, that name is said to be overloaded." (см. 13/1)
L_L>При этом понятие "имя" в самом начале главы 3 определяется так L_L>
L_L>4 A name is a use of an identifier (2.11), operator-function-id (13.5), literal-operator-id (13.5.8), conversionfunction-
L_L>id (12.3.2), or template-id (14.3) that denotes an entity or label (6.6.4, 6.1).
НИ>>Перегрузка оператора и перегрузка функции — разные вещи. L_L>Так что не надо заострять внимание на том, что разная.
"Надо, Федя. Надо" (c) Шурик.
Встроенным операторам не соответствуют никакие функции. Есть лишь набор псевдо-функций, описанных в 13.6, которые могут рассматриваться только в целях operator overload resolution и только при определённых условиях. В частности, для выражения 1+2 никаких кандидатов не определяется, здесь + сразу же трактуется как встроенный оператор в соответствии с 13.3.1.2/1.
Здравствуйте, Николай Ивченков, Вы писали:
НИ>Caracrist:
AG>>>>Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?
НИ>>>Перегрузка оператора и перегрузка функции — разные вещи. Объявляя операторную функцию operator+, ты вводишь новую возможную интерпретацию для выражения вида
C>>Так речь то вся идёт о том, что в некоторых случаях вводится первая и единственная возможная интерпретация...
НИ>В каких случаях?
class A
{
int i;
};
A a,b;
a = b + a;
какая тут интерпретация?
--------
class A
{
int i;
A& operator + (const A&);
};
A a,b;
a = b + a;
class A
{
int i;
A& operator + (const A&);
};
A a,b;
a = b + a;
ISO/IEC 24765:2008 (Systems and software engineering — Vocabulary):
overload. To assign an operator, identifier, or literal more than one meaning, depending upon the data types associated with it at any given time during program execution
Ты ввёл новое значение для оператора сложения — вот она и перегрузка. Конкретная интерпретация оператора сложения зависит от типов его операндов.
Здравствуйте, Николай Ивченков, Вы писали:
НИ>ISO/IEC 24765:2008 (Systems and software engineering — Vocabulary): НИ>
overload. To assign an operator, identifier, or literal more than one meaning, depending upon the data types associated with it at any given time during program execution
НИ>Ты ввёл новое значение для оператора сложения — вот она и перегрузка. Конкретная интерпретация оператора сложения зависит от типов его операндов.
А вот это уже озвучил jazzer. С этой формулировкой я согласен
Caracrist:
НИ>>Ты ввёл новое значение для оператора сложения — вот она и перегрузка. Конкретная интерпретация оператора сложения зависит от типов его операндов.
C>А вот это уже озвучил jazzer.
Насколько я понял, он решил свести перегрузку операторов к перегрузке операторных функций. Это неверный подход.
Здравствуйте, Кодт, Вы писали:
К>Там слишком глубокое синтаксическое различие: x.f ищется исключительно в области видимости класса, тогда как f(x) — во всех подходящих пространствах имён, вплоть до ::
Помещаем все в класс:
class A {
struct X {};
void f(X);
struct Y {};
void f(Y);
};
class A {
struct X {
void f();
};
struct Y {
void f();
};
};
"Глубокое синтаксическое различие" превратилось в "мелкое", тем не менее в первом случае имеем перегрузку, во втором — нет.
Здравствуйте, igna, Вы писали:
I>"Глубокое синтаксическое различие" превратилось в "мелкое", тем не менее в первом случае имеем перегрузку, во втором — нет.
Ничто никуда не превратилось, поскольку "различие" было между свободными функциями и функциями-членами.
А у тебя в обоих случаях — функции-члены.
Здравствуйте, Alexander G, Вы писали:
AG>Почему перегрузкой метода foo называется случай, когда таких методов более двух, а перегрузкой оператора + для класса называется даже единственное объявление этого оператора?
IMHO, для успешной разработки и поддержки ПО на С++ это не имеет никакого значения...
Все эмоциональные формулировки не соотвествуют действительному положению вещей и приведены мной исключительно "ради красного словца". За корректными формулировками и неискажённым изложением идей, следует обращаться к их автором или воспользоваться поиском
Здравствуйте, igna, Вы писали:
I>Вопрос риторический и ответ разумеется ясен, но нет никакого глубокого смысла в том, что определение operator+ называется перегрузкой, а вышеприведенная ситуация нет.
Наверно дело в области видимости еще, которая является частью сигнатуры ф-ии. Для глобального оператора + мы перегружаем его таким же глобальным вариантом.
Здравствуйте, vdimas, Вы писали:
V>Наверно дело в области видимости еще, которая является частью сигнатуры ф-ии. Для глобального оператора + мы перегружаем его таким же глобальным вариантом.
Здравствуйте, igna, Вы писали:
I>Пусть так. Тем не менее, по какой такой логике имеем перегрузку здесь: I>
I>class A {
I> struct X {};
I> void f(X);
I> struct Y {};
I> void f(Y);
I>};
I>
Здесь у выражения a.f(xy) область поиска f — члены класса A, что определяется из типа выражения a. И мы встречаем две одноимённые функции.
I>Но не здесь?: I>
I>class A {
I> struct X {
I> void f();
I> };
I> struct Y {
I> void f();
I> };
I>};
I>
А здесь у выражения xy.f() область поиска f — либо члены класса X, либо члены класса Y. Но не одновременно.
Логика такая, что при замыкании объект.член компилятор всегда сперва выводит тип объекта и сужает поле зрения для поиска членов.
Иначе можно было бы делать вот такие чудеса
struct X {};
struct Y { Y(X); void f(); };
void g(Y);
X x;
g(x); // законное поведение: g(Y(x)), т.к. есть неявное приведение X к Y
x.f(); // внезапно, Y(x).f(), по той же самой причине
Ничего не мешает тебе сделать язык с этой логикой, но это будет уже не тот С++, который мы знаем.
Кодт:
К>Иначе можно было бы делать вот такие чудеса К>
struct X {};
struct Y { Y(X); void f(); };
void g(Y);
X x;
g(x); // законное поведение: g(Y(x)), т.к. есть неявное приведение X к Y
x.f(); // внезапно, Y(x).f(), по той же самой причине
Такое преобразование дважды запрещено в 13.3.1/5:
During overload resolution, the implied object argument is indistinguishable from other arguments. The implicit object parameter, however, retains its identity since conversions on the corresponding argument shall obey these additional rules: — no temporary object can be introduced to hold the argument for the implicit object parameter;
— no user-defined conversions can be applied to achieve a type match with it; [...]
Здравствуйте, igna, Вы писали:
I>А терминология вообще имеет значение?
Терминология -- это вопрос соглашения. Сейчас, IMHO, проблем с терминологией в обсуждаемом месте нет. Все всех понимают...
Все эмоциональные формулировки не соотвествуют действительному положению вещей и приведены мной исключительно "ради красного словца". За корректными формулировками и неискажённым изложением идей, следует обращаться к их автором или воспользоваться поиском
Перекуём баги на фичи!
