1. Си / Говнокод #28798

    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
    struct node
    {
        void *data;
    
        struct node *head;
        struct node *tail;
    };
    struct list
    {
        int size;
    
        struct node *head;
        struct node *tail;
    
        void *(*alloc_node)(size_t);
        void *(*alloc_data)(size_t);
        void (*free_node)(void *);
        void (*free_data)(void *);
    };
    
    typedef struct node node_t;
    typedef struct list list_t;
    
    void list_init(list_t *list)
    {
        list->size = 0;
    
        list->head = (node_t*)list;
        list->tail = (node_t*)list;
    
        list->alloc_node = &malloc;
        list->alloc_data = &malloc;
        list->free_node = &free;
        list->free_data = &free;
    }
    void list_link(struct node *head, struct node *tail)
    {
        head->tail = tail;
        tail->head = head;
    }
    void *push_head(list_t *list, node_t *head, size_t size)
    {
        node_t *node = list->alloc_node(sizeof(node_t));
        void   *data = list->alloc_data(size);
    
        node->data = data;
        list_link(node, head->tail);
        list_link(head, node);
    
        list->size++;
        return data;
    }
    void *push_tail(list_t *list, node_t *tail, size_t size)
    {
        node_t *node = list->alloc_node(sizeof(node_t));
        void   *data = list->alloc_data(size);
    
        node->data = data;
        list_link(tail->head, node);
        list_link(node, tail);
    
        list->size++;
        return data;
    }
    void pop(list_t *list, node_t *node)
    {
        list_link(node->head, node->tail);
        list->size--;
    
        void *data = node->data;
    
        list->free_node(node);
        list->free_data(data);
    }
    void print(struct list *list)
    {
        printf("\n====\n");
    
        printf("size: %ld \n", list->size);
    
        int i = 0;
    
        for(node_t *node = list->head; node != list; node = node->head)
        {
            printf("index: %ld number: %ld \n", i, *(int*)(node->data));
            i++;
        }
    }
    
    struct list lst;
    
        list_init(&lst);
    
        print(&lst);
    
        void *data;
        data = push_tail(&lst, lst.tail, 4);
        *(int*)data = 1;

    итак скажите про название функций про то каких функций не хватает + alloc и free поля не трогать это мне нужно ТОЛЬКО НЕ советуйте перейти на с++ и использовать чтото другое(std::list)

    Запостил: CodeTux, 16 Июня 2023

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

    • Попробуй го.
      Ответить
    • у тебя лаба по написанию листа что ли?
      Ответить
      • нет мне 15 я пишу TCP через UDP мне этот лист нужен для хитрого механизма очереди без маллока

        Я просто хочу что бы его можно было использовать не только я
        Ответить
        • Подучи сначала русский язык. Там есть такие значки, как "знаки препинания".
          Ответить
        • Наверняка его будут использовать все, ведь твоя реализация с размером int, обобщенным программированием *void, и настоящим ООП через посредство указателей на функции, окажется намного более производительной и стабильной, чем std::list.

          Ну и конечно у твоей реализации TCP есть все шансы вынести порядком всем надоевший RFC793 и миллионы его расширений, адаптивных подстроек размеров окна, конджешн контролов, и пр.


          Но



          Если тебе действительно 15 лет, то это всё мега-круто, потому что 99.9% 15-ти летних в твоем комментарии не поймут ни одного слова
          Ответить
          • я расстроен, на-до мной опять шутят, и тут. Как обычно ни чего хорошего и полезного я не услышал. Жаль.
            Ответить
            • Можешь посмотреть как реализован связанный список в ядре Linux
              https://www.oreilly.com/library/view/linux-device-drivers/0596000081/ch10s05.html
              Ответить
          • Я вот для себя не могу даже чек-лист написать, что нужно реализовать для TCP. Там же по мере эксплуатации будут налипать проблемы, как снежный ком.
            Ответить
    • > итак скажите про название функций про то каких функций не хватает

      Можешь посмотреть методы из std::list и сделать как там
      https://en.cppreference.com/w/cpp/container/list
      Ответить
      • Спасибо.
        Ответить
        • Надо посмотреть, как в стандартных библиотеках объявлены очереди, стеки и деки (deque).

          Тут я вижу, что push сделан с двух сторон, а pop только с одной. Т. е. это гибрид очереди и стека, но односторонний. Добавив pop с другой стороны, можно получить полноценный дек.
          Ответить
          • pop просто удаляет элемент
            Ответить
            • Ты дурак, что ли? Ты вообще д***л? Ты больной? Ты и***т? У тебя есть справка о том, что ты дцпированный?
              Ответить
    • Зая я убила мента
      Ответить

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