Понимание операций разыменования, адреса и индекса массива в C

Операция индекса массива a[i] определяется как *(a + i) - учитывая адрес a, смещение i элементов (не байтов) от этого адреса и разыменование результата. Таким образом, для указателя p *p эквивалентно *(p + 0), что эквивалентно p[0].

Тип argv — char **; при этом верно все следующее:

    Expression         Type            Value
    ----------         ----            -----
          argv         char **         Pointer to a sequence of strings
         *argv         char *          Equivalent to argv[0]
        **argv         char            Equivalent to argv[0][0]
       argv[i]         char *          Pointer to a single string
      *argv[i]         char            Same as argv[i][0]
    argv[i][j]         char            j'th character of i'th string
      &argv[i]         char **         Address of the pointer to the i'th string

Поскольку тип argv[i][j] равен char, *argv[i][j] не является допустимым выражением.

Вот плохая визуализация последовательности argv:

     +---+              +---+                                         +---+
argv |   | ---> argv[0] |   | ---------------------------> argv[0][0] |   |
     +---+              +---+                     +---+               +---+
                argv[1] |   | -------> argv[1][0] |   |    argv[0][1] |   |
                        +---+                     +---+               +---+
                         ...           argv[1][1] |   |                ...
                        +---+                     +---+               +---+
             argv[argc] |   | ---|||               ...   argv[0][n-1] |   |
                        +---+                     +---+               +---+
                                     argv[1][m-1] |   |
                                                  +---+

Это может помочь объяснить результаты различных выражений.

char *argv[]

argv – это массив⁽¹⁾ указателей на символы. Так что это обычный массив, просто каждый элемент массива является указателем. argv[0] — указатель, argv[1] и т. д.

argv[0] - первый элемент в массиве. Поскольку каждый элемент в массиве является указателем на символ, значение this также является указателем на символ (как мы уже упоминали выше).

*argv[1] - Здесь argv[1] является вторым элементом в приведенном выше массиве, но argv[1] также является указателем на символ. Применение * просто разыменовывает указатель, и вы получаете первый символ в строке, на который указывает argv[1]. Вы должны использовать %c для его печати, так как это всего лишь символ.

argv[1][0] уже является первым символом второй строки в массиве, поэтому больше нет места для разыменования. Это по сути то же самое, что и предыдущее.

_{(1) как выделено, строго говоря, что это указатель на указатель, но, возможно, вы можете «думать» об этом как о массиве указателей. В любом случае больше информации об этом здесь: https://stackoverflow.com/a/39096006/3963067}

Если argv[1] является указателем на char, то *argv[1] разыменовывает этот указатель и дает вам первый символ строки в argv[1], поэтому он совпадает с argv[1][0] и печатается с описателем формата "%c".

argv[1][0] — это сам char, а не указатель, поэтому его нельзя разыменовать.

1. Это не относится к char *.
2. Вы можете упростить, в чем разница между *ptr и ptr[0].
3. Нет никакой разницы, потому что ptr[0] — это сахар для *(ptr + 0) или *ptr, потому что + 0 бесполезен.

// printf("%p\n", &argv[1]); is wrong you must cast to (void *)
printf("%p\n", (void *)&argv[1]);

Поскольку спецификатор %p ожидает void *, в обычном случае C автоматически продвигает ваш указатель в void *, но printf() использует список переменных аргументов. По этому поводу есть много правил, я предлагаю вам прочитать doc если хотите. Но char * не будет повышаться до void * и, как я уже сказал, printf(), кроме void *, так что у вас будет неопределенное поведение, если вы не примените его сами.

Последняя строка printf("%c\n",*argv[1]); одновременно разыменовывает argv и обращается к индексу массива 1. Другими словами, здесь выполняется argv[1][0], как и в предыдущей строке, поскольку доступ к индексу массива [1] имеет более высокий приоритет, чем оператор разыменования (*).

Однако, если бы вам нужно было заключить выражение в последней строке в скобки, чтобы оператор разыменования обрабатывался первым, вы бы сделали следующее:

printf("%c\n", (*argv)[1]);

Теперь, когда вы запускаете программу, последней строкой вывода будет argv[0][1] вместо [1][0], то есть второй символ в командной строке, которую вы используете для выполнения программы.