Указатель + int против точки - int

В C (pointer + n) эквивалентен &pointer[n]... то есть индекс подсчитывает элементы, на которые указывает указатель, а не байты. Если вам нужно смещение в байтах, используйте ((char*)pointer + n). Но в вашем случае вам не нужно смещение байта; вместо

return newNode + sizeof(node);

ты можешь просто сделать

return newNode + 1;

or

return &newNode[1];

Хотя вы, вероятно, захотите привести их к (void*), если вы возвращаете указатель на что-то, что вызывающая сторона может использовать как любой тип. Чтобы вернуться к исходному узлу из указателя (void*), используйте либо (node*)vp - 1, либо (node*)((char*)vp - sizeof(node)).

Также,

#define HEADER(24)

не будет компилироваться, потому что он напоминает макрос, похожий на функцию; вам нужен хотя бы один пробел между именем макроса и левой скобкой (или опустите скобки).

Вы не дали нам достаточно кода для решения проблемы. Тем не менее, я могу предположить.

Покажите нам декларацию pointer. Я предполагаю, что это не head *pointer;. Арифметика указателя учитывает тип указателя.

Когда вы (например) добавляете 1 к указателю на int, указатель увеличивается на 1 * sizeof int байт. Если бы тип был short, то он был бы увеличен на 1 * sizeof short байт. Не обязательно одно и то же.

Итак, если pointer (опять же, например) объявлено как char *pointer, то добавление к нему HEADER увеличивает указатель на HEADER (24) байт (поскольку sizeof char всегда 1). Однако, когда вы позже вычитаете HEADER из toUse, которое имеет тип head*, оно уменьшается на HEADER * sizeof head байт. Опять же, не то же самое.

Можно использовать еще немного кода, чтобы быть уверенным здесь... но я собираюсь бросить это вам. Вы сказали:

have some memory and I try to allocate it in several pieces. So I have a linked list. Each node keeps track of the size the allocated piece of memory is and the next node.

Итак, я предполагаю, что вы создаете узлы и malloc() выделяете им некоторую память, а затем пытаетесь сделать что-то вроде:

ptr_to_next_node = ptr_to_current_node+sizeof(node);

Ну, это не работает. Вы не можете выполнять арифметические операции с указателями в связанных списках, потому что это не непрерывная память. Причина, по которой арифметика указателей работает с массивами, заключается в том, что память, которую вы получаете, будет непрерывной:

 char array [0][1][2][3]
             ^  ^  ^  ^
             |  |  |  +----------0x86C00004
             |  |  +-------------0x86C00003
             |  +----------------0x86C00002              
             +-------------------0x86C00001

 linked_list 

    +-------+        +-------+        +-------+
    | node1 |        | node2 |        | node3 |
    | next---------->| next---------->| next---------->NULL
    +-------+        +-------+        +-------+
    (0x86C0001)      (0x86C000A)      (0x86C00BC)

Итак, значения в памяти могут не иметь особого смысла, но вы можете понять, что я пытаюсь здесь проиллюстрировать. Массивы sizeof(type) отделены друг от друга, память, которую вы выделяете своим узлам, может быть практически где угодно, мы не можем просто добавить смещение, поэтому у них есть указатели на next.

Если вы хотите иметь возможность прыгать вперед и назад, вам нужно добавить указатели вперед next и назад prev.