Runtime error in the following code

Question

The following code,according to me should run successfully,but fails at runtime.I don\'t get the reason:

 void main()
 {
   int arr[5][3]={1,2,3,4,5,6,7,8,9,10,1         


        

Answer 1

int **p=&m;

p points to address, where m is placed:

... |  m  | sth | ... |  p  | ...
       ^                 V
       |_________________|

Now, increment it:

... |  m  | sth | ... |  p  | ...
             ^           V
             |___________|

So, now p points to sth. What is sth? Nobody knows. But you're trying to get access to the address sth contains. This is undefined behavior.

Answer 2

With the line

int **p=&m

you create a pointer to a pointer to an integer.

Then, you add one to the address - one memory address, that is, not one times the number of bytes to point to the next integer.

Then you deference it twice:

• both dereferences will return unspecified values, so the second dereference may break memory boundaries for the OS you are using,
• both times it will be off boundary alignmemnt, which may cause issues in some OSes.

Answer 3

Here int **p=&m;. p points to m. Then when p = p + 1; p will point to the address next to m (integer). That address may not be accessible.

Answer 4

An array of arrays and a pointer to a pointer is quite different, and can't be used interchangeably.

For example, if you look at your array arr it looks like this in memory

+-----------+-----------+-----------+-----------+-----+-----------+
| arr[0][0] | arr[0][1] | arr[0][2] | arr[1][0] | ... | arr[4][2] |
+-----------+-----------+-----------+-----------+-----+-----------+

When you have the pointer-to-pointer p the program don't really knows that it points to an array of arrays, instead it's treated as an array of pointers, which looks like this in memory:

+------+------+------+-----+
| p[0] | p[1] | p[2] | ... |
+------+------+------+-----+
  |      |      |
  |      |      v
  |      |      something
  |      v
  |      something
  v
  something

So when you do p + 1 you get to p[1] which is clearly not the same as arr[1].