1. Куча / Говнокод #27314

    +1

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    # PowerShell
    
    switch ($true)
    {
        ($firstNumber -gt $secondNumber) {Write-Output ("{0} > {1}" -F $firstNumber, $secondNumber)}
        ($firstNumber -eq $secondNumber) {Write-Output ("{0} == {1}" -F $firstNumber, $secondNumber)}
        ($firstNumber -lt $secondNumber) {Write-Output ("{0} < {1}" -F $firstNumber, $secondNumber)}
    }

    Интересный такой свитч-кейс (https://stackoverflow.com/questions/57063932/powershell-overriding-assignment-and-comparison-operators)

    groser, 24 Марта 2021

    Комментарии (5)
  2. Java / Говнокод #27313

    +5

    1. 1
    2. 2
    3. 3
    private static String getMargin(final int size) {
            return "                                                                                                                             ".substring(0, 6 * size);
        }

    Как создать пустую строку с заданной длиной...

    nekkiy, 24 Марта 2021

    Комментарии (31)
  3. C++ / Говнокод #27312

    +1

    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
    37. 37
    38. 38
    39. 39
    #include <iostream>
    
    template<typename T>
    struct CrtpBase {
        static float base_func()
        {
            std::cout << "CrtpBase::base_func(), " << typeid(T).name() << "::int_field == "
                << T::int_field << std::endl;
            return 16.0f;
        }
    
        static inline float x = base_func();
    };
    
    struct A: public CrtpBase<A> {
        void func_a()
        {
            base_func();
        }
    
        static inline int int_field = 16;
    };
    
    struct B : public CrtpBase<B> {
        void func_b()
        {
            std::cout << "B::func_b(), no CrtpBase<B>::base_func() call" << std::endl;
        }
    };
    
    
    int main()
    {
        A a;
        a.func_a();
    
        B b;
        b.func_b();
    }

    [temp.inst]/2:
    Unless a class template specialization is a declared specialization,
    the class template specialization is implicitly instantiated when
    the specialization is referenced in a context that requires a
    completely-defined object type or when the completeness of the
    class type affects the semantics of the program.

    [temp.inst]/3:
    The implicit instantiation of a class template specialization causes
    (3.1) -- the implicit instantiation of the declarations, but not of the definitions, of
    the non-deleted class member functions, member classes, scoped member enumerations,
    static data members, member templates, and friends; and
    (3.2) -- the implicit instantiation of the definitions of deleted member functions,
    unscoped member enumerations, and member anonymous unions.

    [temp.inst]/4:
    Unless a member of a templated class is a declared specialization, the specialization
    of the member is implicitly instantiated when the specialization is referenced in a
    context that requires the member definition to exist or if the existence of the definition
    of the member affects the semantics of the program; in particular, the initialization
    (and any associated side effects) of a static data member does not occur unless the
    static data member is itself used in a way that requires the definition of the static
    data member to exist.


    Таким образом, по стандарту CrtpBase<B>::x не должен быть инициализирован, поскольку он нигде не used in a way that requires the definition of the static data member to exist. Правильные компиляторы (gcc и clang) это понимают и компилируют код, а вот Visual Studio зачем-то пытается инициализировать CrtpBase<B>::x и нон-конформно ломается.

    PolinaAksenova, 24 Марта 2021

    Комментарии (179)
  4. C++ / Говнокод #27311

    +3

    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
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    // A registrator class.
    // To register a Parents <- Child relation user must derive their type from
    // the correct specialization of this class
    template<typename Child, typename... Parents>
    struct registrator {
    private:
        // The registerRelation() function would be called during dynamic initialization of this
        // static storage duration variable.
        static volatile inline detail::registratorType _registrator
            = RelationManager::registerRelation<Child, Parents...>();
    
    protected:
        /*
        [basic.start.dynamic]/6:
            It is implementation-defined whether the dynamic initialization of a non-block inline variable
            with static storage duration is sequenced before the first statement of main or is deferred.
            If it is deferred, it strongly happens before any non-initialization odr-use of that variable.
        [basic.start.dynamic]/4:
            A non-initialization odr-use is an odr-use ([basic.def.odr]) not caused directly or indirectly
            by the initialization of a non-block static or thread storage duration variable.
        By odr-using the _registrator here we are making sure that any Child constructor is odr-using it as well,
        thus guaranteeing that the compiler would call registerRelation() strongly before the Child constructor
        */
        constexpr registrator() noexcept
        {
            // Taking an address of a variable, even in a discarded statement, is an odr-use
            (void)&_registrator;
        }
    
    private:
        /*
        If registrator() constructor is never 'non-initialization odr-used'
        (no Child objects are created besides non-local static ones), then the only
        instantiation of the registrator class is an implicit instantiation caused by deriving Child;
    
        [temp.inst]/3:
            The implicit instantiation of a class template specialization causes
            (3.1) -- the implicit instantiation of the declarations, but not of the definitions, of
                the non-deleted class member functions, member classes, scoped member enumerations,
                static data members, member templates, and friends; and
            (3.2) -- the implicit instantiation of the definitions of deleted member functions,
                unscoped member enumerations, and member anonymous unions.
    
        [basic.def.odr]/8:
            [...] A constructor for a class is odr-used as specified in [dcl.init].
        (In other words, "A constructor (including default constructors) for a class
         is odr-used by the initialization that selects it.")
    
        The problem is that if there is no Child() constructor calls, then the compiler is not required to
        even DEFINE our registrator() constructor, and since there is only one odr-use of the static inline
        variable _registrator, the compiler is not required to generate a definition for it as well. And since
        it is not generating a definition, the initialization is also not generated.
    
        But [temp.inst]/3.2 requires that any implicit instantiation of a class template also
        causes the DEFINITION instantiation of an unscoped member enumerations. Next,
        [dcl.spec.auto.general]/12:
            Return type deduction for a templated entity that is a function or function template
            with a placeholder in its declared type occurs when the definition is instantiated
            even if the function body contains a return statement with a non-type-dependent operand
        Thus, using sizeof(*_force_registrator_instantiation()) causes the implicit instantiation
        of definition of _force_registrator_instantiation(), and since this function is odr-using _registrator,
        its definition (and initialization) is also generated.
    
        The only problem is that by [basic.start.dynamic]/6 the implementation MAY defer the dynamic
        initialization of _registrator to the point where it is 'non-initialization odr-used', and since without
        the Child() constructor call we don't have any way to non-initialization odr-use it, we also have no way to
        make sure that the compiler invokes registerRelation() before main() or before any other point of execution.
        The good news, though, is that all three modern compilers obediently initializes _registrator before the first
        statement of main().
        */
        static auto _force_registrator_instantiation()
        {
            return &_registrator;
        }
    
        enum {
            _ROTARTSIGER_ETAITNATSNI = sizeof(*_force_registrator_instantiation()),
        };
    };

    PolinaAksenova, 23 Марта 2021

    Комментарии (51)
  5. JavaScript / Говнокод #27310

    0

    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
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    97. 97
    $(".reg_button").on("click", function(){
        console.log("hello world jquery");
        $(".main").css("display", "none");
        $(".register-main").css("display", "block");
        $(`input[type="text"]`).css("width", "14vw");
        $(`input[type="password"]`).css("width", "14vw");
        $(`input[type="email"]`).css("width", "14vw");
         // Обработка нажатия на кнопку регистрации
    });
    const recovery = {
      login: "",
      email: "",
    }
    const regExp = {
      login: /^[a-z0-9_-]{5,20}$/,
      pass: /^[A-Za-z0-9_-]{6,16}$/,
      email: /^[A-Z0-9._%+-][email protected][A-Z0-9-]+.+.[A-Z]{2,4}$/i,
    }
    const state = {
      reg: {
        login: "",
        pass: "",
        email: "",
        agreement: ""
      },
      auth: {
        login: "",
        pass: "",
        agreement: false
      }
      }
    $(".back").on("click", function() {
        $(".register-main").css("display", "none");
        $(".main").css("display", "flex");
        $(`input[type="text"]`).css("width", "21.5vw");
        $(`input[type="password"]`).css("width", "21.5vw");
        // Обработка нажатия на кнопку "Назад"
    });
    $(".auth_forgotPassword").on("click", function() {
      console.log("Система восстановления пароля в разработке.")
     /* $(".main").css("display", "none");
      $(".recovery").css("display", "block");
      $(".recovery-step-one").css("display", "block");
      $(`input[type="text"]`).css("width", "14vw");
      $(`input[type="password"]`).css("width", "14vw"); */
    })
    $(".recovery-back").on("click", function() {
      $(".recovery").css("display", "none");
      $(".recovery-step-one").css("display", "none");  
      $(".main").css("display", "flex");                 // кнопка назад, в восстановления пароля.
      $(`input[type="text"]`).css("width", "21.5vw");
      $(`input[type="password"]`).css("width", "21.5vw");
    })
    $(".recovery-back2").on("click", function() {
      $(".recovery-step-two").css("display", "none");
      $(".recovery").css("display", "block");     
      $(".recovery-step-one").css("display", "block");                  // кнопка назад, в восстановления пароля.
      $(`input[type="text"]`).css("width", "14vw");
      $(`input[type="password"]`).css("width", "14vw");
    })
    // $(".recovery-button").on("click", function() {
      /*recovery.login = $(".step_login").val()
      recovery.email = $(".step_email").val()
      alt.emit("click:recovery")
      if(recovery.login == "" || recovery.email == "" )
      {
        console.log("Необходимые поля пустые!")
      }
      else {
      alt.on("recovery-step-two", (args) => {
      if(args == true) {
        $(".recovery-step-one").css("display", "none");
        $(".recovery-step-two").css("display", "block");
      }
      else {
        console.log("Введены неверные данные или аккаунта с такой почтой не существует.")
      }
      })
      }
      */
    // })
    $(".recovery_button2").on("click", function() {
      $(".recovery-step-two").css("display", "none");
      $(".recovery-step-three").css("display", "block");
    })
    $('.button-wrap').on("click", function(){
      $(this).toggleClass('button-active');
      if ($(this).hasClass('button-active')) {
        localStorage.checkbox = 1
        
      } else {
        localStorage.checkbox = 0
      }
      console.log(localStorage.checkbox)
    });
    $(".confirm-back2").on("click", () => {
      $(".authentication").css("display", "none");

    Логика работы меню авторизации :)
    Собственно первая моя верстка была, как и использование jquery)

    Seagate, 22 Марта 2021

    Комментарии (5)
  6. C++ / Говнокод #27309

    +3

    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
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    template<typename T>
    struct [[nodiscard]] InplacePointerGuard {
        InplacePointerGuard(T *& ptr_) : ptr(ptr_) {}
        ~InplacePointerGuard()
        {
            if (ptr != nullptr) {
                ptr->~T();
            }
        }
    
        T *& ptr;
    };
    
    template<typename EventType, typename... Args>
    bool publishEmplace(Args &&... args) const
    {
        static_assert((std::is_base_of_v<Event, EventType> && std::is_convertible_v<const EventType *, const Event *>),
                      "EventType must be a public subtype of Event");
        auto typeIdx = Event::getStaticIndex<EventType>();
    
        std::aligned_storage_t<sizeof(EventType), alignof(EventType)> eventStorage;
        EventType *eventConstructed = nullptr;
        auto guard = InplacePointerGuard(eventConstructed);
    
        publishEmplaceImpl<EventType>(typeIdx, eventStorage, eventConstructed, std::forward<Args>(args)...);
    
        return eventConstructed != nullptr;
    }
    
    template<typename EventType, typename... Args>
    static EventType *constructEvent(std::aligned_storage_t<sizeof(EventType), alignof(EventType)> & eventStorage,
                                     Args &&... args)
    {
        return std::launder(new(&eventStorage) EventType(std::forward<Args>(args)...));
    }
    
    template<typename EventType, typename... Args>
    void publishEmplaceImpl(const std::type_index & typeIdx,
                            std::aligned_storage_t<sizeof(EventType), alignof(EventType)> & eventStorage,
                            EventType *& eventConstructed,
                            Args &&... args) const
    {
        if (auto it = callbacks.find(typeIdx); it != callbacks.end()) {
            for (const auto & [subId, callback] : it->second) {
                if (!eventConstructed) {
                    eventConstructed = constructEvent<EventType>(eventStorage, std::forward<Args>(args)...);
                }
                callback(*eventConstructed);
            }
        }
    
        auto range = EventsRelation::RelationManager::getParentsRange(typeIdx);
        for (auto it = range.first; it != range.second; ++it) {
            if (!eventConstructed) {
                publishEmplaceImpl<EventType>(it->second, eventStorage, eventConstructed, std::forward<Args>(args)...);
            } else {
                publishImpl(it->second, *eventConstructed);
            }
        }
    }

    PolinaAksenova, 22 Марта 2021

    Комментарии (66)
  7. C++ / Говнокод #27307

    +1

    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
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    namespace detail {
        template<entity_event_t Event>
        struct EventHasEntityStateConstructor {
            // Sanity check
            static_assert(static_cast<int32_t>(Event) >= 0
                          && static_cast<int32_t>(Event) < ENTITY_EVENTS_COUNT);
    
        private:
            struct TwoChar {
                char a, b;
            };
    
            template<typename T>
            constexpr static TwoChar _check(
                decltype(
                    T(std::declval<const entityState_t &>())
                )*
            );
    
            template<typename T>
            constexpr static char _check(...);
    
        public:
            constexpr inline static bool value = (sizeof(_check<EntityEvent<Event>>(nullptr)) == sizeof(TwoChar));
        };
    
        template<typename BusT, entity_event_t Event>
        bool defaultEntityEventPublisher(const BusT & bus, const entityState_t & eventEntity)
        {
            static_assert(EventHasEntityStateConstructor<Event>::value,
                          "defaultEntityEventFactory<Event>() instantiated for a custom\n"
                          "event that does not have a (const entityState_t & eventEntity) constructor.\n"
                          "This should not happen (you'll get a more obscured compiler error anyway)!");
            return bus.publishEmplace<EntityEvent<Event>>(eventEntity);
        }
    
        template<typename BusT, typename T, T... Is>
        constexpr std::array<EntityEventPublisherPtr<BusT>, sizeof...(Is)>
            createDefaultEntityEventFactories(std::integer_sequence<T, Is...>)
        {
            return {
                [](auto i) -> EntityEventPublisherPtr<BusT> {
                    if constexpr (EventHasEntityStateConstructor<static_cast<entity_event_t>(i.value)>::value) {
                        return &defaultEntityEventPublisher<BusT, static_cast<entity_event_t>(i.value)>;
                    } else {
                        return nullptr;
                    }
                }(std::integral_constant<T, Is>{})...
            };
        }
    }
    
    // An (event_number -> EntityState<event_number> 'publishing factory' function) mapping;
    // if event N could not be constructed from a single entityState_t reference
    // then this table would contain nullptr at the index N
    template<typename BusT>
    const std::array<EntityEventPublisherPtr<BusT>, ENTITY_EVENTS_COUNT> & getDefaultEntityEventsPublishers() noexcept
    {
        static auto factories = detail::createDefaultEntityEventFactories<BusT>(std::make_integer_sequence<int32_t, ENTITY_EVENTS_COUNT>());
        return factories;
    }
    
    template<typename BusT>
    EntityEventPublisherPtr<BusT> tryGetDefaultEntityEventPublisher(entity_event_t event) noexcept
    {
        auto eventNum = static_cast<int32_t>(event);
        if (eventNum >= 0 && eventNum < ENTITY_EVENTS_COUNT) {
            return getDefaultEntityEventsPublishers<BusT>()[eventNum];
        } else {
            return nullptr;
        }
    }

    PolinaAksenova, 21 Марта 2021

    Комментарии (10)
  8. Java / Говнокод #27306

    +1

    1. 1
    Class HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor

    https://javadoc.io/doc/org.aspectj/aspectjweaver/1.8.10/org/aspectj/weaver/patterns/HasThisTypePatternTriedToSneakInSomeGene ricOrParameterizedTypePatternMatchingStu ffAnywhereVisitor.html

    6oHo6o, 21 Марта 2021

    Комментарии (23)
  9. C++ / Говнокод #27305

    −1

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    9. 9
    enum class NodeFlags : int {
        None               = 0,
        Let                = 1 << 0,
    // ...
    }
    
    contextFlags &= ~flag;
    
    // error C2675: unary '~': 'NodeFlags' does not define this operator or a conversion to a type acceptable to the predefined operator

    Кому нужны такие гавно-компиляторы? которые даже не в состоянии привети четко прописанные типы?

    ASD_77, 20 Марта 2021

    Комментарии (29)
  10. C++ / Говнокод #27303

    0

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    9. 9
    metrics_key::metrics_key(std::initializer_list<std::string> const& il) {
      TRI_ASSERT(il.size() > 0);
      TRI_ASSERT(il.size() < 3);
      name = *il.begin();
      if (il.size() == 2) {
        labels = *(il.begin()+1);
      }
      _hash = std::hash<std::string>{}(name + labels);
    }

    просто гавно

    gnusmas, 18 Марта 2021

    Комментарии (36)