了解2D数组中字符串的寻址

Question

#include<stdio.h>
 void main()
{
  char s[10][10];
 int i;

 for(i=0;i<4;i++)
      scanf("%s",s[i]);
 printf("%s",s);
 printf("%s",s+1);
 printf("%s",s[1]+1);
}

When I type the above line of code first printf statement will print the first string and second printf will print the second string since s[1] is equivalent to s+1 . But the third printf will print the second string starting from the second character.

If s[1] is equivalent to s+1 why s[1]+1 does not give the result of s+2 ?

I do not get the idea of address calculation for 2D string array.

Answer 1

The way pointer arithmetic works, s[i] is equal to *(s + i) . So s[1]+1 is actually *(s + 1) + 1 , which is not the same as either s + 2 or *(s + 2) .

Answer 2

So, let's talk about pointer arithmetic for a second. Given a pointer to any type T :

T *p;

the expression p+1 will evaluate to the address of the next object of type T . So if T is int , then p+1 will give us the address of the next int object after p . If p is 0x8000 and sizeof (int) is 4, then p+1 evaluates to 0x8004 .

Where things get fun is if we're working with array expressions. Assume the following:

T a[N];

Except when it is the operand of the sizeof or unary & operators, an expression of type "N-element array of T " will be converted ("decay") to an expression of type "pointer to T " and its value will be the address of the first element of the array.

So if we write

int a[10];
int *p = a + 1;

the expression a is converted from "10-element array of int " to "pointer to int ", and the value of a is the address of the first element (ie, &a[0] ). So the expression a + 1 gives us the address of the next integer object following a , which just happens to be &a[1] ¹ .

Now assume we're working with a 2-D array:

int a[2][3];
int (*p)[3] = a + 1;

The expression a has type "2-element array of 3-element array of int ". In this case, a "decays" to type "pointer to 3-element array of int ", or int (*)[3] . So a + 1 gives us the address of the next *3-element array of int ". Again, assuming a starts at 0x8000 and sizeof (int) is 4, then a + 1 evaluates to 0x800c

---

^{1. The expression a[i] is evaluated as *(a+i) ; that is, we're offsetting i elements from the address specified by a and dereferencing the result. Note that this treats a as a pointer, not an array. In the B language (from which C is derived), the array object a would have been a pointer object that contained the address of the first element ( a[0] ). Ritchie changed that in C so that the array expression would be converted to a pointer expression as necessary.}