1. JavaScript / Говнокод #27809

    0

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    9. 9
    function s(v: any): v is string
    {
    	return typeof v === "string";
    }
    
    function main()
    {
    	print(s("sss"));
    }

    А ты так можешь на С/C++ .. а я могу....

    Запостил: ASD_77, 10 Ноября 2021

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

    • аха... где мои сообщения.. почему никто не пишет?
      Ответить
    • Да как нехуй делать.
      #include <iostream>
      #include <string>
      #include <any>
      
      void f(const std::any & v)
      {
          if (v.type() == typeid(std::string)) {
              std::cout << "string: " << std::any_cast<const std::string &>(v) << std::endl;
          } else {
              std::cout << "not a string" << std::endl;
          }
      }
      
      int main()
      {
          f(42);
          f(std::string("hello"));
      
          return EXIT_SUCCESS;
      }

      https://wandbox.org/permlink/L4SDEH8qBxpMzbrl
      Ответить
      • эникаст это такой тайпсейф каст как "as?"?

        типа можно маттерин патчинг запилить?
        Ответить
        • Если попытаешься не в тот тип скастовать — получишь эксепшеном по ебалу. Так что да, тайпсэйф.
          Ответить
          • Осталось его поймать, и вернуть nullptr


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

                эксепшен летит если там ссылка, а если указатель то как раз нул и будет?
                Ответить
                • Ну. Поэтому ссылка нужна когда ты уверен в типе, а указатель -- когда хочешь проверить.
                  Ответить
                  • Забавно, что жавка соснула у крестов 17 (или когда это там появилось?)

                    Там сначала проверяешл тип, потом кастишь
                    А вкотлине уже нет
                    Ответить
                    • В бусте это было с дедовских времён.
                      Ответить
                      • ну по идее-то тривиально пишеца

                        получаешь указатель, проверяешь typeid, и вот
                        Ответить
                    • if (const int* i = std::any_cast<int>(&x)) {
                          // это инт
                      }


                      Как-то так вроде это пишется. Ни разу не юзала, на самом деле, так что могу ошибиться...
                      Ответить
            • Можно ещё обработчик выбрать по мапе с type() в качестве ключа. Тогда это не будет так дико лагать как от линейного перебора вариантов.
              Ответить
              • а можно взять полиморфизм ))
                Ответить
                • С полиморфизмом думать надо. А тут можно кресты в "php" превратить если перегрузочек для "any" запилить.
                  Ответить
                  • А если вместо any взять variant, можно делать кошерные визиторы.
                    Ответить
                    • А они мапу умеют юзать для ускорения?
                      Ответить
                    • А как с variant сделать один колбек на два типа?

                      Получается, только выносить его в отдельную лямблию и передавать два раза?
                      Ответить
                      • struct pitux
                        {
                            void operator()(int x) { std::cout << "int\n"; }
                            void operator()(double x) { std::cout << "double\n"; }
                        }
                        
                        std::variant<int, double> foo;
                        
                        std::visit(pitux(), foo);


                        или воспользоваться шаблономагией:
                        template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
                        std::visit( overloaded {
                            [](int x)    { std::cout << "int: " << x*x << '\n';  },
                            [](double x) { std::cout << "double: " << -x << '\n'; },
                            [](bool x)   { std::cout << "bool:" << !b << '\n'; }
                        }, foo)


                        А, понял вопрос. не на то отвечал.
                        Можно с auto и if constexpr в лямбде.
                        [](auto x){
                            using T = decltype(arg);
                            if constexpr (std::is_same_v<T, int> or std::is_same_v<T, double> ) {
                                std::cout << "number\n"; 
                            else if constexpr (std::is_same_v<T, bool>) {
                                ... 
                            }
                        }
                        Ответить
                        • с auto и if constexpr можно и без лямбды)))
                          Ответить
                          • Если у тебя коллбек через коллбек и вариант где-то в недоступных кишках, то придётся через лямбду.
                            Ответить
            • Ну как, поймал?
              Ответить
    • Ого, RTTI для себя отрыли
      Ответить
      • это у С++ RTTI а у меня ничего такого нет
        Ответить
        • Вариант и хешмапа?
          Ответить
        • > у меня ничего такого нет
          > typeof v
          [X] Сомнение
          Ответить
          • В JS всегда есть RTTI, а в C++ вроде компилятор может выпилить, если ты не виртуальный например.
            Или это детали реализации, и с точки зрения программиста RTTI есть всегда?
            Ответить
            • > Или это детали реализации, и с точки зрения программиста RTTI есть всегда?
              (RT)TI в крестах бывает разный:
              1. dynamic_cast: работает для виртуальных объектов за счёт таскания с собой уко-ко-козателя на vtable;
              2. typeid(X), где X — ссылка/указатель на невротуальный объект: работает в компайлтайме и всегда возвращает информацию о статическом типе X;
              3. typeid(V), где V — ссылка/указатель на вротуальный объект: работает уже в рантайме за счёт проверки указателя на vtable.
              Возможно, ещё что-то я пропустил, но не суть.

              В общем и целом, рантайм-расходы на RTTI есть только для виртуальных объектов, которые таскают за собой таблицу вротуальных функций; для всех остальных typeid() разрешается в компайлтайме.
              Ответить
              • Забавно, что статическая (комплайл тайм) проверка всё равно называется RTTI.
                Но это же по сути оптимизация компилятора: он МОЖЕТ статически проверить тип, вот и проверяет, а название осталось

                В жавке все говно витуальное и такой оптимизации нет (хотя ее может JIT наверное)
                Ответить
                • На самом деле не называется, это просто термины путаются под ногами. Тут разве что проблема с тем, что и для рантайм проверки, и для статической используется один и тот же оператор — typeid.
                  Ответить
                  • Хм, а разве typeid можно юзать не в рантайме? Ты ведь даже не сможешь их сравнить в статике.

                    Вроде только какой-нибудь std::is_same можно...
                    Ответить
                  • Блядь как всё сложно

                    А бывает так, что компилятор не умеет в RTTI, и тогда typed взять у невиртуального питуха можно, а у виртуального (ну точнее у ссылки на нево) нельзя?
                    Ответить
                    • RTTI отключается всегда целиком, емнип. Никто его там не делит на "виртуальные" и "невиртуальные".

                      А когда включен, тупо линкер выбрасывает неиспользованное.
                      Ответить
                      • Было бы смешно если бы оператора было два разных
                        Ответить
                        • static_typeid, dynamic_typeid и reinterpret_typeid?
                          Ответить
                          • dynamic_const_cast. Снимает const с объекта либо возвращает nullptr если объект совсем-совсем константный.
                            Ответить
            • Это мой компилятор, а не JavaScript. потому я не пользуюсь RTTI (кроме exceptions)
              Ответить
    • В твоём гомне поддержаны argc, argv?
      Ответить

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