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

    0

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        cout << "is_same_v: " << std::is_same_v<int, const int> << endl;
    }

    https://en.cppreference.com/w/cpp/types/is_same

    > If T and U name the same type (taking into account const/volatile qualifications), provides the member constant value equal to true. Otherwise value is false.

    Запостил: OlegUP, 17 Августа 2020

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

    • В стандартной библиотеке C++17 есть объявление:
      template< class T, class U >
      inline constexpr bool is_same_v = is_same<T, U>::value;


      Модификация для C++11:
      https://ideone.com/dbKiDf

      int и const int с точки зрения std::is_same — разные типы.

      Особенно интересно, что char — это и не signed char, и не unsigned char.
      Ответить
      • > В стандартной библиотеке C++17 есть объявление:
        Это потому, что template variables до «C++17» (или 14, не помню) не было. Когда завезли — все подобные метафункции перевели на суффикс «_v».

        > int и const int с точки зрения std::is_same — разные типы.
        Ну да, это логично. Будет странно, если ты сделаешь проверку «std::is_same_v<T, int>», а потом попробуешь что-нибудь записать в переменную типа T.
        Если нужно сравнить «базовые» типы — нужно просто сделать «std::remove_cv_t» на оба аргумента «std::is_same_v» (да, суффикс «_t» тоже появился из-за того, что в старых крестах не было охуительного «using T = type»). Можно даже «std::remove_reference_t» добавить, если хочется совсем-совсем базовый тип сравнить.

        > Особенно интересно, что char — это и не signed char, и не unsigned char.
        Ага, это мы где-то в начале года обсуждали, даже нашли, где в Стандарте такое прописано.
        Ответить
        • Блядь, как всё сложно. Именно поэтому я за «PHP».
          Ответить
        • > это логично
          - я бы сказал, что это не логично, но разумно
          Ответить
          • А почему не логично?
            Ответить
            • Ну нет всё же такого типа const int, это ж модификатор пельменной.
              Или в крестах это именно тип?
              Ответить
              • Ну да, const — это модификатор типа, а const int — это тип. Точно так же (ну, строго говоря, не точно, ну да ладно, похуй), как, например, «unsigned int» или «int *».
                Ответить
                • Ебалась курочка в борще!

                  Спасибо.
                  Ответить
                  • Евпатий Коловратий
                    Ответить
                  • Пожалуйста.

                    P. S. Итого, у произвольного типа могут быть модификаторы (в общем смысле) const, volatile, & и &&. Получаем 16 кобенаций. А ведь ещё есть у-ко-ко-козатель, но он не ортогонален ссылкам. Зато константный уко-ко-ко-козатель и уко-ко-ко-козатель на константу — это тоже разные вещи, как ниже Фунтик подсказывает!
                    Ответить
                    • >Зато константный уко-ко-ко-козатель и уко-ко-ко-козатель на константу

                      вечно не могу правильно прочитать длинные декларации, путаюсь, к чему относится const. Приходится вспомнить правило
                      Ответить
              • В крестах это именно тип. Можно взять указатель на const int, и его нельзя путать с константной пельменной, указывающей на int.

                Вот это разные типы:
                (const int) * var1;
                int * const var2;
                Ответить
                • > Вот это разные типы:
                  Причём не просто разные, а означающие совершенно разные вещи. Первому указателю ты можешь поменять значение (var1 = 0x1234), но вот записать по нему (*var1 = 42) ничего нельзя (но если очень хочется он указывает на неконстантную пельменную, то const_cast'ом const можно отбросить и таки записать!). По второму указателю ты можешь спокойно записывать (*var2 = 42), но вот его адрес изменять нельзя (var2 = 0x1234).

                  Коньстантный уко-ко-козатель на коньстантные данные выглядит как «const int * const var3».
                  Ответить
                  • А все эти крестовые shared_ptr умеют бывать константными или не-константными?
                    Ответить
                    • shared_ptr — это просто обычная структурка, к ней применяются стандартные правила. Правда, я точно не помню, можно ли сделать shared_ptr<const int>, но скорее всего можно.
                      Ответить
        • > Ага, это мы где-то в начале года обсуждали, даже нашли, где в Стандарте такое прописано.
          Одно из обсуждений: https://govnokod.ru/26318#comment519640.
          Ответить
    • > the member constant value equal to true
      - не могу распарсить. Мембер чего?
      Ответить
      • Есть шаблонная структура «is_same», у неё есть статический член-константа «value» типа буль «bool». Так делались метафункции в старых крестах.
        Ответить
      • member — это прилагательное в данном случае. Свыняча мова, никаких суффиксов и окончаний, части речи различить невозможно.

        Членное константное значение эквивалентно истине.

        У меня два варианта, как это дальше облагородить:
        1. Значение членной константы — значение константы члена.
        2. Константное значение члена.

        Я окончательно запутался.
        Ответить
        • На https://ru.cppreference.com/w/cpp/types/is_same перевели так:
          Если T и U - это имя одного и того же типа с теми же cv-квалификаторами, то предоставляет
          константу-член value, которая будет равна true, если же T и U это разные типы (или одни и
          те же типы, но с разными cv-квалификаторами), то констатный член value будет равен false.
          Ответить

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