Conversión implícita de char ** a const char **

Question

¿Por qué mi compilador (GCC) no emite implícitamente de char** a const char**?

Thie siguiente código:

#include <iostream> 

void print(const char** thing) { 
    std::cout << thing[0] << std::endl; 
} 

int main(int argc, char** argv) { 
    print(argv); 
} 

da el siguiente error:

oi.cpp: In function ‘int main(int, char**)’: 
oi.cpp:8:12: error: invalid conversion from ‘char**’ to ‘const char**’ [-fpermissive] 
oi.cpp:3:6: error: initializing argument 1 of ‘void print(const char**)’ [-fpermissive] 

Answer 1

una conversión de este tipo permitiría que coloques una const char* en su gama de char*, lo que sería peligroso. En print que podría hacer:

thing[0] = "abc"; 

Ahora argv[0] podría apuntar a una cadena literal que no puede ser modificado, mientras que main espera que sea no constante (char*). Por lo tanto, para la seguridad del tipo, esta conversión no está permitida.

Answer 2

Porque podría permitirnos modificar un valor constante. Lea aquí para comprender por qué: http://c-faq.com/ansi/constmismatch.html

Answer 3

@Fred Overflow link to the FAQ es una respuesta completa. Pero (lo siento Marshall) no es la explicación más clara. No sé si el mío es más claro, pero espero que sí.

---

La cosa es, si p es un puntero char*, entonces se puede utilizar para modificar como quiera que se apunta a.

Y si se pudiera obtener un puntero que apunta a ppp, pero con pp de tipo char const**, entonces se podría utilizar para asignar a ppp la dirección de un const char.

Y con eso, podría usar p para modificar el const char. O, pensarías que podrías. Pero ese const char podría estar incluso en la memoria de solo lectura & hellip;

En código:

char const  c = 'a'; 
char*    p = 0; 
char const**  pp = &p;    // Not allowed. :-) 

*pp = &c;  // p now points to c. 
*p = 'b';  // Uh oh. 

---

como una solución práctica a su código que no se compila, y hellip;

#include <iostream> 

void print(const char** thing) { 
    std::cout << thing[0] << std::endl; 
} 

int main(int argc, char** argv) { 
    print(argv); // Dang, doesn't compile! 
} 

just do & hellip;

#include <iostream> 

void print(char const* const* thing) 
{ 
    std::cout << thing[0] << std::endl; 
} 

int main(int argc, char** argv) 
{ 
    print(argv); // OK. :-) 
} 

Saludos & HTH.,

Answer 4

Nota, que si bien está prohibido

void dosmth(const char** thing); 

int main(int argc, char** argv) { 
    dosmth(argv); 

, puede y debe hacer

void dosmth(const char* const* thing); 

int main(int argc, char** argv) { 
    dosmth(argv); 

que es probablemente lo que quería de todos modos.El punto aquí es que thing ahora se refiere a una matriz const char* que a su vez es inmutable y cuyos valores de referencia char son inmutables. Por lo tanto, para un escenario de "mírelo, pero no lo cambie", const char* const* es el tipo de uso.

Nota: Utilicé el estándar más común (pero en mi opinión inferior) de intentar escribir el modificador const lo más izquierdo posible. Personalmente, recomiendo escribir char const* const* en lugar de const char* const*, ya que es mucho más conciso de esa manera.