Programming

i'm using a C program and running it on a linux server, i got 2 adressess of 2 variables, and 2 addresses of 2 chars, and compared it. and got the size of a int and the size of a char.
why is a size of a int (4 bytes) bigger then the size of a char (1 byte)?

also if i do &a-&b i get 1, but if i get the difference of the address i get 4, why is that?

When loading phydsical accumulators and registers with numbers, they are stretched to fit, with zeros if unsigned or by repeating the sign bit at the high order bit of the comp-2 representation. Similarly, C stretches the values to the bigger type to compare or compute.

Usually, a char is 1 byte unsigned (0-255), and an int is 4 bytes signed (+/- 2 billion plus). Old C models had int and short at 2 and long at 4, most 32 bit models have int and long at 4, and long models have int at 4 and long at 8.

Floating types are particularly variable in computers, but in C it is 4 bytes, and there is an IEEE spec on floating numbers that makes them portable. Differnt float types are 64 Double or 80 Long Double or is it Double Double, no, that feels wrong, bits. Float has some bits for mantissa, usually as a 2's complement fraction between .5 and < 1.0 when normalized, where 010000- is 1/2, and exponent, usually a 2's complement power of 2 but sometimes a 2's complement power of 16 or an "excess" number, where the boundary between negative and positive is shifted to a more useful range. None of this leaks into IEEE floating representations.

C increments pointers for each type by its size. types.h gives a lot of info on alternative C types. Some APIs just typedef their int types int1, int2, int4 and int8 or unsigned uint1, uint2, uint4, uint8.

Positions of items in a struct are usualy formatted #pragma pack 4 by default, and generally, you can save space by declaring like sized types adjacent.

not sure if i understand why &a-&b gets me 1 when i print it, but if i get the difference manually via calculator i get 4.

Well, & is the address, and it goes up one for every char and usually 4 for every int. Addresses are guaranteed to be subtractable even if they are in odd formats internally. Also, adding integers is the same as offsetting an array, so for array "char c[] = "Hello" ;", c + 5 = &(c[5]) points c[5] = *(c+5) to the null of the "" string after the 'o' of hello.

For int arrays, adding one moves it 4 in char terms, but if you subtract int addresses, you get a result / 4 unless you cast them as (char*) first. So, for "int i[8];", &(i[5]) - &(i[2]) = 3, which turns out to be more useful than 12 unless you are doing i/o or malloc(), which are byte char operations.

If you are doing an array of struct, the struct size is multiplied for you into any increment or offset. You can discover the real size with sizeof() or by casting addresses of two adjacent struct to (char*) and subtracting, a popular interview question some places.

It's giving the offset in integer-sizes, I suppose. If you want it to just be integers for easy arithmetic, cast pointers into unsigned long before doing arithmetic.

still not sure if i understand, say i do this
a=6; b=7;
print (&a-&b)
i would get 1
but if i do
c=&a; d=&b;
print(c-d)
i would get 4

why is this?

Well, the first makes arithmetic sense, and the second makes memory allocation sense. Whether int 4 are in the heap or the stack, they are packed tight and so are 4 apart. Automatic are in the stack, so each pulls the stack pointer down by 4, but static or global are in the heap, which moves up.

---------- Post updated at 05:19 PM ---------- Previous update was at 05:14 PM ----------

I am not sure that is portable for all CPUs!

I think there is a printf option for printing pointers that is portable.