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

    +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
    void printParser(const wchar_t *fileName, const wchar_t *str, boolean showLineCharPos)
    {
        ts::Parser parser;
        auto sourceFile = parser.parseSourceFile(fileName, str, ScriptTarget::Latest);
    
        ts::FuncT<> visitNode;
        ts::ArrayFuncT<> visitArray;
    
        auto intent = 0;
    
        visitNode = [&](ts::Node child) -> ts::Node {
    
            for (auto i = 0; i < intent; i++)
            {
                std::cout << "\t";
            }
    
            std::cout << "Node: " << wtoc(parser.syntaxKindString(child).c_str()) << " @ [ " << child->pos << " - " << child->_end << " ]" << std::endl;
    
            intent++;
            ts::forEachChild(child, visitNode, visitArray);    
            intent--;
    
            return undefined;
        };
    
        visitArray = [&](ts::NodeArray<ts::Node> array) -> ts::Node {
            for (auto node : array)
            {
                visitNode(node);
            }
    
            return undefined;
        };
    
        auto result = ts::forEachChild(sourceFile.as<ts::Node>(), visitNode, visitArray);
    }

    спортировал TypeScript парсер в C++ и ахренел от обьема работы :)

    ASD_77, 06 Апреля 2021

    Комментарии (188)
  2. C++ / Говнокод #27326

    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
    98. 98
    99. 99
    class MyString
    {
    public:
    	MyString(const char* str)
    	{
    		symbol = strlen(str);
    		this->str = new char[symbol + 1];
    		for (int i = 0; i < symbol; i++)
    		{
    			this->str[i] = str[i];
    		}
    		this->str[symbol] = '\0';
    	}
    	int Size()
    	{
    		return symbol;
    	}
    	MyString()
    	{
    		str = nullptr;
    		symbol = 0;
    	}
    	~MyString()
    	{
    		delete[] str;
    	}
    	MyString(const MyString& objct)
    	{
    		symbol = strlen(objct.str);
    		this->str = new char[symbol + 1];
    		for (int i = 0; i < symbol; i++)
    		{
    			this->str[i] = objct.str[i];
    		}
    		this->str[symbol] = '\0';
    	}
    	MyString operator ()(const char* objct)
    	{
    		if (this->str != nullptr)
    		{
    			delete[] this->str;
    		}
    		symbol = strlen(objct);
    		this->str = new char[symbol + 1];
    		for (int i = 0; i < symbol; i++)
    		{
    			this->str[i] = objct[i];
    		}
    		this->str[symbol] = '\0';
    		return *this;
    	}
    	MyString& operator =(MyString& objct)
    	{
    		if (this->str != nullptr)
    		{
    			delete[] str;
    		}
    		symbol = strlen(objct.str);
    		this->str = new char[symbol + 1];
    		for (int i = 0; i < symbol; i++)
    		{
    			this->str[i] = objct.str[i];
    		}
    		this->str[symbol] = '\0';
    		return *this;
    	}
    	MyString operator +(MyString& objct)//конкатенация строк
    	{
    		MyString NEWString;
    		symbol = strlen(this->str);
    		Ssymbol = strlen(objct.str);
    		NEWString.str = new char[symbol + Ssymbol + 1];
    		int i = 0;
    		NEWString.symbol = symbol + Ssymbol;
    		for (; i < symbol; i++)
    		{
    			NEWString.str[i] = this->str[i];
    		}
    		for (int j = 0; j < Ssymbol; j++, i++)
    		{
    			NEWString.str[i] = objct.str[j];
    		}
    		NEWString.str[symbol + Ssymbol] = '\0';
    		return NEWString;
    	}
    	//перегруженные операторы........
     int main()
    {
    	MyString asd = "Go";
    	MyString aa = "God";
    	if (asd >= aa)
    	{
    		cout << "Первая переменная больше по символам чем вторая." << endl;
    	}
    	else
    	{
    		cout << "Первая переменная меньше по символам чем вторая." << endl;
    	}
    }

    Свой класс строк. Что можно поправить для лучшей оптимизации?

    1337, 28 Марта 2021

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

    +1

    1. 1
    pubimbue, ate и ios

    давайте ржать над крестостримами

    booratihno, 25 Марта 2021

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

    +2

    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
    98. 98
    #include <array>
    #include <iostream>
    #include <string_view>
    #include <type_traits>
    
    std::string_view getMaxMargin();
    
    template<int bit_num>
    struct flag {
        friend constexpr int adl_flag(flag<bit_num>);
    };
    
    template<int bit_num>
    struct writer {
        friend constexpr int adl_flag(flag<bit_num>)
        {
            return bit_num;
        }
    
        static constexpr int value = bit_num;
    };
    
    template<int bit_num, int = adl_flag(flag<bit_num>{})>
    constexpr bool is_flag_set(int, flag<bit_num>)
    {
        return bit_num >= 0;
    }
    
    template<int bit_num>
    constexpr bool is_flag_set(float, flag<bit_num>)
    {
        return false;
    }
    
    template<size_t number, size_t bit_num>
    constexpr bool get_bit()
    {
        return (number & (1 << bit_num)) != 0;
    }
    
    #define flags_to_size()                     \
         ((is_flag_set<0>(0, flag<0>{}) << 0)   \
        | (is_flag_set<1>(0, flag<1>{}) << 1)   \
        | (is_flag_set<2>(0, flag<2>{}) << 2)   \
        | (is_flag_set<3>(0, flag<3>{}) << 3))
    
    template<bool test, typename T_true, typename T_false>
    struct meta_if {
        using type = T_true;
    };
    
    template<typename T_true, typename T_false>
    struct meta_if<false, T_true, T_false> {
        using type = T_false;
    };
    
    template<bool test, typename T_true, typename T_false>
    using meta_if_t = typename meta_if<test, T_true, T_false>::type;
    
    template<
        size_t desired_size,
        int = (0 +
               sizeof(meta_if_t<get_bit<desired_size, 0>(), writer<0>, int>) +
               sizeof(meta_if_t<get_bit<desired_size, 1>(), writer<1>, int>) +
               sizeof(meta_if_t<get_bit<desired_size, 2>(), writer<2>, int>) +
               sizeof(meta_if_t<get_bit<desired_size, 3>(), writer<3>, int>)
        )
    >
    constexpr size_t f()
    {
        return desired_size;
    }
    
    int main()
    {
        constexpr size_t a = f<1>();
        constexpr size_t b = f<6>();
        std::cout << "Max margin size: " << getMaxMargin().size() << std::endl;
    }
    
    constexpr size_t MARGIN_SIZE = flags_to_size();
    constexpr char MARGIN_CHAR = 'x';
    
    template<typename T, T... Args>
    constexpr auto getMarginStorageImpl(std::integer_sequence<T, Args...>)
    {
        return std::array<char, sizeof...(Args)>{(static_cast<void>(Args), MARGIN_CHAR)...};
    }
    constexpr auto getMarginStorage()
    {
        return getMarginStorageImpl(std::make_integer_sequence<int, MARGIN_SIZE>());
    }
    constexpr static auto marginStorage = getMarginStorage();;
    
    std::string_view getMaxMargin()
    {
        return std::string_view(marginStorage.data(), MARGIN_SIZE);
    }

    "Интересно, можно ли насфиначить такой шаблон, чтобы в пределах TU сгенерированные литералы были слайсами одного статического массива, длина которого выводилась бы автоматически."

    PolinaAksenova, 25 Марта 2021

    Комментарии (8)
  5. 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)
  6. 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)
  7. 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)
  8. 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)
  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)