Какие аргументы есть чтобы язык не поддерживал перегрузку операторов?

Какие есть аргументы в пользу того, чтобы в языке вообще были операторы?

Код читабельнее   

Субъективно. В противовес могу сказать, что без специальных операторов код единообразен, что субъективно также положительно сказывается на читабельности, а объективно упрощает компилятор и косвенно положительно сказывается на возможностях метапрограммирования на этом языке.

По сабжу же... Плюсы: язык становится гибче. Минус: потенциально код становится более "опасным" и "удивительным".

в чем опасность?


возможно

Да, вообще это удивительно, когда написано что-то вроде

и совершенно непонятно что делает этот оператор, гораздо логичнее и понятнее написать

по мне так

читабельнее

  

Опасность вытекает из удивительности. Видя знакомое a + b ты никак не ожидаешь, что оно начнет удалять файлы из твоего домашнего каталога. Утрирую, но, думаю, мысль должна быть ясна.

Перегрузка операторов иногда бывает довольно полезной, просто надо знать где и как ее использовать. Скажем установка обработчика события на класс оператором + это извращение. Перегруженный оператор должен делать то, чего от него ждет пользователь, т.е. + это математический плюс а не добавление чего-то к чему либо. Я бы и из string-а убрал этот оператор, но к нему уже все привыкли.

я такого не ожидаю и от метода add

Это не значит, что надо запрещать операторы, просто надо запрещать извращенцам писать код  
Индокод можно на любом языке написать и без перегрузки операторов.

Добавлено через 4 минуты и 33 секунды

Зря, эти методы очень коварны  

Это сообщение отредактировал(а) azesmcar - 6.12.2011, 10:52

502, azesmcar, вы б читали, что комментируете... Про потенциальную опасность и удивительность я писала в рамках обсуждаемой темы "давать перегружать операторы или нет". Естественно на перегруженные функции это тоже распространяется...

Добавлено через 56 секунд

Я и говорю, субъективизм. Мне обе записи понятны, вторая даже лучше благодаря четкой структурированности.

Добавлено через 2 минуты и 2 секунды
Еще! Отказываясь от операторов мы забываем о такой головной боли (особенно начинающих программистов) как порядок выполнения операторов.

Предлагаете и перегрузку функций запретить?
Удивительным и опасным код делает не какая либо возможность языка, а кривые руки программиста.

Это сообщение отредактировал(а) azesmcar - 6.12.2011, 11:01

это распространяется на любые функции  

Добавлено через 1 минуту и 31 секунду

хороший аргумент   

Я не предлагаю, а констатирую  


Удивительность перегрузки - это аргумент, я его констатировала. Мы можем или отказаться от гибкости и запретить перегрузку, или соглашаемся на дубовость, но ### надежную.

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

Отказываться от какой либо возможности языка стоит лишь тогда, когда от нее есть только вред и никакой пользы. А так код испортить можно чем угодно, функция math.abs вполне может форматировать диск, никто не мешает программисту написать такой код, но это не значит, что от функций нужно отказываться.

Добавлено @ 11:10

Мне непонятно что в перегрузке удивительного? Можно написать функцию add, которая будет выполнять деление, это тоже будет удивительно, но это НЕ аргумент в пользу отказа от функций, это аргумент в пользу увольнения программиста.

Это сообщение отредактировал(а) azesmcar - 6.12.2011, 11:10

Нет. Если в мануале по языку сказано, что встроенная функция add обладает всеми свойствами математического плюса и предназначена для сложения двух чисел, в случае с отсутствием возможности перегрузки (или перегрузки встроенных функций, не знаю, бывает ли такое в жизни), я могу со всей уверенностью писать add(a,b), не опасаясь угробить свой порно-архив.

Это сообщение отредактировал(а) newbee - 6.12.2011, 11:56

Стандартный оператор +. Я его перегружаю и переназначаю на деление. Потом вижу в коде a<стандартный оператор +>b и открываю небольшой кирпичный заводик.

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

azesmcar, наш спор не имеет смысла, т.к. я сама выступаю за максимальную вседозволенность - фрилав, анархия и полный легалайз! - просто в топике выступаю в роли Кэпа: чем язык гибче, тем больше потенциальных косяков может всплыть во время его использования. Это не должно останавливать от использования такого языка, но просто быть готовым к неожиданностям надо.

Еще в кучу перегрузки (функций): если программа на нашем языке выполняется нативно, перегрузка неизбежно (или нет?) приведет к name-mangling в исполняемом файле программы.

ok, тут я погорячился, все кроме встроенных

пишу функцию add и делаю деление   

тебя волнует name-mangling в исполняемом файле программы?   

Делай, но согласись, одно дело, когда непонятное поведение преследует тебя только в твоем коде, и другое - если оно по факту может происходить в любом месте.

Ну вообще то да, случается, что волнует.

не совсем понял




в чем отличие ?

Это в язык не встроено. Тут ты полагаешься на авось, изучаешь документацию на функцию add или вычитываешь ее исходник. Если в языке включена перегрузка, выполняешь квест, описанный ниже.

Это встроено. Если перегрузки нет, ты уверен, что выполнится именно то, что написано: значения двух переменных будут сложены - вот в этом весь цимес. Если мы имеем перегрузку функций/операторов, в этом ты тоже не уверен и полагаешься на авось или ищешь типы переменных (а в с++ еще и то к каким типам они могут быть приведены! (а в с++ типы приводятся двумя способами, совсем свихнуться можно!)), устанавливаешь какой из множества операторов + будет выполнен и изучаешь документацию на него или вычитываешь его исходник.

a + b для НЕ фундаментальных типов тоже в документацию не встроено. Речь идет не о переопределении операторов, а о перегрузке.

Ладно, я последний раз попробую объяснить... Ты перегружаешь оператор + для множества комбинаций типов. Потом где-то видишь строчку a+b и реально нет никаких гарантий, что будет выполнено нечто вроде сложения или хотя бы конкатенации. Чтобы не быть голословной, пусть "где-то" - это в каком-то шаблонном коде (c++) или просто в языке с динамической типизацией, видя который перед своими глазами ты действительно не знаешь, какого типа у тебя a и b, и какой код будет выполнен во время вызова a+b. В случае отсутствия возможности перегружать операторы ты будешь уверен, что выболнится то, что написано: сложение, а для "неправильных" типов либо ошибка компиляции, либо сигнал/эксепшн - в зависимости от языка.

подставь a.add(b) вместо a+b, ничего не изменится => методы/функции не нужны

Это сообщение отредактировал(а) 502 - 6.12.2011, 14:38

Ты дундук! Я тебе о перегрузке, а ты все за оператор VS функция цепляешься...

Добавлено через 1 минуту и 16 секунд
И ваще, господа спорщики, выкладывайте свои мнения по поводу сабжа а не моего первого комментария

Я и говорю о том, что если программист перегружает оператор + и реализует в нем деление, то его надо кастрировать. Это не повод отменять операторы и их перегрузку, как неправильное использование исключений не повод отменять исключения. Перегрузка операторов - это всего лишь еще одна возможность языка и это возможность (как и впрочем 99% других) дает программисту возможность написать индокод, но это не значит, что сама возможность плохая и она не нужна. Я говорю о том, что не считаю аргументом в пользу отказа от некой возможности то, что используя эту возможность можно написать плохой код.

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

У меня нет аргументов, почему язык должен этого не поддерживать, у меня есть аргументы для обратного утверждения. Почему я должен делить значение встроенного типа int с помощью оператора, а своего типа big_int с помощью функции?

Это сообщение отредактировал(а) azesmcar - 6.12.2011, 14:58

Да полностью согласен.. Для тех, кому гибкость не нужна, такие языки как С++ противопоказаны,  в крайнем случае С в котором отсутсвует перегрузка как таковая, хотя и он для неокрепшей психики не рекомендуются.. Лучше уж к языкам Виртам приобщиться (привет главному агитатору этого дела, давно его видно не было).. Сухие, не эмоциональные предложения  обеспечат мнимую уверенность в безопасности кода..
Но есть люди, которым охота придать окрас своим предложениям.. Им не нравится односложные предложения первого класса, а хочется передать свою мысль во всей ее красоте. Таким неохота нудно и банально описывать компилятору, что он должен сделать, а проще переложить эту рутинную работу на его плечи, извлекая из системы типов максимальную пользу...
Но для второго мало желания красиво выражаться, нужно еще и учиться, знать правила (а в некоторых языках  (С++) из за многообразия ньюансов это действительно затруднительно).. Мало вероятно, что некто имея уровень образования соответсвующий 3му классу, сможет писать сочинения на уровне Чехова..  Поэтому мое мнение, спорить надо не о наличие в языке возможностей перегрузки, в частности, операторов, а о пороге вхождения таких языков.. 

P.S. (примеры языков приводил со своей колокольни)

Это сообщение отредактировал(а) mes - 7.12.2011, 09:01