1. Perl / Говнокод #11489

    −136

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    sub parse_http_date($)
    {
    	my ($date)[email protected]_;
    	my %months=(Jan=>0,Feb=>1,Mar=>2,Apr=>3,May=>4,Jun=>5,Jul=>6,Aug=>7,Sep=>8,Oct=>9,Nov=>10,Dec=>11);
    
    	if($date=~/^[SMTWF][a-z][a-z], (\d\d) ([JFMASOND][a-z][a-z]) (\d\d\d\d) (\d\d):(\d\d):(\d\d) GMT$/)
    	{ return eval { timegm($6,$5,$4,$1,$months{$2},$3-1900) } }
    
    	return undef;
    }

    Вакаба.

    Запостил: 7ion, 28 Июля 2012

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

    • Perl — это тот язык, который одинаково выглядит как до, так и после RSA шифрования.(с)
      Ответить
    • >Вакаба.
      Да её целиком можно выкладывать. Как сказал один мой знакомый "Проще своё написать, чем это дол ума доводить".
      Ответить
    • Perl уже не очень актуален
      Ответить
    • Тут с первой строчки пиздец.

      Вместо
      my %months=(Jan=>0,Feb=>1,Mar=>2,Apr=>3,May=>4,Jun=>5,Jul=>6,Aug=>7,Sep=>8,Oct=>9,Nov=>10,Dec=>11);

      следует писать
      my @months = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
      my %codes = map {$months[$_] => $_} 0 .. $#months;
      print($codes{'Feb'}) #1;
      Ответить
      • А я за «Python».
        >>> dict(zip('Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec'.split(), range(1, 13)))
        {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6, 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}


        UPD: Хотя, конечно, лучше не выёбываться однострочниками и написать по-человечески:
        >>> import itertools
        >>> dict(zip('Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec'.split(), itertools.count(1)))
        {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6, 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}


        UPD2: Не заметил, что месяцы надо с нуля. Какой багор )))
        Ответить
        • А я за «PHP».
          array_flip(explode(' ', 'Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec'))
          Ответить
          • Какой скилл )))
            Ответить
          • Именно поэтому я за «PHP».
            Ответить
          • А нук переведи вот такую чуйню
            my @hackers = qw(O'Tool Ein$tein "CoolGuy");
            print join ', ', @hackers; #O'Tool, Ein$tein, "CoolGuy"
            Ответить
            • H16H_V017463_(0(K
              Ответить
              • Что тебе непонятно?
                Ответить
              • =('you_are_here')=
                Ответить
                • Оператор "козочкина любовь" пишется не так, а так
                  =()=

                  Он организует листовой контекст справа, а потом переводит результат в скалярный
                  Ответить
            • Ничего не понимаю. Переведи на «PHP».
              Ответить
              • Что не потяно?

                Я создал массив из трех записей
                O'Tool
                Ein$tein,
                "CoolGuy"
                и вывел их через запяту

                А у вас qw нету, лол
                Ответить
                • Зачем мне кью вэ?
                  Ответить
                  • ну сделай мне такой массив, и сравни читаемость
                    Ответить
                    • <?php
                      
                      $hackers = explode(' ', 'O\'Tool Ein$tein "CoolGuy"');
                      echo implode($hackers, ', ');


                      Сравнил. В «PHP» читаемее.
                      Ответить
                      • Это со слешем читаемее? серьезно?
                        Ответить
                        • Если не нравится - используй хередок.
                          Ответить
                          • как хередок можно в одну строку?
                            Ответить
                            • зачем мне одна строка?
                              Ответить
                              • Ну вот тебе нужно перечислить список ников, зачем тебе много строк?
                                Ответить
                                • Есть ник Lure Of Chaos
                                  тогда все соснут

                                  А в хередоке лучше по одному в строке
                                  Ответить
                                  • Это правда.

                                    Но в целом мысль того, что ты можешь перечислять слова без кавычек и запятых и получать массив -- она же классная!

                                    Она есть в руби, перле, tcl, а вот в пых с питоном не завезли
                                    Ответить
                                  • Все соснули у TCL ожидаемо.

                                    $ tclsh
                                    % set nicks {MAKAKA admin "Lure of Chaos" gost}
                                    MAKAKA admin "Lure of Chaos" gost
                                    % lindex $nicks 0
                                    MAKAKA
                                    % lindex $nicks 1
                                    admin
                                    % lindex $nicks 2
                                    Lure of Chaos
                                    % lindex $nicks 3
                                    gost


                                    Всё, я теперь за TCL
                                    Ответить
                        • Смотрите, как надо:
                          <?= implode(explode(' ', <<<'PITUHI'
                          O'Tool Ein$tein "CoolGuy"
                          PITUHI
                          ), ', ');


                          https://ideone.com/WuM6dg
                          Ответить
                    • >>> print('''O'Tool Ein$tein "CoolGuy"'''.split())
                      ["O'Tool", 'Ein$tein', '"CoolGuy"']
                      
                      >>> ['O\'Tool', 'Ein$tein', '"CoolGuy"']
                      ["O'Tool", 'Ein$tein', '"CoolGuy"']

                      Подтверждаю Иньо, «qw» не нужен.
                      Ответить
                      • C ''' -- уже лучше, но куча лишних скобов. А в пыхе есть """?

                        Второй вариант засран кавычками и еще и слешем
                        Ответить
        • Язык богов передает вам привет.
          MONTHS = %w[Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec].each_with_index.to_h
          Ответить
        • В питончике нехватает wq/%w конечно
          Ответить
        • >>> dict(enumerate("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split()))
          {0: 'Jan', 1: 'Feb', 2: 'Mar', 3: 'Apr', 4: 'May', 5: 'Jun', 6: 'Jul', 7: 'Aug', 8: 'Sep', 9: 'Oct', 10: 'Nov', 11: 'Dec'}
          Ответить
          • Ой
            >>> dict(map(lambda x: (x[1], x[0]), enumerate("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split())))
            {'Jan': 0, 'Feb': 1, 'Mar': 2, 'Apr': 3, 'May': 4, 'Jun': 5, 'Jul': 6, 'Aug': 7, 'Sep': 8, 'Oct': 9, 'Nov': 10, 'Dec': 11}
            Ответить
            • Малочитаемое конечно, а еще куча скобочек
              Если добавить в задание хакеров из https://govnokod.xyz/_11489/#comment-541800 , то отсос у руби (и немного у перла) станет очевиден
              Ответить
    • В перле можно встреить такой хак
      perl -n  -e "}{ print $."

      Выводится количество строк в stdin. Кто угадает как это работает?

      Подсказки:
      * "-n" важен: см perl --help
      * про $. можно прочитать в perldoc perlvar
      Ответить
      • Получается иньекция, оптомушто -n это
        "while(<>){$code}"


        А $. хранит умер последнец прочитанной строки.
        Ответить
        • именно!
          получается
          while(<>){}{print $.}
          Ответить
        • Какая инъекция )))
          Ответить
          • В питухоне такое не написать ни в жизни, кстати.
            Ответить
            • Какое?
              Ответить
              • $ cat /etc/passwd | perl -n -e '$a++ if $_=~/nologin/}{ print "You have $. users, $a daemons\n"';
                You have 29 users, 24 daemons

                Переведи на питухон одной строчкой
                Ответить
                • Не могу, в «Питоне» принято писать явно. Именно поэтому я за «Питон».
                  Ответить
                  • Скучно
                    Ответить
                    • И вот тут бы пригодились функции Бесселя из плюсов. С ними не скучно!
                      Ответить
                    • Ну ладно, поучаствую в спецолимпиаде.
                      python3 -c "with open('/etc/passwd', 'r') as f: l = list(f); print(f'''You have {len(l)} users, {len([x for x in l if x.find('nologin') + 1])} daemons''')"
                      Ответить
                      • Да, читаемость у питона не очень, надо признать.

                        >list(f)
                        ты весь файл закачал в памяти?? а вдруг там гигабайт?

                        ну вот, питон еще и по памяти не оптимизирован..
                        Ответить
                        • Оптимизировал по тем параметрам, которые есть в ТЗ. В «/etc/passwd» никогда не будет гигабайта данных, поэтому оптимизация по памяти не требуется и будет предварительной.

                          Читаемость, как по мне, гораздо лучше: всё просто и понятно даже пятикласснику. Ну, разве что специфичные для «Питона» list comprehensions и f-строки имеются.
                          Ответить
                          • Ну давай теперь оптимизируем по памяти?

                            list comprehensions вообще не очень читаемы кмк
                            Ответить
                            • Давай.
                              python3 -c "import functools; x = functools.reduce(lambda acc, val: (acc[0] + 1, acc[1] + val), map(lambda x: x.find('nologin') == -1, open('/etc/passwd')), (0, 0)); print(f'You have {x[0]} users, {x[1]} daemons')"

                              Гвидо — пидор. Мало того, что сделал совершенно уёбищные лямбды, так ещё и reduce() в отдельный пакет убрал (а map() и filter() оставил в глобальном пространстве, лол).
                              Ответить
                              • А вот в руби и в перле можно заимпортить пакет ключиком командной строки! В питоне так нельзя? Обязательно import писать?

                                Вообще по чесноку конечно мою задачу нужно решать авком
                                $ cat /etc/passwd | awk  '{L++; if ($0~/nologin/) N++}END{print "Total users:",L, " Daemons",N}'
                                Ответить
                                • > В питоне так нельзя? Обязательно import писать?
                                  Конечно, «Питон» для таких хаков слишком прост.
                                  Ответить
                                  • Именно по этому
                                    Ответить
                                  • -i -m functools не оно? Хотя второй модуль так уже не зацепить, да.
                                    Ответить
                                    • нет, это запускает библу как модуль. То-есть там __main__ должен быть (или __init__, не помню)
                                      Ответить
                                      • __main__ для красоты пишут. Его руками зовут один хер, это не какое-то специальное имя. Но да, эта штука загружает указанный скрипт как главный модуль.
                                        Ответить
                                        • воништ
                                          Ответить
                                          • А, я понял о чём ты. Ты о том что __name__ будет содержать __main__.

                                            З.Ы. Как же бесят эти ебучие подчерки. Как-будто в кишках stl копаешься.
                                            Ответить
                              • А в «PHP» array_reduce, array_map, array_filter во встроенной библиотеке. Именно поэтому я за «PHP».
                                Ответить
                                • Функциональный язык прям.
                                  Ответить
                                  • Только если я переведу код gost'а на «PHP», получится длиннее, потому что лямбды и замыкания в «PHP» записываются многословно.

                                    Вот на «Ди» получится довольно коротко.
                                    Ответить
                              • >Мало того, что сделал совершенно уёбищные лямбды

                                Опровергаю. Или там какие-то багры есть, о которых я не знаю?

                                >reduce() в отдельный пакет убрал (а map() и filter() оставил в глобальном пространстве)

                                А вот тут верно.
                                Ответить
                                • Лямбды уебищны мусорным синтаксимом и словом "lambda".
                                  Ответить
                                  • Да, и вот это тоже.
                                    Ответить
                                  • >мусорным синтаксимом и словом "lambda"

                                    Если проблема только в этом, то во многих языках используют ещё более длинное «function».

                                    Кмк, по-настоящему уёбищные лямбды в крестах.
                                    Ответить
                                    • В нормальных языках не используют.
                                      Ну, разве что в lua.

                                      В js стрелочки
                                      В Perl sub, хотя часто можно просто передать блок
                                      В руби просто куча видов блоков из коробки
                                      В котлине просто блок, и кажется в груви тоже
                                      Ответить
                                    • > Кмк, по-настоящему уёбищные лямбды в крестах.
                                      Зато там можно в одной лямбде использовать три вида скобок! А в «C++20» можно будет все четыре.
                                      [](){};  // C++17
                                      []<class>(){}; // C++20
                                      Ответить
                                      • Там вроде можно выбирать, что явно захватывать.
                                        Больше ни в одном нормальном* языке программирования так нельзя, к сожалению. А жаль.

                                        *в одном пидарском языке можно, но мы его не будем даже упоминать
                                        Ответить
                                        • Да, это одна из хороших вещей про крестовые лямбды.
                                          []() { /* Ничего не захватываем: просто анонимная функция */ };
                                          [&]() { /* Захватываем весь внешний ко-ко-контекст по ссылке */ };
                                          [=]() { /* Захватываем весь внешний ко-ко-контекст по значению, копируя */ };
                                          [&a, b]() { /* Захватываем a по ссылке, b по значению*/ };
                                          
                                          ([]<class>(){}).operator()<int>();  // C++20: вызываем (IIFE) шаблонную лямбду. Какой багор )))
                                          Ответить
                                          • крутота! Язык багов
                                            Ответить
                                          • А что такое внешний контекст?
                                            Ответить
                                            • Все видимые на момент определения замыкания автоматические пельменные («automatic variables») — грубо говоря, все, которые были определены внутри блоков (тела функции, цикла, условия, etc) без ключевых слов static/extern/thread_local. «Автоматические» они потому, что после выхода из соответствующего блока они будут автоматически уничтожены («RAII»).
                                              Ответить
                                        • В питоне лямбды черезчур примитивны, а в крестах напротив черезчур переусложены.
                                          Ответить
                                          • > а в крестах напротив черезчур переусложены.
                                            Скорее, это просто следствие сложности крестов в целом.
                                            В том же «JavaScript» просто нет смысла контролировать захватываемый ко-ко-контекст, потому что всё равно всё — ссылка, причём не висячая. Захватиться лишнего — похуй.

                                            А в крестах нужно ручками всё контролировать. Реальный пример — возврат замыкания, захватывающего локальную пельменную. Если будем всё захватывать по ссылке — получим висячие ссылки, UB, кровь, кишки. Если будем захватывать по значению — мало того, что проебём весь пирфоманс, так ещё и в принципе проебёмся, потому что некоторые объекты захватывать нельзя.
                                            auto get_closure() {
                                                Petuh pethu;
                                                pethu.set_name('Petya');
                                                return []() { pethu.kukareku(); };  // Заватим петху по ссылке — получим багор
                                            }
                                            Ответить
                                            • А как же вернуть лямбду, ухватившую локального автоматического питушка? Умный указатель нужен?
                                              Ответить
                                              • Простой вореант — скопировать питуха.
                                                auto get_closure_1() {
                                                    Petuh pethu;
                                                    pethu.set_name('Petya');
                                                    return [pethu]() { pethu.kukareku(); };  // Всё хорошо: на каждом вызове get_closure()
                                                                                             // получим нового петху в замыкании
                                                }


                                                Если скопировать нельзя — переместить, используя несколько страшно выглядящий «Generalized lambda capture» («C++14»):
                                                auto get_closure_2() {
                                                    Petuh pethu;
                                                    pethu.set_name('Petya');
                                                    return [pethu = std::move(pethu)]() { pethu.kukareku(); };  // pethu перелетел в замыкание!
                                                }
                                                Ответить
                                                • >pethu = std::move(pethu)

                                                  Право, я удивлён.
                                                  Почему не какой-то очередной упоротый, ничего не означающий значок?
                                                  Ответить
                                                  • Какой значок? Ёбнулся? Одно из ключевых слов какое нибудь надо взять.
                                                    Ответить
                                                    • Это же С++. Там кругом значки.Это был сарказм
                                                      * — кокозатель
                                                      & — сцылка
                                                      = — всё по значению
                                                      Можно например @ или ^
                                                      Ответить
                                                • Да это лучший язык!
                                                  Ответить
                                            • Ой, я недавно ловил такой багор )))
                                              Ответить
                                        • А я не постесняюсь сообщить, что в «PHP» все захватываемые пельменные нужно перечислять явно (причём указывается тип захвата: по значению или по ссылке).
                                          Ответить
                                        • Это ты Свифт так щас приложил?
                                          Ответить
                                          • Извини, я свитф не знаю

                                            Там можно, да?
                                            Ответить
                                            • Там можно захватывать ссылки как слабые и явно указывать, что ты хочешь скопировать value type.

                                              Или ты что-то другое имел в виду?
                                              Ответить
                                • > Или там какие-то багры есть, о которых я не знаю?
                                  Ну дык вместо нормального замыкания (или хотя бы анонимной функции) — одно выражение-огрызок. Реальный пример: хочу лямбду, принимающую строку и возвращающую пару (строка_в_нижнем_регистре, хэш_строки_в_нижнем_регистре). До 3.8 это можно было сделать либо наивно (повторение кода, удвоение тяжёлых операций — говно, в общем): «lambda s: (s.lower(), hash(s.lower()))», либо уёбищно: «lambda s: (lambda s_lower: (s_lower, hash(s_lower)))(s.lower())». С 3.8 дела стали чу-у-уть лучше: «lambda s: (s_lower := s.lower(), hash(s_lower))», но всё ещё очень плохо — никаких циклов, никаких присваиваний внешним пельменным.

                                  Именно поэтому я за «JavaScript» с его однообразным свинтаксисом для всех функций и замыканий.
                                  Ответить
                                  • Ух ты, оператор конь моржовый, или как он там, да?

                                    Сначала тридцать лет тебе рассказывают, что си -- говно, потому что там присвоение это выражение, возвращающее значение, а потом хуяк -- и тоже самое делают в питоне
                                    Ответить
                                    • Ага, walrus.

                                      Не, ну тут я питонухов поддерживаю: проблема с сишным оператором «=» в том, что его очень легко написать вместо «==» — и, что самое главное, полученная очепятка будет полностью валидным выражением, которое ещё и выполняется правильно, похеривая только дальнейшее выполнение программы. Абсолютно любой человек, который писал на си или крестах что-то сложнее «Хеллоу Ворлда», делал эту опечатку.
                                      А вот с питоньем хером оператором моржовым так опечататься не получится.
                                      Ответить
                                      • Это я ещё, кстати, забыл, что до каких-то версий Стандарта очень распространённое выражение вида «a = b = c = 42;» формально было неопределённым поведением! Какой багор )))
                                        Ответить
                                      • >Абсолютно любой человек, который писал на си или крестах что-то сложнее «Хеллоу Ворлда», делал эту опечатку.

                                        Именно поэтому я постоянно пишу константу спереди.

                                        И именно поэтому я против неявного преобразования любой питушни в boolean.
                                        Ответить
                                        • Какой Йода )))

                                          ИМХО, Йода-стайл — это борьба с последствиями, а не причиной. Плюс он не спасает, когда сравниваются две мутабельных переменных.

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

                                            Вместо сравнения двух мудакбельных переменных можно сравнивать их разницу с нулём:
                                            if (a == b) // так пишут только мудаки
                                            if (0 == a - b) // а так пишут магистры
                                            Ответить
                                            • Какой магистр )))

                                              Не поможет, когда сравниваются объекты без перегруженного минуса. Векторы, например.
                                              Ответить
                                              • >сравниваются объекты без перегруженного минуса. Векторы, например.

                                                Векторы (геометрические) ещё можно отнять покомпонентно.
                                                А вот строки...

                                                Да и минус породит новый временный объект, а это перепитушня.
                                                Ответить
                                                • > Векторы ещё можно отнять.
                                                  Не, к счастью, в крестах для стандартного вектора (который «std::vector») такой операции не предусмотрено.
                                                  Хотя, конечно, если захотеть — перегрузить можно всё.

                                                  > Да и минус породит новый временный объект, а это перепитушня.
                                                  Подтверждаю.
                                                  Ответить
                                                  • В коко можно из листа вычесть другой лист
                                                    Ответить
                                                  • Реальный пример перегрузки:
                                                    #include <iostream>
                                                    #include <vector>
                                                    
                                                    template<typename T, typename R>
                                                    auto operator-(const std::vector<T> & a, const std::vector<R> & b)
                                                    {
                                                        using CommonType = decltype(std::declval<T>() - std::declval<R>());
                                                        if (a.size() != b.size()) {
                                                            throw std::runtime_error("a.size() != b.size()");
                                                        }
                                                    
                                                        auto res = std::vector<CommonType>{};
                                                        res.reserve(a.size());
                                                    
                                                        for (size_t i = 0; i < a.size(); i++) {
                                                            res.push_back(a[i] - b[i]);
                                                        }
                                                    
                                                        return res;
                                                    }
                                                    
                                                    template<typename T>
                                                    std::ostream & operator<<(std::ostream & stream, const std::vector<T> & vec)
                                                    {
                                                        stream << '[';
                                                        auto it = vec.begin();
                                                        if (it != vec.end()) {
                                                            stream << *it++;
                                                        }
                                                        for (; it != vec.end(); ++it) {
                                                            stream << ", " << *it;
                                                        }
                                                        stream << ']';
                                                    
                                                        return stream;
                                                    }
                                                    
                                                    int main()
                                                    {
                                                        std::vector<int> a{ 1, 2, 3 };
                                                        std::vector<float> b{ 1, 2, 2 };
                                                        std::cout << (a - b) << std::endl;
                                                    
                                                        return 0;
                                                    }

                                                    https://wandbox.org/permlink/PeXsgwmcVcaRyQ2z
                                                    Ответить
                                                    • Вдруг ты не знал, можно писать using namespace std, чтобы не писать std:: везде.
                                                      Ответить
                                                      • > можно писать using namespace std
                                                        В среде крестовиков это считается очень дурным тоном.
                                                        Ответить
                                                        • Не отмазывайся. Ты просто не знал что так можно!!!
                                                          Ответить
                                                          • https://i.imgur.com/KtUZT7C.png

                                                            Всем спокойной ночи.
                                                            Ответить
                                                        • Ну я просто для информации
                                                          Ответить
                                                          • Борманда проинформируй.

                                                            Это как матёрому jsеру подойти и начать рассказывать что есть оператор with(Bagor){...}
                                                            Ответить
                                                            • Магазинчик Бо
                                                              Ответить
                                                            • Use of the with statement is not recommended, as it may be the source of confusing bugs and compatibility issues.
                                                              Ответить
                                                            • Уже все померли кто знал про этот оператор
                                                              Ответить
                                                            • > борманда проинформируй

                                                              Анус себе проинформируй, пёс.

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

                                                              Есть же using, в котором можно указать что тебе конкретно нужно из std.

                                                              Но проще писать std::vector и не париться. Тогда читателю сразу понятно, что это не твой самодельный вектор и не бустовый.
                                                              Ответить
                                                      • А вдруг он создаст класс ostream , и будет конфликт имен?
                                                        Ответить
                                                        • На самом деле после «using namespace std» к тебе в пространство имён проваливаются тысячи говна — без преувеличений. Что особенно смешно, эти тысячи говна ещё и недетерминированы: если на одном конпеляторе у тебя всё сработало заебись — это совсем не значит, что на другом конфликтов не будет. Реальный пример забыл, но, ЕМНИП, в «Visual Studio» тебе вместе с «<algorithm>» подключается и «<utility>», а в «gcc» — нет (или что-то в этом духе).

                                                          Вот тут чувак наглядно поясняет: https://stackoverflow.com/questions/1265039/using-std-namespace (хорошо сказал: «In fact, seeing a raw vector makes me wonder if this is the std::vector or a different user-defined vector»).
                                                          Ответить
                                                          • Какой багор ))) На самом деле и в одном компиляторе в разных версиях библиотеки разное количество говна проваливается.
                                                            Ответить
                                                          • А чем говно может помешать?
                                                            Ответить
                                                            • Временем компиляции, и случайными ненужными перегрузками, не?
                                                              Ответить
                                                              • > перегрузками
                                                                Реальный пример приведёшь? Можно вместо std свой namespace.
                                                                Ответить
                                                                • Не приведу, я всерьез не крестячил, только для себя чото мелкое.

                                                                  Ну а что мне мешает сделать функцию
                                                                  makaka(char c);

                                                                  а потом получить из std случайно
                                                                  makaka(int c);

                                                                  и потом много думать почему вдруг у меня две функции
                                                                  Ответить
                                                                  • А, ну тут да. Вообще, нехуй называть так же функции, как в std. Но я согласен, что using namespace std лучше не писать (в .h файлах вообще никакой using namespace не писать), просто сообщил, вдруг gost не знал. А то в его тестовом примере ехал «std::» через «std::», сунул «std::» в «std::»...
                                                                    Ответить
                                                                    • Зачем вообще вы дерейнули мой форс перла?
                                                                      Ответить
                                                                    • Ну это ты, конечно, сглупил.
                                                                      Ответить
                                                                    • > нехуй называть так же функции, как в std

                                                                      А ты их все знаешь? И какие через 5-10 лет добавят тоже заранее предсказать можешь?
                                                                      Ответить
                                                                      • Если добавят одноимённые функции, мы к нашим добавим знак подчёркивания с помощью search/replace.
                                                                        Ответить
                                                                      • У нас, например, кодстайл такой, что он не совпадает с стд.
                                                                        А вообще, вы блядь сарказма не понимаете?
                                                                        Ответить
                                                            • По ссылке реальный пример же.
                                                              #include <algorithm>
                                                              using namespace std;
                                                              
                                                              int count = 0;
                                                              
                                                              int increment()
                                                              {
                                                                  return ++count; // error, identifier count is ambiguous
                                                              }

                                                              Ну и Макака с перегрузками багор привёл.
                                                              Ответить
                                                      • >Вдруг ты не знал, можно писать using namespace std

                                                        Лучше Борманду это расскажи. Он стопудов не в курсе.
                                                        Ответить
                                          • >Йода-стайл — это борьба с последствиями, а не причиной

                                            Само собой не от хорошей жизни.
                                            А вообще
                                            1. Нужно по дефолту объявлять всё константами, а не переменными.
                                            2. Питухи сделали правильно, но сайд-эффектное присваивание в 90% случаев не нужно
                                            3. Неявная конвертация в bool — зло. Потому я за явный if (nullptr != ptr)
                                            https://govnokod.ru/26754#comment555015
                                            Ответить
                                        • > Именно поэтому я постоянно пишу константу спереди

                                          Пацаны, это полная хуета и парадокс блять.

                                          Сособенно то что питух ниже предлагает со сравнением 0 == a - b

                                          Смарити:
                                          Почему происходит очепятка = вместо ==? Нет привычки, недоглядел, лаганула клава, комар сел на нос в это время, недавно писал на другом языке и так далее.

                                          Так сука, если у тебя блять есть достаточно оперативки и внимания, чтобы не забыть преобразовать условное выражение в такое, где константа слева или того хуже, ноль сравнивается с разностью — ТАК ПРОВЕРЬ ТЫ УЖЕ ГЛАЗАМИ БЛЯТЬ КАКОЙ ТАМ У ТЕБЯ ОПЕРАТОР И ОТЪЕБИСЬ.

                                          Кто-то ответит: ну, я уже привык писать константу слева, так что это не требует внимания.

                                          Ну так а хули ты привык к такому сложному действию, а не смог привыкнуть чекать оператор сравнения?

                                          Хуета полная.

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

                                          0 == a - b — это говнокод, имхо. Это то же самое, что в русском языке инверсировать порядок слов на уёбищный и трудночитаемый, лишь бы избежать ситуации, где тебе понадобится запятая (sic!) чтобы случайно не забыть её поставить.

                                          Это парадокс. Как можно случайно не забыть сделать столько действий, которые нужны чтобы случайно не забыть сделать гораздо меньшее?
                                          Ответить
                                          • Да йода стайл давно устарел уже. Конпеляторы ворнингуют на типичных кейсах, когда ты = и == перепутал.
                                            Ответить
                                          • Парадоксов много. Например, парадоксом являются мнемоники: чтобы запомнить что-то простое, человек строит мостики ассоциаций с более сложными объектами и запоминает эти мостики и эти объекты.

                                            https://ru.wikipedia.org/wiki/Мнемоника

                                            В результате мозг оказывается забитым бессмысленной питушнёй вроде «Один бритый англичанин финики грызёт как морковку».
                                            Ответить
                                    • >Сначала тридцать лет тебе рассказывают, что си -- говно, потому что там присвоение это выражение, возвращающее значение, а потом хуяк

                                      Ага. Я вроде этот позор даже отдельным постом выносил.
                                      Ответить
                                  • >вместо нормального замыкания (или хотя бы анонимной функции) — одно выражение-огрызок

                                    Какая дрянь )))
                                    Ответить

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