1. C++ / Говнокод #8220

    +1007

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    template <typename T, typename U>
    auto operator()(T&& t, U&& u) const
    -> decltype(forward<T>(t) + forward<U>(u)) {
        return forward<T>(t) + forward<U>(u);
    }

    Запостил: ohlol, 17 Октября 2011

    Комментарии (83) RSS

    • Очень читаемо...(
      Ответить
    • а почему не operator+ ?
      Ответить
      • перегрузка оператора + для 2х произвольных типов? мутация же!
        Ответить
        • Что ещё за мутация? перегрузка операторов мало чем отличается от перегрузки функций.
          Не вижу тут никаких проблем с перегрузкой бинарного "+" для двух разных типов.
          Ответить
          • А я вот вижу. Простенький такой пример.
            class string{
            public:
            string(){...}
            string(const char *str){...}
            string(const string& str){...}
            ...
            string& operator+(const string& str){...}
            string& operator+(const char *str){...}
            }

            string b = "aaaaa";
            string a = "a" + b; // опа, не компилится.

            а вот с оператором скомпилится, будет неявное преобразование.

            Хотя в примере пестец.
            Ответить
            • Сделайте свободную функцию, как в гк, а не член класса. У вас первый операнд ограничивается из-за этого типом string.
              Ответить
            • >> а вот с оператором скомпилится, будет неявное преобразование.
              отвлекали, ступил, криво написал, про friend функцию имел ввиду.
              Ответить
          • >Что ещё за мутация?
            В С++ не может быть перегрузки операторов для исключительно стандартных типов, а здесь U и T могут быть стандартным.
            Ответить
            • Короче: в приведенном ГК - функция-член класса (о чем говорит наличие const), о каких тут стандартных типах может идти речь вообще с точки зрения перегрузки?
              Если же перегрузка operator+ будет производиться на глобальном уровне, то да, для стандартных типов работать не будет. Однако, если хотя бы один из них будет пользовательским типом, то всё ок.
              Ответить
              • >Короче: в приведенном ГК - функция-член класса
                Это верно, но я не понимаю в чем вопрос? Человеку нужно сделать функтор что-то складывающий - он это и сделал. Ему не нужен оператор +.
                Ответить
        • мудант ты, алехуй, невалидный логин взял, но не стал менее унылым
          Ответить
          • так это ohlolexyi ?
            Ответить
            • после этого - http://govnokod.ru/8152 - логин общего пользования
              Ответить
              • отправил в минус одиннадцать. мдя уж. на кучу не подписан, поэтому не читал.
                Ответить
              • а я думаю, почему от моего имени кто-то пишет все время и у меня возникает такое чувство, что обо мне знают что-то такое, чего я не знаю сам...

                мне было лень регистрироваться и знакомый отдал мне этот ник, сказав что он особенный...
                Ответить
                • Да, да... Знакомый подруги друга соседа моего брата... Сипипи двести тридцать второго...
                  Ответить
                  • >Знакомый подруги друга соседа моего брата...
                    С чего ты взял? Нет. Просто мой знакомый.

                    >Сипипи двести тридцать второго...
                    RS-232?
                    Ну он мне сказал, что это не он. Он вообще интернеты не любит.
                    Ответить
                    • Почистите свои куки браузером, и завлагиньтесь.
                      Ответить
                      • Упс. Разлогинился. :-[
                        Ответить
                      • Ты думаешь, страйкер такой говнокодер, что таким образом банит народ?
                        Ответить
              • ЧСХ, там уже оба пасса сменены :-)
                Ответить
      • Потому, что неизвестно, где он определён — как член класса или вне класса.
        Ответить
        • кому не известно и кто он?
          Ответить
          • > кто он?
            сами знаете кто
            Ответить
          • Автору шаблонного кода. operator+.

            forward<T>(t).operator+(forward<U>(u)) или operator+(forward<T>(t), forward<U>(u))? Для разных типов будет по-разному.
            Ответить
            • А зачем знать где он определен? Если нет в классе, то будет вызываться глобальный. Или я не прав?
              Ответить
              • Как? Выберите синтаксис.
                Ответить
                • Так-с... по факту оказалось, что нельзя определять оператор+ глобально и внутри класса, возникает неоднозначность выбора.
                  Но я все равно не понимаю, зачем знать где он определен.
                  Ответить
                  • А как вы его используете?
                    Ответить
                    • Не, ребята, я конечно институтов не кончал, мне вот интересно: перегрузка операторов - это признак мощности языка программирования - или всё таки soft code? (что как бы намекает, на то, что разработчики языка были недостаточно нетрезвы чтобы позволить такое.) Или, всё таки, это удобная штука?
                      Ответить
                      • Это синтаксический сахар.
                        Ответить
                        • А такая фишка не запутывает программиста?
                          "+" в данном контексте, означает одно(например, конкатенацию строк ) , а в другом контексте - другое (например, добавление свойств объекту)
                          Ответить
                          • http://ru.wikipedia.org/wiki/Синтаксический_сахар
                            Ответить
                            • Я к тому, что:
                              http://mults.spb.ru/mults/?id=2305
                              Ответить
                              • На википедии и критика описана. :-P
                                Канонический пример запутывания:
                                std::cout << "omg wtf";
                                Ответить
                      • Это позволяет единообразно представлять в коде встроенные и пользовательские типы.
                        Главное условие - чтобы в прикладной области было принято такое трактование.
                        Ответить
                        • Насколько я понимаю - стороннему программисту требуется значительное время, для того чтобы изучить все перегруженные операторы определённого типа данных?
                          Ответить
                          • зависит от знаний стороннего программиста
                            Ответить
                            • Т.е. код получается божественным большим комком грязи, не?
                              Ответить
                              • не. В Руби, например, любой оператор является методом, и код выглядит проще (при адекватной реализации, разумеется)
                                Ответить
                      • Это удобная штука, позволяющая работать с пользовательскими типами данных, как с встроенными. Нет проблем для комплексных или целых неограниченной точности писать a.add(b).mul(c), но (a+b)*c — удобнее.

                        Киллер-фичей Фортрана в своё время была возможность записи арифметических выражений в естественной форме. Теперь это есть в 99.9% языков и воспринимается как само собой разумеющееся.
                        Ответить
                    • например так:
                      struct S
                      {
                         /* int operator+( int i )
                         {
                            return +100500; 
                         } */
                      };
                      
                      int operator+ (S s, int i)
                      {
                         return -100500;
                      } 
                      
                      int tmain()
                      {
                         S s;
                         std::cout << s + 5;
                         return 0;
                      }
                      Ответить
                      • Запишите исходный код, явно вызывая operator+.

                        forward<T>(t).operator+(forward<U>(u)) или operator+(forward<T>(t), forward<U>(u))?
                        Ответить
                    • показать все, что скрыто>А как вы его используете?
                      Ай йа йай. В своем языке плюсисты разобраться не можете...
                      Ответить
    • Это какое-то сильное колдунство?
      Ответить
      • да. ШФП (шаблонно-функциональная парадигма) головного мозка.
        Ответить
    • оператор -> классно переопределен)
      Ответить
    • Ты сделал мне больно.
      Ответить
    • -> decltype(forward<T>(t) + forward<U>(u))

      что это за поебень? из сипипоха?
      Ответить
    • не понял.. где разглядели перегрузку operator+ ?
      Ответить

    Добавить комментарий