У меня три петли над массивом элементов (char *) в C. Почему третий сбой?

При экспериментировании с методами для перехода по массиву строк в C я разработал следующую небольшую программу:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef char* string;

int main() {
  char *family1[4] = {"father", "mother", "son", NULL};
  string family2[4] = {"father", "mother", "son", NULL};

  /* Loop #1: Using a simple pointer to step through "family1". */
  for (char **p = family1; *p != NULL; p++) {
    printf("%s\n", *p);
  }
  putchar('\n');

  /* Loop #2: Using the typedef for clarity and stepping through
   * family2. */
  for (string *s = family2; *s != NULL; s++) {
    printf("%s\n", *s);
  }
  putchar('\n');

  /* Loop #3: Again, we use the pointer, but with a unique increment
   * step in our for loop.  This fails to work.  Why? */
  for (string s = family2[0]; s != NULL; s = *(&s + 1)) {
    printf("%s\n", s);
  }
}

Мой конкретный вопрос касается отказа Loop # 3. При прохождении через отладчик Loops # 1 и # 2 завершаются успешно, но последний цикл выходит из строя по неизвестной причине. Я бы не спросил об этом здесь, кроме факта, что показывает мне, что у меня есть некоторые критические недоразумения относительно "&". Оператор.

Мой вопрос (и текущее понимание) таков:

family2 - это массив-указатель на char. Таким образом, когда s установлено на family2[0], мы имеем a (char*), указывающий на "отец". Поэтому принятие &s должно дать нам эквивалент family2, указывая на первый элемент family2 после ожидаемого распада указателя. Почему же тогда нет, *(&s + 1) указывает на следующий элемент, как ожидалось?

Большое спасибо,
lifecrisis

EDIT - обновление и извлеченные уроки:

Следующий список представляет собой резюме всех соответствующих фактов и интерпретаций, которые объясняют, почему третий цикл не работает, как первые два.

s - это отдельная переменная, содержащая копию значения (указатель-to- char) из переменной family2[0]. I.e., эти два эквивалентных значения расположены в SEPARATE местах в памяти.
family2[0] до family2[3] являются смежными элементами памяти, а s не имеет присутствия в этом пространстве, хотя оно содержит то же значение, которое хранится в family2[0] в начале нашего цикла.
Эти первые два факта означают, что &s и &family2[0] НЕ равны. Таким образом, добавление одного в &s вернет указатель на неизвестные /undefined данные, тогда как добавление одного в &family2[0] даст вам &family2[1], если требуется.
Кроме того, шаг обновления в третьем цикле for фактически не приводит к тому, что s будет выполняться вперед в памяти на каждой итерации. Это связано с тем, что &s является постоянным во всех итерациях нашего цикла. Это является причиной наблюдаемого бесконечного цикла.

Благодаря КАЖДОМУ за их помощь!
lifecrisis

Ответ 1

Когда вы выполняете s = *(&s + 1), переменная s является локальной переменной в неявной области, содержащей только цикл. Когда вы делаете &s, вы получаете адрес этой локальной переменной, которая не связана с каким-либо из массивов.

Отличие от предыдущего цикла заключается в том, что там s является указателем на первый элемент в массиве.

Чтобы объяснить это немного более "графически", то, что у вас есть в последнем цикле, похоже на

+----+      +---+      +------------+
| &s | ---> | s | ---> | family2[0] |
+----+      +---+      +------------+

То есть, &s указывает на s, а s указывает на family2[0].

Когда вы делаете &s + 1, у вас есть что-то вроде

+------------+
| family2[0] |
+------------+
^
|
+---+----
| s | ...
+---+----
^   ^
|   |
&s  &s + 1

Ответ 2

Картинки очень помогают:

            +----------+
            | "father" |                                    
            +----------+         +----------+      +-------+      NULL 
   /-----------→1000            | "mother" |      | "son" |        ↑
+-----+           ↑              +----------+      +-------+        |
|  s  | ?         |                  2000            2500           |
+-----+           |                   ↑                ↑            |
 6000  6008 +----------------+----------------+--------------+--------------+
            |   family2[0]   |   family2[1]   |  family2[2]  |  family2[3]  |
            +----------------+----------------+--------------+--------------+
                  5000              5008            5016           5024

                    (    &s refers to 6000    ) 
                    ( &s+1 refers to 6008 but )
                    (   *(&s+1) invokes UB    )

^{Адреса, выбранные в качестве случайных целых чисел для простоты}

Дело в том, что хотя оба s и family2[0] указывают на один и тот же базовый адрес строкового литерала "father", указатели не связаны друг с другом и имеют свою собственную другую ячейку памяти, где они хранятся. *(&s+1) != family2[1].

Вы нажимаете UB, когда вы делаете *(&s + 1), потому что &s + 1 - это ячейка памяти, в которую вы не должны вмешиваться, т.е. она не принадлежит к любому созданному вами объекту. Вы никогда не знаете, что хранилось там = > Undefined Поведение.

^{Спасибо @2501 за то, что указали несколько ошибок!}

Ответ 3

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef char* string;

int main() {
char *family1[4] = { "father", "mother", "son", NULL };
string family2[4] = { "father", "mother", "son", NULL };

/* Loop #1: Using a simple pointer to step through "family1". */
for (char **p = family1; *p != NULL; p++) {
    printf("%s\n", *p);
}
putchar('\n');

/* Loop #2: Using the typedef for clarity and stepping through
* family2. */
for (string *s = family2; *s != NULL; s++) {
    printf("%s\n", *s);
}
putchar('\n');

/* Loop #3: Again, we use the pointer, but with a unique increment
* step in our for loop.  This fails to work.  Why? */
/*for (string s = family2[0]; s != NULL; s = *(&s + 1)) {
    printf("%s\n", s);
}
*/
for (int j = 0; j < 3; j++)
{
    printf("%d ",family2[j]);
    printf("%d\n", strlen(family2[j]));
}
printf("\n");
int i = 0;
for (string s = family2[i]; i != 3; s = (s + strlen(family2[i]) + 2),i++) {
    printf("%d ",s);
    printf("%s\n", s);
}

system("pause");

}

это пример, переработанный из вашего кода, если вы запустите его, вы найдете изменение адреса точки и семейства2, тогда вы поймете взаимосвязь цикла № 3.