1. Список говнокодов пользователя j123123

    Всего: 335

  2. Куча / Говнокод #25208

    +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
    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
    ;;; the toplevel operators of each equation in the system
    ;;; type : array[term]
    (defmacro match-acz-state-methods (state__) `(svref ,state__ 0))
    
    ;;; functional terms
    ;;; type : array[term]
    (defmacro match-acz-state-lhs-f (state__) `(svref ,state__ 1))
    
    ;;; variables on the LHS
    ;;; type : array[term]
    (defmacro match-acz-state-lhs-v (state__) `(svref ,state__ 2))
    
    ;;; contants on the RHS
    ;;; type : array[term]
    (defmacro match-acz-state-rhs-c (state__) `(svref ,state__ 3))
    
    ;;; functional terms on RHS
    ;;; type : array[term]
    (defmacro match-acz-state-rhs-f (state__) `(svref ,state__ 4))
    
    ;;; notes repeated functional terms of LHS
    ;;; type : array[bool]
    (defmacro match-acz-state-lhs-f-r (state__) `(svref ,state__ 5))
    
    ;;; notes repeated variables of LHS
    ;;; type : array[bool]
    (defmacro match-acz-state-lhs-v-r (state__) `(svref ,state__ 6))
    
    ;;; notes repeated constants of RHS
    ;;; type : array[bool]
    (defmacro match-acz-state-rhs-c-r (state__) `(svref ,state__ 7))
    
    ;;; notes repreated funcational terms of RHS
    ;;; type : array[bool]
    (defmacro match-acz-state-rhs-f-r (state__) `(svref ,state__ 8))
    
    ;;; variables and funs acocunted for by RHS-c-sol
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-mask (state__)  `(svref ,state__ 9))
    
    ;;; funs accounted for by RHS-c-sol
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-f-mask (state__) `(svref ,state__ 10))
    
    ;;; bit vector of all repeated (> 0) terms on LHS
    (defmacro match-acz-state-lhs-r-mask (state__)  `(svref ,state__ 11))
    
    ;;; solution matrix for constants
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-c-sol (state__) `(svref ,state__ 12 ))
    
    ;;; max value of elements of RHS-C-sol
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-c-max (state__) `(svref ,state__ 13))
    
    ;;; solutions matrix; functional terms
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-f-sol (state__) `(svref ,state__ 14))
    
    ;;; max value of elements of RHS-f-sol
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-f-max (state__) `(svref ,state__ 15))
    
    ;;; type : fixnum 11111 ... 1111
    (defmacro match-acz-state-rhs-full-bits (state__) `(svref ,state__ 16))
    
    ;;; array of compatibility bitvectors; constants
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-c-compat (state__) `(svref ,state__ 17))
    
    ;;; array of compatibility bitvectors; funcs
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-f-compat (state__) `(svref ,state__ 18))
    
    ;;; number of constants on LHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-c-count (state__) `(svref ,state__ 19))
    
    ;;; number of functions on LHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-f-count (state__) `(svref ,state__ 20))
    
    ;;; number of variables on LHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-v-count (state__) `(svref ,state__ 21))
    
    ;;; number of constants on RHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-c-count (state__)  `(svref ,state__ 22))
    
    ;;; number of functions on RHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-f-count (state__) `(svref ,state__ 23))
    
    ;;; t iff all solutions have been reported.
    (defmacro match-acz-state-no-more (state__) `(svref ,state__ 24))

    https://github.com/CafeOBJ/cafeobj/blob/master/chaos/e-match/match-acz.lisp

    ГОМОИКОНЫ копипаст лиспе
    CafeOBJ is a most advanced formal specification language which inherits many advanced features (e.g. flexible mix-fix syntax, powerful and clear typing system with ordered sorts, parameteric modules and views for instantiating the parameters, and module expressions, etc.) from OBJ (or more exactly OBJ3) algebraic specification language.

    CafeOBJ is a language for writing formal (i.e. mathematical) specifications of models for wide varieties of software and systems, and verifying properties of them. CafeOBJ implements equational logic by rewriting and can be used as a powerful interactive theorem proving system. Specifiers can write proof scores also in CafeOBJ and doing proofs by executing the proof scores.

    CafeOBJ has state-of-art rigorous logical semantics based on institutions. The CafeOBJ cube shows the structure of the various logics underlying the combination of the various paradigms implemented by the language. Proof scores in CafeOBJ are also based on institution based rigorous semantics, and can be constructed using a complete set of proof rules

    j123123, 20 Декабря 2018

    Комментарии (46)
  3. Си / Говнокод #25202

    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
    enum crap
    {
        shit = 0,
        fuck,
        dick,
        ass,
        turd,
        fart,
    };
    
    static char *crap_to_str(int crap)
    {
        switch (crap)
        {
            case shit:
            {
                return "shit";
            }
            case fuck:
            {
                return "fuck";
            }
            case dick:
            {
                return "dick";
            }
            case ass:
            {
                return "ass";
            }
            case turd:
            {
                return "turd";
            }
            case fart:
            {
                return "fart";
            }
            default:
            {
                return "!!!UNKNOWN CRAP!!!";
            }
        }
    }

    Есть ли возможность через какую-нибудь плюсовую метушню с шаблонами, констэспрами и препроцессором нагенерировать подобную хрень из готового определения структуры?

    j123123, 18 Декабря 2018

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

    +3

    1. 1
    2. 2
    3. 3
    4. 4
    Кстати, разные эпизоды из Зеленого слоника можно сопоставить с разными статьями
    о C++. Если статья про какие-то новые возможности, которые вводятся в
    каком-нибудь С++20, это когда братишке покушать принесли. Если статья о том,
    как можно метапрограммировать на шаблонах, то это когда вилкой говно чистить.

    Ну что ты! Я тебе сейчас расскажу, вот смотри, Я тебе хорошую сейчас расскажу! Смотри, я… вот у нас здесь копипаста много… ой-ой… копипаста много, понимаешь? Смотри, копипаст, они тебе код читать мешает. А я вот, давай я здесь напишу метушни на темплейтах и консэкспрах с препроцессором сишным, и весь копипаст сокращу слышишь? Ну что, писать?

    j123123, 15 Декабря 2018

    Комментарии (21)
  5. Си / Говнокод #25171

    +4

    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
    #include <stdio.h>
    #include <inttypes.h>
    #include <stddef.h>
    
    void printuint64(const uint64_t state);
    uint64_t game_of_life8x8(const uint64_t old);
    uint8_t getbit(uint64_t in, uint8_t y, uint8_t x);
    
    uint8_t getbit(uint64_t in, uint8_t y, uint8_t x)
    {
      return !!((in) & (1ULL << ((y&0b111) + (x&0b111)*8)) );
    }
    
    uint64_t setbit(uint8_t y, uint8_t x, uint8_t bit)
    {
      if (bit)
      {
        return 1ULL << ((y&0b111) + (x&0b111)*8);
      }
      return 0;
    }
    
    uint64_t game_of_life8x8(const uint64_t old)
    {
      uint64_t new_state = 0;
      #define GETBIT(y,x,val) getbit(val, y, x)
      #define SETBIT(y,x,bit) setbit(y,x,bit)
      
      #define SUMAROUND(y,x,val) ( \
        GETBIT(y+1,x,val) + GETBIT(y-1,x,val) \
      + GETBIT(y,x+1,val) + GETBIT(y,x-1,val) \
      + GETBIT(y+1,x+1,val) + GETBIT(y+1,x-1,val) \
      + GETBIT(y-1,x+1,val) + GETBIT(y-1,x-1,val) \
      )
    
      #define CELLSTATE(y,x,val) \
      (GETBIT(y,x,old) == 1 ? \
        ( ((SUMAROUND(y,x,val) == 2 ) || ( SUMAROUND(y,x,val) == 3 )) ? 1 : 0) \
        : \
        ( ( SUMAROUND(y,x,val) == 3 ) ? 1 : 0 ) \
      )
    
      #define SETCELL_SH(y,x,val) SETBIT(y,x,CELLSTATE(y,x,val))
    
      #define FILL_LINE(y) \
        SETCELL_SH(y,7,old) | SETCELL_SH(y,6,old) | SETCELL_SH(y,5,old) | \
        SETCELL_SH(y,4,old) | SETCELL_SH(y,3,old) | SETCELL_SH(y,2,old) | \
        SETCELL_SH(y,1,old) | SETCELL_SH(y,0,old)
    
      new_state = FILL_LINE(7) | FILL_LINE(6) | FILL_LINE(5)
      |  FILL_LINE(4) | FILL_LINE(3) | FILL_LINE(2)
      |  FILL_LINE(1) | FILL_LINE(0);
    
      return new_state;
    }
    
    void printuint64(const uint64_t state)
    {
      for (size_t i = 7; i != SIZE_MAX; i--)
      {
        for (size_t j = 7; j != SIZE_MAX; j--)
        {
          printf("%u", !!((state >> (j+i*8)) & 1) );
        }
        printf("\n");
      }
    }
    
    int main(void)
    {
      // Glider
      uint64_t state =
      (( 0b01000000ULL ) << 8*7 ) |
      (( 0b00100000ULL ) << 8*6 ) |
      (( 0b11100000ULL ) << 8*5 ) |
      (( 0b00000000ULL ) << 8*4 ) |
      (( 0b00000000ULL ) << 8*3 ) |
      (( 0b00000000ULL ) << 8*2 ) |
      (( 0b00000000ULL ) << 8*1 ) |
      (( 0b00000000ULL ) << 8*0 );
    
      
      for (size_t i = 0; i < 50; i++)
      {
        printuint64(state);
        state = game_of_life8x8(state);
        printf("\n");
      }
      return 0;
    }

    Conway's game of life внутри uint64_t (8 на 8) с периодическими граничными условиями.

    j123123, 09 Декабря 2018

    Комментарии (148)
  6. JavaScript / Говнокод #25131

    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
    // https://dev.to/saigowthamr/how-to-reverse-a-string-in-javascript-3i9c
    
    // In this tutorial, we are going to learn three different ways to reverse a string
    // in JavaScript by using the reverse method, reduce method.
    
    // First way
    
    const str = "hello"
    
    str.split('').reverse().join('')
    
    //"olleh"
    
    
    // We used split method to split the string into an array of individual strings then chain it to reverse method.
    // Second way
    
    const str = "hello"
    
    [...str].reduce((prev,next)=>next+prev)
    
    //"olleh"
    
    // First, we spread the string using spread operator and reverse the string using the reduce method
    // Third way
    
    
    function reverseString(str){
    
      const arr = [...str]
      let reverse= "";
    
      while(arr.length){
         reverse = reverse + arr.pop()
      }
    
      return reverse
    }
    
    // I mostly like the Second way to reverse a string using reduce method.
    
    // Happy coding...

    Это видимо такой вид соревнований, типа как вкрутить лампочку в патрон наиболее упоротым и неочевидным способом. Нахрена это нужно обычному программисту? Может это такой способ ручной обфускации? Тогда понятно

    j123123, 29 Ноября 2018

    Комментарии (134)
  7. Си / Говнокод #25130

    +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
    #include <stdio.h>
    #include <inttypes.h>
    #include <string.h>
    
    typedef struct
    {
      uint8_t arr[10];
      uint8_t pos;
      uint8_t is_swap;
    } arr10;
    
    arr10 bubble_sort_recursion(arr10 a);
    void bubble_sort (uint8_t arr[static 10]);
    
    
    void bubble_sort (uint8_t arr[static 10])
    {
      arr10 a;
      memcpy(a.arr, arr, sizeof(a.arr));
      a.pos = 0;
      a.is_swap = 0;
      a = bubble_sort_recursion(a);
      memcpy(arr, a.arr, sizeof(a.arr));
    }
    
    arr10 bubble_sort_recursion(arr10 a)
    {
      if (a.pos != 9)
      {
        if (a.arr[a.pos] > a.arr[a.pos + 1])
        {
          uint8_t tmp = a.arr[a.pos + 1];
          a.arr[a.pos + 1] = a.arr[a.pos];
          a.arr[a.pos] = tmp;
          a.is_swap = 1;
        }
        a.pos++;
        return bubble_sort_recursion(a);
      }
      else
      {
       if (a.is_swap == 0)
       {
         return a;
       }
       else
       {
         a.pos = 0;
         a.is_swap = 0;
         return bubble_sort_recursion(a);
       }
      }
    }
    
    int main(void)
    {
      uint8_t arr[10] = {244, 90, 254, 109, 33, 85, 69, 81, 126, 71};
      bubble_sort(arr);
      printf("%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8,
             arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9]);
      return 0;
    }

    Рекурсивная сортировка пузырьком

    j123123, 29 Ноября 2018

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

    +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
    // https://habr.com/post/428846/
    // Работа со строками на этапе компиляции в современном C++
    
    // Определим статическую строку как массив символов, для удобства будем считать, что строка всегда оканчивается нулевым символом:
    
    template<size_t Size>
    using static_string = std::array<const char, Size>;
    
    constexpr static_string<6> hello = {'H', 'e', 'l', 'l', 'o', '\0'};
    
    constexpr auto hello = make_static_string("hello");
    
    // Здесь нам поможет одна из форм вариативного шаблона, которая позволяет развернуть
    // шаблонные аргументы как индексы для агрегатной инициализации нашей статической
    // строки из строкового литерала:
    
    template<size_t Size, size_t ... Indexes>
    constexpr static_string<sizeof ... (Indexes) + 1> make_static_string(const char (& str)[Size]) {
        return {str[Indexes] ..., '\0'};
    }
    
    constexpr auto hello = make_static_string<0, 1, 2, 3, 4>("hello"); // hello == "hello"
    
    // ...
    
    //Будем сравнивать строки посимвольно, пока не выявим различия, либо не достигнем конца хотя бы одной из строк.
    // Поскольку constexpr for еще не изобрели, воспользуемся рекурсией и тернарным оператором:
    
    template<size_t Size1, size_t Size2>
    constexpr int static_string_compare(
        const static_string<Size1>& str1, 
        const static_string<Size2>& str2,
        int index = 0) {
            return index >= Size1 && index >= Size2 ? 0 :
                index >= Size1 ? -1 :
                    index >= Size2 ? 1 :
                        str1[index] > str2[index] ? 1 :
                            str1[index] < str2[index] ? -1 :
                                static_string_compare(str1, str2, index + 1);
    }

    Ммм, какой БАГОР
    Крестобляди опять накостылили какой-то параши на шаблонах и радуются

    j123123, 20 Ноября 2018

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

    +3

    1. 1
    2. 2
    https://youtu.be/A4Gu0lfIKU0
    Нужно ли программисту изучать C++?

    Какое только дерьмо не найдешь на ютубе.

    C++ это кривая и дерьмовая высокоуровневая говнонадстройка над Си.
    Начинать с C++ точно не стоит, потому что в итоге получаются какие-то говнокодеры, не умеющие ничего делать без трижды обдристанной плюсовой стдлибы и всяких там классов с шаблонами и эксепшенами. Лучше уж начинать с Си, потом немного потыкать в лисп с его макросами, а потом посмотреть на плюсовые темплейты и констэкспры, тогда-то дерьмовейщая суть говноплюсов будет ясна.
    Что касается ООП в C++, то это просто сраное дерьмо. Понапридумывали каких-то паблик-приват-протектед наследований. Еще эта питушня с множественным наследованием и vtable, отсутствие метаклассов (RTTI - говно), отсутствие нормальных механизмов метапрограммирования (только какое-то кривое и убогое говно), отсутствие интроспекции, тьюринг-полные темплейты, не совпадающие с самим C++. Сраное парашное нагромождение разнообразной хуйни. Никакого базиса и ничего фундаментального в этому куске дерьма нет.

    j123123, 05 Ноября 2018

    Комментарии (2025)
  10. Си / Говнокод #25013

    +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
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdalign.h>
    #include <inttypes.h>
    #include <string.h>
    
    float sum_f(const float arr[], const size_t len);
    int32_t sum_i32t(const int32_t arr[], const size_t len);
    
    #define sum(a, b) _Generic((a), float*:   sum_f, \
                                 const float*:   sum_f, \
                                 int32_t*: sum_i32t,\
                                 const int32_t*: sum_i32t)(a, b)
    
    
    // foldl (+) 0 arr
    float sum_f(const float arr[], const size_t len)
    {
      return (len != 0) ? ( sum(arr+1, len-1) + arr[0] ) : 0;
    }
    
    int32_t sum_i32t(const int32_t arr[], const size_t len)
    {
      return (len != 0) ? ( sum(arr+1, len-1) + arr[0] ) : 0;
    }
    
    enum { we_want_int, we_want_float } what_we_want;
    
    void test(int www)
    {
      void *a;
      if (www == we_want_int)
      {
        uint8_t buf[sizeof(int32_t[10])] __attribute__ ((aligned (alignof(int32_t[10]))));
        a = (void *) buf;
        memcpy ( a, (int32_t[10]){1,2,3,4,5,6,7,8,9,10},
                 sizeof((int32_t[10]){1,2,3,4,5,6,7,8,9,10})
                );
        printf("%" PRIi32 "\n", sum((int32_t *)a, 10));
      }
      else if (www == we_want_float)
      {
        uint8_t buf[sizeof(float[10])] __attribute__ ((aligned (alignof(float[10]))));
        a = (void *) buf;
        memcpy ( a, (float[10]){1,2,3,4,5,6,7,8,9,10},
                 sizeof((float[10]){1,2,3,4,5,6,7,8,9,10})
                );
        printf("%f\n", sum((float *)a, 10));    
      }
    }
    
    int main(void)
    {
      test(we_want_int);
      test(we_want_float);
      return EXIT_SUCCESS;
    }

    https://wandbox.org/permlink/TwbKHE8l7ZJc6PNI
    https://govnokod.ru/25005#comment436646
    https://i.imgur.com/yFYfuED.jpg

    j123123, 23 Октября 2018

    Комментарии (454)
  11. C++ / Говнокод #25009

    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
    /*
    https://habr.com/post/246009/
    
    Это вторая статья в цикле «Теория категорий для программистов».
    
    ...
    
    Я хотел бы сказать вам, что есть шаблон в стандартной библиотеке С++,
    который принимает две функции и возвращает их композицию, но такого
    нет.
    
    Примечание переводчика: но такой не сложно написать на С++14 (я опускаю
    тонны деталей владения и шаблонной магии для проверок, что эти функции
    и тип аргумента действительно можно компоновать):
    */
    
    template <typename T>
    struct function_arg: public function_arg<decltype(&T::operator())> {};
    
    template<typename ReturnType, typename Arg>
    struct function_arg<ReturnType(Arg) const> {
    	using type = Arg;
    };
    
    template<typename ClassType, typename ReturnType, typename Arg>
    struct function_arg<ReturnType(ClassType::*)(Arg) const> {
    	using type = Arg;
    };
    
    template<typename T>
    using function_arg_t = typename function_arg<T>::type;
    
    template<typename F, typename G>
    auto compose(F&& f, G&& g) {
    	return [f = std::forward<F>(f), g = std::forward<G>(g)]
    		(function_arg_t<F>&& a) {return g(f(std::forward<function_arg_t<F>>(a)));};
    }

    Поэтому я за C++

    j123123, 22 Октября 2018

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