Why a pointer to an integer increments by 4 bytes?

Question

Possible Duplicate:
Question about pointer increment

When i increment a int pointer then its address have a gap of 4 bytes. why it is so ? why a int pointer takes 4 bytes to store whereas a char takes 2 bytes ?

Answer 1

When you increment a pointer of a type A, you move that pointer forward in the memory by the size of the type it points to. On your machine, int takes 4 bytes, so the pointer moves by 4 bytes.

As for "why does int take 4 bytes on my machine?":

The C++ standard says (4.9.1. paragraph 2):

There are five standard signed integer types : “signed char”, “short int”, “int”, “long int”, and “long long int”. In this list, each type provides at least as much storage as those preceding it in the list. <...> Plain ints have the natural size suggested by the architecture of the execution environment^[44]; the other signed integer types are provided to meet special needs.

---

^[44]: that is, large enough to contain any value in the range of INT_MIN and INT_MAX, as defined in the header .

Basically, the sizes of fundamental types are not set in stone, and are implementation-defined. The accepted answer to this SO question has some information about it.

Answer 2

the size of the pointer to any data types always be the same as supported by your system

If system is 32 -bit the size would be 4 bytes for all the pointers.

In pointer arithmetic when you do ptr++ or ptr-- the increments and decrements takes place according to the size of the data type this ptrpointer points to .

char *cptr;
int *iptr;
char c[5];
int a[5];
cptr=c;
iptr=a;

By doing cptr++ you will get c[1] and pointer will increments by only one byte You can check the address of each char.

Similarly iptr++ will give you a[1] here pointer increased by 4 bytes.

int main()
{
 int i;
 for(i=0;i<5;i++)
 {
  printf("%p\t",&c[i]); //internally pointer arithmeitc: (c+sizeof(char)*i) , 
  printf("%p\n",&a[i]); //intenally pointer arithmetic : (a+sizeof(int)*i)
 }
}

Size of int or other data types are implementation defined

Answer 3

Here is the general rule:

• If the type is T, its size N is calculated as sizeof(T) bytes. So pointer of type T* is increased by N bytes if you increment the pointer by 1.

  Mathematically,

  T  *p = getT();
  
  size_t diff = static_cast<size_t>(p+1) - static_cast<size_t>(p);
  
  bool alwaysTrue = (diff == sizeof(T)); //alwaysTrue is always true!
  

Answer 4

because the size of data (int) which the pointer is pointing has 4 byte size so the pointer increments 4 bytes (size of data (int))

another example: if you have structure with size 8 byte and you have pointer pointing to this structure the increment of this pointer will be 8 byte:

struct test {
   int x;
   int y;
}

struct test ARRAY[50];
struct test *p=ARRAY; // p pointer is pointing here to the first element ARRAY[0]. ARRAY[0] is with size 8 bytes

p++; // this will increment p with 8 byte (size of struct test). So p now is pointing to the second element ARRAY[1]

Answer 5

Pointers increment by the size in bytes of the things they point to. ints take 4 bytes on a 32-bit machine.

Answer 6

Because, on your computer, sizeof (int) == 4, so stepping from one int to the next requires an increment of four bytes.

Most integer types have different sizes on different computers. int must have at least 16 bits, and is supposed to be a "natural" size for the computer. Most 32 or 64-bit platforms choose 32 bits as a "natural" size, and most computers have 8-bit bytes, so 4 bytes is a very common size for int.

However, sizeof (char) == 1 on all computers, so I'm rather surprised that you say "a char takes 2 bytes". It should only take one.