Qfyilyi

I am trying to add a decimal integer to an address. (I'm not very clear about address, I guess it works in hexadecimal) in the following way:

//node_t is a structure with an int and node_t* ptr, so i have the size 8

    int move = sizeof(node_t) + size; //here node_t is 8, size is 10

//so actually i want to move it by 18bytes.

    node_t* tmp = (current)+sizeof(node_t) / sizeof(node_t) + size/sizeof(int)

//current is the starting address, i try to get current moving positively with 18 bytes

But it turns out tmp is only 16 bytes greater than current.

I think the problem is that size is recognized as hexadecimal, how can I solve this?

This does not make much sense:

node_t* tmp = (current)+sizeof(node_t) / sizeof(node_t) + size/sizeof(int)

Pointer arithmetics works by adding a number of elements, not bytes.
You seem to try to take care about this by dividing the sizes but this cannot work.

From the expression I assume current is of type node_t*.
Adding sizeof(node_t) / sizeof(node_t) basically moves it behind current position. You could also just use 1 for this part.

Then you add size/sizeof(int).
Here you assume a different size of elements: int instead of node_t.

You mention size of node_t is 8. How would you divide 10 by 8? 10/8 is 1 with integer division.
This means you always move by 2 elements, i.e. 16 bytes.

You could try this ugly hack instead:

node_t* tmp = (node_t *)(((char*)current) + sizeof(node_t) + size);

This can work if you do not have very strict alignment restrictions on your hardware.

Otherwise you need to round up to the next well aligned address.