为什么不指向字母C？

我想倒读我的字符串。我做到了，但我不明白我的代码的两部分是如何工作的

char s1[] = "ABC";
printf("%s", s1);
size_t len = strlen(s1);
printf("\n%d", len);

char *t = s1 + len - 1;
printf("\n%s\n", t);

while (t>=s1)
{
    printf("%c", *t);
    t = t - 1;
}

• 第一：

  t

  如何指向字母C
• 第二：如何添加变量

  len

  ，该变量包含整数，而数组包含文本？这是因为指针t使用指针算法添加地址吗
  这

  char s1[] = "ABC";
  

  看起来像

   0x100   0x101  0x102   0x103 . . . .Assume 0x100 is base address of s1
   --------------------------------
  |   A   |   B   |   C   |   \0   |
   --------------------------------
  s1
  

   0x100   0x101  0x102   0x103 . . . . 
   --------------------------------
  |   A   |   B   |   C   |   \0   |
   --------------------------------
  s1                  t <-- t points here
  

  这里的

  s1

  是字符数组，它指向基址

  0x100

  （假设）
  我想反向读取字符串
  为此，您需要有人指向

  0x102

  位置，即数组的最后一个元素

  size_t len = strlen(s1); /* finding length of array s1 i.e it returns 3 here */
  char *t = s1 + len - 1; /* (0x100 + 3*1) - 1 i.e char pointer t points to 0x102 */
  

  上面两行代码是编写的。现在看来

   0x100   0x101  0x102   0x103 . . . .Assume 0x100 is base address of s1
   --------------------------------
  |   A   |   B   |   C   |   \0   |
   --------------------------------
  s1
  

   0x100   0x101  0x102   0x103 . . . . 
   --------------------------------
  |   A   |   B   |   C   |   \0   |
   --------------------------------
  s1                  t <-- t points here
  

  s1

  是字符指针，

  len

  是一个整数变量，因此当您执行指针算术时，它将根据指针所指数据的大小自动递增。例如

  char *t = s1 + len;
  

  评价为

  t = 0x100 + 3*sizeof(*s1); ==> 0x100 + 3*1  ==> 0x103
  

  ---

  在C语言中，数组有点奇怪。At-of-x可以很容易地降级为指向x的指针。例如，如果传递到另一个例程，或者在添加到该例程时。所以你是对的，这是指针算法。（在指针算术中，您可以添加指针和整数以获得指针。）

  chars1[]=“ABC”
  
  s1
  是一个由4个字符组成的数组
  char[4]
  具有值
  {'A'、'B'、'C'、'\0'}
  
  size\u t len=strlen（s1）
  
  s1
  从类型数组“衰减”（读取：自动转换）到类型指针。因此，
  s1
  从4个字符的数组衰减为指向数组第一个字符的指针
  
  strlen
  在遇到空字节分隔符
  '\0'
  之前，对字节数进行计数。从
  'A'
  开始，我们可以计算
  'A'
  ，
  'B'
  ，
  'C'
  -这就是
  len=3
  
  C中的指针是普通整数（好的，在大多数体系结构上）。您可以对它们进行加法和减法运算，并使用
  uintpttr\u t
  将它们转换为整数。但是在不使用强制转换的情况下添加它们将使用“指针算术”，这意味着
  （int*）5+2
  等于
  5+2*sizeof（int）
  
  char*t=s1+len-1
  
  s1
  衰减到指向
  s1
  数组中第一个字符的指针，即
  'A'
  。我们添加了
  +（len=3）
  ，这意味着
  s1+3
  指向
  s1=（char[4]）{'A'、'B'、'C'、'\0'}
  数组中的
  '\0'
  字节。然后我们减去
  -1
  ，因此
  t
  现在将指向
  s1
  数组中包含字符
  'C'
  的字节
  
  while (t >= s1) {
      ... *t ...
      t = t - 1;
  } 
  
  开始：
  s1
  指向
  'A'
  t
  指向
  'C'
  
  
  而：
  t
  大于
  s1
  。两个<代码>t-s1=2
  ，即
  s1+2=t
  循环：
  *t
  等于
  'C'
  
  
  减量：
  t--
  ，所以现在
  t
  将指向
  'B'
  
  
  而：
  t
  大于
  s1
  。由onw提供。
  
  循环：
  *t
  等于
  'B'
  
  
  减量：然后
  t--
  ，所以现在
  t
  将指向
  'A'
  
  
  while:Now
  t
  等于then
  s1
  。两者都指向数组的第一个字符。
  
  循环：
  *t
  等于
  'B'
  
  
  递减：然后
  t--
  ，因此现在
  t
  将指向数组前面的未知位置。作为指针
  
  （在大多数体系结构上）是简单的整数，您可以将其作为普通变量进行递减和递增。
  
  而：
  t
  现在低于
  s1
  。循环终止
  
  注:
  
  
  printf（“\n%d”，len）是未定义的行为并生成。使用
  printf（“\n%zu”，len）
  打印
  大小\u t
  变量
  
  您可以使用
  %p
  说明符打印指针值，并强制转换为void
  printf（“%p”，（void*）t）
  t=s1-1
  。在C语言中，将指针分配到数组之前的一个元素是未定义的行为。当
  t=t-1
  时，这种行为发生在循环的结束条件中。在循环时更改为
  do{..}
  
  printf（“\n%d”，len）具有未定义的行为<代码>%d
  采用
  int
  ，而不是
  size\t
  ptr+n
  有点像
  &ptr[n]
  我在代码中看不到
  t=C
  任何软件。@ctrl-alt-delor，我认为Jan意味着对t的赋值，即
  char*t=s1+len-1
  指向字母“C”，因为
  char s1[]=“ABC”
  。因此，不是字面上的
  t=C
  ，而是更像
  *t='C'
  或只是“t指向一个'C'”@ctrl-alt-delor编号。
  %d
  printf说明符接受一个
  int
  参数
  %zu
  printf说明符接受
  size\u t
  参数。变量参数列表中的所有参数都进行整数提升（即，
  char
  转换为
  int
  -）。非常感谢您需要一点说明，指针算术知道所指向项的大小，并在代码中向指针p添加整数n，创建一个n*sizeof（*p）的指针地址p之后的字节。例如，如果您有一个
  int*ptrToInt
  并且ptrToInt是0x100，那么
  ptrToInt+n
  的地址是0x100+sizeof（int）*n；是@Wyck此
  n*sizeof（*p）
  是正确的。例如，在OP案例中，我在comments
  （0x100+3*1）
  中写到，
  3
  是
  n
  ，而
  sizeof（*p）
  是
  1
  。欢迎使用堆栈溢出家族@JanKlimaszewskinit:
  这里s1是字符数组，指向基地址<