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

    +940.8

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    bool checkForExe(std::string ext)
    {
        return ext==".exe" ? true : 
                  ext==".Exe" ? true :
                  ext==".eXe" ? true :
                  ext==".EXe" ? true :
                  ext==".exE" ? true :
                  ext==".ExE" ? true :
                  ext==".eXE" ? true :
                  ext==".EXE" ? true : false;
    }

    Нашел в одной моей очень древней программе-шутке. Регистронезависимая проверка на расширение .exe.

    Запостил: frp, 29 Марта 2010

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

    • интересно, а что трудоёмче: такое вот невинное сравнение, или использование всяких локалей, копирования и то дэ?

      имхо, это может быть не быдлокод, а оптимизация...

      бенчмарки в студию!
      Ответить
      • показать все, что скрыто+ вроде бы для таких случаев (регистры) нет кросплатформенного решения... так что без контекста реально этот кусок имеет право жить... в с++ не разбираюсь (я не быдлокодер), поправьте, если не прав, вдруг какая-то библиотека встроенная есть? хз
        Ответить
        • > в с++ не разбираюсь (я не быдлокодер)
          Какая Вы, уважаемый гость, няшечка
          =3
          Ответить
        • ьлондинка
          Ответить
      • на хрена локали? таблицу аски видал?
        Z от z находится на смещении, равном 0х20, как и вся латиница собственно, и от локали это не зависит... намного быстрей будет по кодам пробить, чем строки сравнивать.
        Ответить
        • ну я имел в виду lowerCase вообще любого символа, а не только us-ascii
          Ответить
        • вы ведь шутите, да? :'(
          Ответить
      • Нет, этот код даст только проигрыш в производительности. Перевод в другой регистр - один проход, и сравнивание - тоже один проход. В результате 2 прохода. А приведенный выше код делает от 1 до 8 проходов (по проходу на каждое сравнивание).
        Ответить
        • проход - это громко сказано.
          если убрать из сравнения ненужную точку, то смори как будет:

          1. в варианте, на который все думают, в стеке делаем строку, копируем в неё содержимое принятой, изменяем смещения каждого символа и сравниваем, так? итого - 3 операции копирования (на каждый символ) и 3 операции сравнения (максимум - может и сразу failнуть на первом), т.е. от 4 до 6 операций.

          2. в случае сего говнокода имеем такой расклад: копирования нет, а есть только сравнения. В 99% случаев расширение стоит в lower case, поэтому сработает только первое условие, а это 3 операции )))

          т.е. сей говнокод в 99% случаев выгоднее правильнее кода. правильный код - правильный, но будет тормознее в 99% случаев.

          и где здесь проигрыш?))
          Ответить
          • ой, я для первого случая ещё забыл операции приведения к общему регистру, ну ты понял.
            Ответить
            • просто не очень понятно, считать ли их отдельными операциями, или частью операции "копирования". но это издержки.

              пойду-ка дальше дышать бензином
              Ответить
              • опа, под операциями я имел в виду statements.

                почитал в вику, оказхывается в русском языке такая убогая терминология=\
                Ответить
          • показать все, что скрытоя мама твой ебал, в случае фейла будут всё равно проверки дальше! (frp)

            твой мама тапкой толстый
            Ответить
          • Нужно было так сделать, тк это быстрее по статистике:
            return ext==".exe" ? true :
            ext==".EXE" ? true :
            ext==".Exe" ? true :
            ext==".eXe" ? true :
            ext==".EXe" ? true :
            ext==".exE" ? true :
            ext==".ExE" ? true :
            ext==".eXE" ? true : false;
            Ответить
            • Ага. Рассортируем по частоте появления вариантов. :p
              Ответить
          • ну хотя бы потому что можно было бы написать хотя бы вот так:
            ext == ".exe" || ext == ".Exe" || ext == ".eXe"...
            Ответить
    • показать все, что скрытоДа вы что? Это же сравнение адресов строк, а не самих строк. ;)
      Ответить
      • ну тады равенства никогда не будет!
        Ответить
        • эээм... а про STL слышали???
          Ответить
        • В любом случае равенство иногда случается. ;)
          Ответить
      • Читать доки по STL. std::string можно сравнивать используя оператор ==
        Ответить
        • А ничего что для этого сначала создается объект типа std:string и сравнение происходит 8 раз?
          Вместо одного
          http://www.govnokod.ru/2892#comment19499
          Ответить
        • в доках по STL ничего про строки нету. Строки не имеют никакого отношения к STL, зайдитите на педивики и посмотрите, для начала, что такое STL и чем она отличается от C++ Standard Library.
          Ответить
          • что за хрень ты тут написал
            Ответить
            • std::string не имеет отношения к STL, читая документацию по STL, ты ничего не узнаешь о перегрузках логических операторов для строк. Повторить по слогам?
              Ответить
    • Нормально, это всего-то бинарные размещения, тут получается всего 8 комбинаций, для 4-х символов - 16.
      А был-бы тут хотя-бы факториал..
      Ответить
      • Кстати, для именно этого случая факториал быстрее (если сравнивать худший случай) - 3! = 6, а 2^3 = 8. Хотя как это сделать за факториал плохо представляю.
        Ответить
    • http://ithappens.ru/story/2666
      прозреваю заговор и прочую хуйню
      Ответить
    • bool checkForExe(std::string ext)
      {
      return ext==".exe" || ext==".Exe" || ext==".eXe" || ext==".EXe" || ext==".exE" || ext==".ExE" ||
      ext==".eXE" || ext==".EXE";
      }
      Ответить
    • А еще говорят: "РНР -- говно".
      Ответить
    • ext не по ссылке на константу, сцуко!
      Ответить
    • Вы что, все на приколе? Каки бенчмарки для подобного? Какое распределение по частоте встречания? Вы микроконтроллеры прошиваете? Тогда откуда std::string?

      //C style
      return !stricmp(".exe",ext.c_str());
      Ответить
    • Это типичный булщит.
      Делаем так:
      return ext==".exe" || ext==".Exe" || ext==".eXe" || ext==".EXe" || ext==".exE" || ext==".ExE" ||
      ext==".eXE" || ext==".EXE";
      Ответить
    • const std::string& ext
      Ответить

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