CODEWITHSUNDEEP
c++cpointerspointer-arithmetic
Engineer999
Engineer999

Reputation: 3955

How does compiler know how to increment different pointers?

I understand that in general , pointers to any data type will have the same size. On a 16 bit system, normally 2 bytes and and on a 32 bit system , 4 bytes.

Depending on what this pointer points to, if it is incremented , it will increment by a different number of bytes depending on if it's a char pointer, long pointer etc.

My query is how does the compiler know by how many bytes to increment this pointer. Isn't it just a variable stored in memory like any other? Are the pointers stored in some symbol table with information about how much they should be incremented by? Thanks

Upvotes: 2

Views: 1099

Answers (3)

Rjain
Rjain

Reputation: 137

The data type of the pointer variable defines how many bytes to be incremented.

for example: 1) on incrementing a character pointer, pointer is increment by 1 Byte. 2) Likewise, for a integer pointer, pointer is increment by 4 Bytes (for 32-bit system) and 8 Bytes (for 64-bit system)

Upvotes: 0

Cheers and hth. - Alf
Cheers and hth. - Alf

Reputation: 145419

Re

” I understand that in general , pointers to any data type will have the same size

No. Different pointer sizes are unusual for ¹simple pointers to objects, but can occur on word-addressed machines. Then char* is the largest pointer, and void* is the same size.

C++14 §3.9.2/4

” An object of type cv void* shall have the same representation and alignment requirements as cv char*.

All pointers to class type object are however the same size. For example, you wouldn't be able to use an array of pointers to base type, if this wasn't the case.

Re

” how does the compiler know by how many bytes to increment this pointer

It knows the size of the type of object pointed to.

If it does not know the size of the object pointed to, i.e. that type is incomplete, then you can't increment the pointer.

For example, if p is a void*, then you can't do ++p.

Notes:
¹ In addition to ordinary pointers to objects, there are function pointers, and pointers to members. The latter kind are more like offsets, that must be combined with some specification of a relevant object, to yield a reference.

Upvotes: 1

Sourav Ghosh
Sourav Ghosh

Reputation: 134376

That is why there are data types. Each pointer variable will have an associated data type and that data type has a defined size (See about complete/incomplete type in footnote). Pointer arithmetic will take place based on the data type.

To add to that, for pointer arithmetic to happen, the pointer(s) should be (quoted from c11 standard)

pointer to a complete object type

So, the size of the "object" the pointer points to is known and defined.

Footnote: FWIW, that is why, pointer arithmetic on void pointers (incomplete type) is not allowed / defined in the standard. (Though GCC supports void pointer arithmetic via an extension.)

Upvotes: 3

Related Questions