Why does this print b = 20?
Is this C's bug?

>>105948747 (OP)
ints are 4 bytes, 5*4=20

>>105948747 (OP)
You do realize you're moving a fucking pointer. Not adding numbers.

>>105948747 (OP)
bc the pointer's virtual address is signed int 20
if gcc you have compiler warnings

>>105948747 (OP)
>anon learns pointers and dereferencing

>>105948747 (OP)
itoddlers should stick to swift

>>105948761
the last platforms that used 16 bit ints were m68k apple and turbo c in the 80's

>>105948761
I'm not gonna lie, I was afraid the level was so low nowadays the answer was not given. Based first responder.

>>105948793
No because JavaScript devs iq peaks at 95

>prints pointer address as integer

>>105948820
nothing is dereferenced in this case

>>105948915
4 bytes are 32 bits. Why are you bringing up 16 bit ints?

normally I just lurk. but 4chan is sped, never ask for any tech related advice (especially OS related). this has nothing to do with an int being 4 bytes. you can Google what a pointer is but essentially your taking a memory address, ie 0x0001 and iterating 5 to the address 0x0006. you are then printing this pointer as an int which is undefined behavior. the reason it is 20 is not obvious without a lot of debugging and desu not important at all. dont ask for help here ever everyone's fucking retarded

>>105949223
4*4=16 retrad

>>105949408
A byte is 8 bits. I really hope you're being le ebin trollerman.

>>105949370
>everyone's fucking retarded
I'm just pretending to be retarded for the luls. I'm actually highly intelligent.
t. highest IQ on /g/

>>105949370
>taking a shitpost this seriously
You're not even a midwit, you're a straight up lackwit, lmao.

>>105948761
>ints are 4 bytes
says who?
>>105949534
>a byte is 8 bits
no it's not. stop making assumptions

>>105948747 (OP)
you're lucky to be on a little endian machine, otherwise this would print 0 and leave you confused.

a and b are pointers, and pointer arithmetic always adds in chunks of the pointed to type's size.
ints are 4 byte on many platforms these days, so 5 * [sizeof (int)] = 20.
hence a = 0, and b = 20. to correctly print the value of the pointer, use %x instead of %d.

>>105949671

>>105949671
>no it's not. stop making assumptions
the programme displays behaviour consistent with little endianness and sizeof (int) == 4, so I think it's safe to assume that CHAR_BITS == 8 ;)

>>105949712
CHAR_BIT is not required to equal 8

>>105949718
Your breath does not need to smell like cock, but it still always does.

nigga u are assigning a pointer to memory address 0 and then creating a new pointer that is 20 bytes offset from it and then printing the memory address with %d so it gets represented in decimal. i pray this is bait and all of the replies as well.

>>105950145
>memory address 0
who says the null pointer has to have address 0

>>105950185
does the provided "code" have a nullptr?

>>105949671
Wtf, how can byte not be 8 bit?
As for int being 4 bytes it depends on arch and the compiler I guess so it's not wrong to say it's not necessarily 4 bytes.

>be me, advanced computer
>made in one of those factories china wants so much
>billion computations per second
>made from parts all across the world
>a marvel of technology

>be user
>outdated organic being with lower intellect
>asks me what's the integer stored in the virtual address 0x5
>the answer infuriates him
>he immediately opens mongolian snowboard forum
>starts to type furiously and discuss with all those others humans
>writes a meltdown rant and then goes jerkoff
>fuck my life

>>105950189
in c
insertpointerhere = 0;
yields a null pointer

>>105948747 (OP)
Retard

>>105948747 (OP)
>nocoders shilling c actually have no idea how pointers work
many, many such cases

>>105948747 (OP)
this is very surprising the first time it happens, but basically the reason why is because pointer arithmetic takes into account the underlying type that's being pointed to.

in other words, the following are equivalent:
int *b = a + 5;
int *b = &a[5];

but the second one makes it much more obvious.

for this reason i always 'index' into pointers, since it prevents this kind of misunderstanding.

if you first cast `a` to a void pointer, then it will print what you originally expected:

int *b = (void *)a + 5;


however this may cause problems on some architectures which expect integer load/stores to be aligned on power-of-two boundaries, possibly slow down performance, in extreme case it will trigger a system trap.

Imagine solving OP's CS assignment for free

>>105948747 (OP)
Does MacOS natively make these weird jeety screencaps?

>>105952222
the apple name is """"screenscapes"""

>>105952202
the fact that he's here and not at chatgpt.com is a strong indicator that this is a real thread.

>>105952202
Imagine giving advice to people for free
Now go back to your cage wagie

>>105950222
>how can byte not be 8 bit
By not being 8 bits of course. Do you have so little imagination that you can't imagine this? Do you have so little knowledge that you can't think of actual historical machines that didn't have 8-bit bytes? The IBM 7090 had 6-bit bytes. The PDP-10 could have byte sizes ranging from 1 to 36 bits.

>>105952222
i like them

>>105952054
Thank you, chatgpt.

>>105948747 (OP)
>>105948761
I understand that you put a value of 5 + address written in a but why is it 20?

>>105955353
>but why is it 20?
Because a starts at address 0 and an int is 32 bits.
So address 0, 1, 2, 3 are the a[0]
4, 5, 6, 7 are a[1]
8, 9, 10, 11 are a[2]
12, 13, 14, 15 are a[3]
16, 17, 18, 19 are a[4]
20, 21, 22, 23 are a[5]
The first byte of the word is the address of that word.

>>105948747 (OP)
It is that easy to farm (you)s huh

It is an UB btw and you are all retarded

>>105955766
>It is an UB btw
>everything I don't understand is UB

>>105955782
t. retard

Null pointer is valid.

>>105955766
>pointer arithmetic is UB

>>105956136
It indeed is, read the standard retard

>>105948747 (OP)
Was it necessary to include the gay syntax highlighting and the itoddler window?

>>105956124
But adding to it is not

>>105948747 (OP)
a is a pointer, not a number.
This is the color palette's fault. It gives pointers and stored variables the same color, when 90% of coding mishaps occur because they different worlds of function.

>>105956136
adding non-zero value to a null point is UB, yes

>>105952054
>however this may cause problems on some architectures which expect integer load/stores to be aligned on power-of-two boundaries
Does amd64 care about alignment? I know GCC is anal about it but does the processor care?

void *ops_brain = NULL;

>>105957268
Modern "big" processors handle unaligned accesses transparently with zero or close to zero penalty, unless the access crosses the cache line or page. But this is only if you are accessing memory. Many (most?) loads are not handled by a memory (cache) subsystem, but are resolved by store-to-load forwarding (within load-store queue). This is where alignment becomes important, because there are limits to how CPU can forward data there. So unaligned loads from a huge array have no penalty, but passing small 2-word structure to a function through memory unaligned can cause stalls until cache handles all accesses.
>>105952054
By the standard, (void*) is an incomplete type and you cannot add anything to such pointers. You have to use (char *). Variant with (void *) is a GCC extension.

>>105957259
It's implementation defined and the implemented definition is almost certainly all zeros unless you time traveled from 1984.

>>105957330
>It's implementation defined
What is implementation defined and is all zeroes?
I said that adding 5 to a NULL pointer is UB.

>>105957330
Pointer arithmetic requires operand and final result to be "pointing to the same array boundary or one element past it", otherwise it is undefined.

The standard is a bit fuzzy for null pointers but it sounds like it should belong to the "otherwise undefined" part, neither source nor result points to the same array object, there is no object to speak of

>>105948747 (OP)
The only correct answer is "undefined behavior", without knowing the underlying architecture we cannot assume that an integer is 32bit

>>105957350
Except it isn't, because a null pointers bit representation is zeros, which is why you can add to it and then print that bit representations integer value. it matters not that the address is garbage or still null, since we are not attempting to dereference it. we are merely changing its address.

>>105957493
>it matters not that the address is garbage or still null, since we are not attempting to dereference it. we are merely changing its address.
Not how it works, Chuddie. See 6.5.6/8.

>>105957493
>manual pointer math in an operating system environment where the OS has ultimate arbitration over memory addressing
yeah that's not going to work out bud

>>105957621
That has absolutely nothing to do with what we're talking about.

>>105957650
>literally worked in op

>>105957658
Did you even read it? I will even give you updated version from C23.
I don't know what YOU are talking about, but adding non-zero value to a NULL pointer is UB. NULL pointer representation is irrelevant here.

>>105948747 (OP)
Fuck, you're dumb.
>>105948915
Fuck, you're dumb.
>>105949408
Fuck, you're dumb.

>>105949671
>be genuinely retarded
>get caught on it
>act retarded on purpose to try and retrofit your previous stupidity into trolling intent
No, you're just retarded, and probably will never escape wageslavery.

>>105949671
>says who?
OP is using one of Windows, MacOS, Linux, Android, or iOS. Anything else is way too fucking obscure for someone who doesn't know basic pointer arithmetic. The int data type is 32 bits on all such platforms, and CHAR_BIT on all such platforms is 8.

>>105950222
Byte is defined as the smallest addressable unit of memory, not as 8 bits. There are some CPUs which used 18 bit or 36 bit words, and naturally that meant that the smallest addressable unit was 9 bits. If you want to be consistent in referring to something that is always 8 bits, the term you are looking for is octet. Although for data transmitted over the Internet, 1 byte = 1 octet.

The number of bits in a byte is represented in C using the constant CHAR_BIT.

>>105955353
Google pointer arithmetic

>>105955766
typed pointer math is not UB, dunning-kruger

>>105958589
then explain this chud
https://godbolt.org/z/PraKvExdP

>>105957621
ub is fak enws made by crabs