Puntero a una cadena en C?

char *ptrChar;

Yo sé eso ptrChar es un puntero a carbonizarse. ¿Cuál es el comando para un puntero a cadena?

Editar: Si es lo mismo (ptr to char vs. ptr to string), ¿qué representa la siguiente definición de variable?

char (*ptr)[N];

Estoy confundido.

Se utiliza la misma notación para apuntar a un solo carácter o al primer carácter de una cadena terminada en nulo:

char c="Z";
char a[] = "Hello world";

char *ptr1 = &c;
char *ptr2 = a;      // Points to the 'H' of "Hello world"
char *ptr3 = &a[0];  // Also points to the 'H' of "Hello world"
char *ptr4 = &a[6];  // Points to the 'w' of "world"
char *ptr5 = a + 6;  // Also points to the 'w' of "world"

Los valores en ptr2 y ptr3 son lo mismo; así son los valores en ptr4 y ptr5. Si va a tratar algunos datos como una cadena, es importante asegurarse de que tengan una terminación nula y que sepa cuánto espacio hay para usar. Muchos problemas son causados ​​por no entender qué espacio está disponible y no saber si la cadena terminó correctamente en nulo.

Tenga en cuenta que todos los punteros anteriores se pueden desreferenciar como si fueran una matriz:

 *ptr1    == 'Z'
  ptr1[0] == 'Z'

 *ptr2    == 'H'
  ptr2[0] == 'H'
  ptr2[4] == 'o'

 *ptr4    == 'w'
  ptr4[0] == 'w'
  ptr4[4] == 'd'

  ptr5[0] ==   ptr3[6]
*(ptr5+0) == *(ptr3+6)

Adición tardía a la pregunta

Que hace char (*ptr)[N]; ¿representar?

Esta es una bestia más compleja por completo. Es un puntero a una matriz de N caracteres. El tipo es bastante diferente; la forma en que se usa es bastante diferente; el tamaño del objeto señalado es bastante diferente.

char (*ptr)[12] = &a;

(*ptr)[0] == 'H'
(*ptr)[6] == 'w'

*(*ptr + 6) == 'w'

Tenga en cuenta que ptr + 1 apunta a territorio indefinido, pero apunta ‘una matriz de 12 bytes’ más allá del comienzo de a. Dado un escenario ligeramente diferente:

char b[3][12] = { "Hello world", "Farewell", "Au revoir" };

char (*pb)[12] = &b[0];

Ahora:

(*(pb+0))[0] == 'H'
(*(pb+1))[0] == 'F'
(*(pb+2))[5] == 'v'

Probablemente no encontrará punteros a matrices excepto por accidente durante bastante tiempo; Los he usado un par de veces en los últimos 25 años, pero tan pocos que puedo contar las ocasiones con los dedos de una mano (y varios de ellos han estado respondiendo preguntas sobre Stack Overflow). Más allá de saber que existen, que son el resultado de tomar la dirección de un arreglo y que probablemente no lo querías, realmente no necesitas saber más acerca de los punteros a los arreglos.

Lo mismísimo. La cadena AC no es más que una matriz de caracteres, por lo que un puntero a una cadena es un puntero a una matriz de caracteres. Y un puntero a una matriz es lo mismo que un puntero a su primer elemento.

La cadena está básicamente delimitada desde el lugar al que apunta (char *ptrChar;), al carácter nulo (\0).

El char *ptrChar; en realidad apunta al comienzo de la cadena (matriz de caracteres) y, por lo tanto, ese es el puntero a esa cadena, así que cuando te gusta ptrChar[x] por ejemplo, en realidad accede a la ubicación de la memoria x veces después del comienzo del carácter (también conocido como desde donde apunta ptrChar).