Puntero global a matriz de puntero local

Tengo una serie de punteros a matrices, en una función. Necesito acceder a esa matriz en otra función.

Matriz de punteros

char *ptr[size + 1]; 

Hice un puntero global

 char *p; 

que señalé a ptr (en la misma función que ptr)

 p = *ptr; 

Entonces traté de acceder a ptr desde la otra función

 void otherFunction(void){ for(int n = 0; n < 6; n++) { char* str = &p[n]; printf("%i %s\n", n, str); } } 

cuando

 ptr[0] = "abcd" ptr[1] = "bcde" ptr[2] = "cdef" ptr[3] = "defg" ptr[4] = "efgh" ptr[5] = "fghi" 

la salida de otra otherfunction(); es:

 0 abcd 1 bcd 2 cd 3 d 4 5 

Quiero que la salida sea

  0 abcd 1 bcde 2 cdef 3 defg 4 efgh 5 fghi 

Mis preguntas son: (0) qué está mal aquí. (1) ¿Cómo lo arreglo? (2) ¿O hay una mejor manera de hacerlo? los requisitos son otherfunction() no puede tomar ningún argumento y ptr necesita permanecer local para su función. (Estoy seguro de que el otro código no contribuye al problema y nada está mal con ptr )

ptr es una matriz de puntero.

 char **p = ptr; char *str = p[n]; printf("%i %s\n", n, str); 

char *ptr[size + 1];

char* p = *ptr;

char* str = &p[n];

Esto hace que p apunte a la primera cadena de la matriz ptr de cadenas, y luego str iterará sobre esa cadena carácter por carácter. Creo que lo que querías hacer es esto:

 char** p = ptr; // p points to the first string of ptr ... char* str = p[n]; // str points to the nth string of ptr 

Aparte de eso, el uso de punteros globales no es una buena idea. Posiblemente sea mejor pasar ptr a la función otherFunction , que tendría el prototipo:

 void otherFunction(char** p); 

y lo llamas con ptr :

 otherFunction(ptr); 

(0) ¿Qué está pasando aquí? (1) ¿Cómo lo arreglo? (2) ¿O hay una mejor manera de hacerlo?

(0) Todo el diseño del progtwig. El uso de variables globales como esta, en particular los punteros, es una forma de progtwigción de espagueti y debe evitarse. Está creando acoplamientos y dependencias ajustadas entre todo tipo de partes no relacionadas en su progtwig.

En general, la presencia de punteros a punteros suele ser una indicación de un diseño deficiente. Los punteros a punteros tienen algunos usos válidos, para casos especiales como devolver un puntero modificado a través de un parámetro de función. No hay ninguna razón aparente para usarlos en su caso.

(1) Utilizando un par de calificadores de tipo y especificadores de almacenamiento para reducir el scope de esas variables globales desordenadas. En cambio, acceda a la matriz de punteros a través de las funciones de establecimiento / obtención.

(2) Sí, cambie el progtwig a algo como el siguiente código:

 static const char* ptr [] = { "abcd", "bcde", "cdef", "defg", "efgh", "fghi", NULL }; inline const char* get_str (size_t index) { return ptr[index]; } inline void set_str (size_t index, const char* str) { ptr[index] = str; }