A short C++ program about the pointer

by

An array of arrays like yours look like this in memory

+---------+---------+---------+---------+---------+---------+
| x[0][0] | x[0][1] | x[0][2] | x[1][0] | x[1][1] | x[1][2] |
+---------+---------+---------+---------+---------+---------+

The location of x, x[0] and x[0][0] is all the same.

Also, arrays naturally decays to pointers to their first element. If you use plain x you will get &x[0]. If you use x[0] you will get &x[0][0]. So when you do *x[0] it is the same as doing *&x[0][0], and the dereference and address-of operators cancel each other out so you are left with x[0][0], which is the value you print.

Furthermore, to help you understand why x is the same as &x[0], you need to know that for any array or pointer x and index i the expressions x[i] is the same as *(x + i). That means the expression &x[i] is the same as &*(x + i), and since the address-of and dereference operators again cancel each other out &x[i] is the same as (x + i) (or without the parentheses x + i). Now think of the case when i is zero, then we have &x[0] which is the same as x + 0 which is the same as x. So &x[0] is the same as x, and vice-versa.

For others that wonders what &x and &x[0] and &x[0][0] are representing, please see this:

+---------+---------+---------+---------+---------+---------+
| x[0][0] | x[0][1] | x[0][2] | x[1][0] | x[1][1] | x[1][2] |
+---------+---------+---------+---------+---------+---------+
^         ^                   ^         ^
|         |                   |         |
+- &x     +- &x[0][1]         +- &x+1   +- &x[1][1]
|                             |
+- &x[0]                      +- &x[1]
|                             |
+- &x[0][0]                   +- &x[1][0]

While all of x, x[0], &x, &x[0] and &x[0][0] may represent the same memory address, they are semantically different, i.e they represent different types:

  • x is a pointer to an array of three char (or char (*)[3])
  • x[0] is a pointer to char (or char *)
  • &x is a pointer to an array of arrays of three char (or char (*)[3][3])
  • &x[0] is a pointer to an array of three char (or char (*)[3])
  • &x[0][0] is a pointer to char (or char *)

More Related Contents:

  1. Pointer to string with spaces [closed]
  2. What is a smart pointer and when should I use one?
  3. Why doesn’t polymorphism work without pointers/references?
  4. What is uintptr_t data type
  5. Which kind of pointer do I use when?
  6. C/C++: Pointer Arithmetic
  7. What is the point of function pointers?
  8. What happens in a double delete?
  9. How does delete[] know it’s an array?
  10. Why is ‘this’ a pointer and not a reference?
  11. Pointers, smart pointers or shared pointers? [duplicate]
  12. What makes more sense – char* string or char *string? [duplicate]
  13. Modifying a const through a non-const pointer
  14. Why does streaming a char pointer to cout not print an address?
  15. When should I use raw pointers over smart pointers?
  16. Deleting a pointer in C++
  17. Create new C++ object at specific memory address?
  18. Uninitialized pointers in code
  19. Do all pointers have the same size in C++?
  20. can’t modify char* – Memory access violation
  21. c++ delete pointer issue, can still access data [closed]
  22. Using a C string gives a warning: “Address of stack memory associated with local variable returned”
  23. Why does pointer to int convert to void* but pointer to function convert to bool?
  24. Get base address of process
  25. Conversion from Derived** to Base**
  26. What does ‘**’ mean in C?
  27. What is the proper way to return an object from a C++ function?
  28. Can I call memcpy() and memmove() with “number of bytes” set to zero?
  29. Displaying the address of a string
  30. Both asterisk and ampersand in a parameter

Leave a Comment