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

    +2

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    template <typename F, class = decltype(F()(E()))>
        auto map(F p) -> std::vector< decltype(p(E())) >
        {        
            std::vector< decltype(p(E())) > result;
            std::transform(get().begin(), get().end(), std::back_inserter(result), [=](auto &v) {
                return mutable_(p)(v);
            });
    
            return result;
        }
    
        template <typename F, class = decltype(F()(E(), 0))>
        auto map(F p) -> std::vector< decltype(p(E(), 0)) >
        {        
            std::vector< decltype(p(E(), 0)) > result;
            auto first = &(get())[0];
            std::transform(get().begin(), get().end(), std::back_inserter(result), [=](auto &v) {
                auto index = &v - first;
                return mutable_(p)(v, index);
            });
    
            return result;
        }
    
    // и применение (e) => f()
        auto strs = (array<int>{ 1, 2, 3 }).map([](auto x)
        {
            return "X" + x;
        });
    
    // или (e, index) => f()
    
        auto strs = (array<int>{ 1, 2, 3 }).map([](auto x)
        {
            return x + i;
        });

    как я выкрутился бля... с разными маперами... как генерики в c#

    Запостил: ASD_77, 27 Мая 2020

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

    • там во втором должно быть

      (array<int>{ 1, 2, 3 }).map([](auto x, auto i)
      Ответить
    • > auto map(F p) -> std::vector< decltype(p(E())) >

      Уот? После -> возвращаемый тип указан? Это када такой синтакс появился?

      Зачем тада ауто?
      Ответить
      • Это чтобы можно было типы аргументов в типе возвращаемого значения юзать. А auto там просто как заглушка чтобы парсер не офигел.
        Ответить
        • Так когда такой синтаксис завезли-то?
          Ответить
          • это было в с++ 11 т.е. 9 лет тому

            https://oopscenities.net/2018/03/04/auto-return-type-deduction/
            Ответить
            • А C++14 уже умеет выводить по выражению return? А если у нас несколько ретурнов, то компилятор сломается?
              Ответить
              • он не сломается. он нахрен пошлет. а вот если концепты юзать тогда сломается
                Ответить
                • В «C++17» всё заебись будет:
                  auto f(int x) {
                      if (x % 2 == 0) {
                          return "even";
                      } else {
                          return "odd";   
                      }
                  }
                  
                  int main() {
                      std::cout << f(42) << std::endl << f(41) << std::endl;    
                      return 0;	
                  }

                  https://wandbox.org/permlink/bKAba8J1uAYzscIg

                  А вот если типы развращаемых значений разные будут — тогда да, тогда полшёт.
                  Ответить
          • В «C++11», дедушка. Новомодная фигня, короче.
            Ответить
        • В смысле крестобляди опять не осилили расширить старый синтакс и высрали новое несовместимое говно?

          А что если сразу и там и там указать тип, интересно? )

          А чем обосрновали они такое решение? Типа до разбора типов аргументов писатели конпеляторов не осилят децлтайп от этих аргументов обработаь или шо?
          Ответить
          • типа
            Q map(F p) -> std::vector< decltype(p(E())) >

            ?
            Ответить
            • ну это как бы дать понять компилятору что ему не получиться отпетлять с формулировкой "не смог определить возврат" :)
              Ответить
          • > Типа до разбора типов аргументов писатели конпеляторов не осилят децлтайп от этих аргументов обработаь или шо?
            До разбора типов аргументов этих самых аргументов просто не существует.
            decltype(a + b) /*Ошибка: в этой точке никаких «a» и «b» нет*/ f(int a, int b) { ... }
            Ответить
            • Я имел ввиду что можно отложить и обработать это говно после разбора аргументов.
              Ответить
              • Убоялись. В крестах нельзя распарсить даже выражение a<b,c>d; пока тип идентификатора «a» неизвестен.
                Ответить
              • Видимо, они побоялись ломать обратную совместимость с такими вот весёлыми штуками:
                typedef std::string my_string;
                
                my_string func(int my_string) {
                    std::cout << my_string << std::endl;
                    return "my_string is: " + std::to_string(my_string);
                }
                
                int main() {
                    std::cout << func(42) << std::endl;
                    return 0;	
                }

                https://wandbox.org/permlink/WyVQF3f0DJMZ9N5f
                Ответить
                • Немножко продолжу банкет:
                  #include <iostream>
                  #include <string>
                  
                  typedef std::string my_string;
                  
                  my_string func(my_string my_string) {
                      std::cout << "Insinde func: " << my_string << std::endl;
                      return ::my_string("Returning: " + my_string);
                  }
                  
                  int main() {
                      my_string my_string = "Hi";
                      std::cout << func("Hello World") << std::endl;
                      std::cout << my_string << std::endl;
                      return 0;	
                  }

                  https://wandbox.org/permlink/ffAAwiDWGumF1lzn
                  Ответить
                  • Марклар какой-то.
                    Ответить
                    • Продолжаем издеваться над парсером.
                      typedef std::string my_string;
                      
                      namespace bagor {
                          my_string my_string(my_string my_string) {
                              std::cout << "my_string inside my_string: " << my_string << std::endl;
                              return "Return value: " + my_string;
                          }
                      }
                      
                      int main() {
                          std::cout << bagor::my_string("Hello World") << std::endl;
                          return 0;	
                      }

                      https://wandbox.org/permlink/d74yyHKBEnGSiQ0R
                      Ответить
                      • typedef long long LongLong;
                        
                        void f(unsigned LongLong) {
                            // Думаете, это функция с одним неименованным параметром типа «unsigned long long»?
                            // А вот хуй.
                            std::cout << "f1(" << LongLong << ")" << std::endl;
                        }
                        
                        int main() {
                            f(42);
                            return 0;	
                        }

                        https://wandbox.org/permlink/IRMqmbEtP9GA8Ox4
                        Ответить
                      • Какая питушня )))

                        При придумывании новых стандартов надо озаботиться выпиливанием такого говна, а не нагромождением синтаксиальной психозы.
                        Ответить
          • Сишку изобретали в расчёте на однопроходный компилятор. И Страуструп унаследовал костыли сишки.

            Потом, конечно, компиляторы стали многопроходными, но осадочек остался.
            Ответить
    • а кто нить догадался нахрена нада class = decltype(F()(E())) и class = decltype(F()(E(), 0)) в шаблоне?
      Ответить
    • Переведите на Java Script
      Ответить

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