Pourquoi ne passant char** comme const char** générer un avertissement?

Réponse Courte

Vous pouvez en toute sécurité transtypage char ** à const char**? Pas. (Pas sûr de toute façon), et la raison est bien plus subtile que vous ne le pensez. Pouvez-vous vous débarrasser d'une autre façon? Assurez-vous. Charger un tableau de const char* valeurs de votre char* valeurs et les transmettre à la place. (ou de modifier le destinataire de l'appel de prototype, mais c'est de la triche =P).

Considérons le code suivant, qui fait essentiellement tout ce que vous êtes désireux sauf appeler une fonction. La ligne marquée illustre l'équivalent de point-de-cast

const char *s = "Test";
char *p = NULL;
char **pp = &p;             //Put address of our pointer in our pointer-to-pointer.
const char **cpp = pp;      //Here: assigning  char** to const char**
*cpp = s;                   //perfectly legal; pp and s both finish "char const"
*p = 0;                     //ru ro raggy

Il faut du temps pour vraiment regarder, et certes je ne l'avais pas vu au premier abord, soit. @sheu a fait un travail solide de l'attraper environ 24 heures avant que je vraiment réfléchi assez longtemps pour réaliser qu'il était la bonne (et je fait upvoted que répondre avant d'écrire celui-ci). Alors j'ai pensé qu'il avait tort à propos de la même époque, il pensait que sa réponse n'était pas applicable. S'avère que nous étions les deux mal sur ce saut, car il était juste la première fois, j'ai été mal la deuxième fois, et maintenant... pouah.

Sur VS2012 et VS2010 à la fois la ligne marquée signalera une erreur sans un plâtre. clang va le compiler avec un avertissement en C, mais le permettent (que j'ai trouvé surprenant). Donné, vous n'avez vraiment pas de sortir de votre endroit heureux de le casser, mais il est encore aucun-le-moins cassé.

Le reste de ce qui est une diatribe sur l'identification des types de pointeur, leur constness, et ce qui est équivalent à ce qui.

---

Longue Diatribe sur les Pointeurs Et Const

L'avertissement est parce que char ** et const char ** ne sont pas équivalentes (duh). Pour être correct, il pourrait résoudre le prototype (l'appelé), ou de fixer l'appelant (par le chargement d'un tableau de const char * et passant). Mais vous pouvez en toute sécurité transtypage de la première à la seconde? Hmmm....

Rappelez-vous, par la norme const va à l'élément immédiatement à son gauche. Déclarant sur le plus à gauche d'un type de données est un concept que la langue prend en charge, mais souvent introduit de la confusion ou de problèmes. Comme une règle-de-pouce, si const apparaît à l'extrême-gauche d'un decl immédiatement avant que le type, il s'applique aux données type; pas ultérieures pointeur (le cas échéant). Lorsqu'il apparaît à la droite de rien elle s'applique immédiatement à gauche decl-partie, que ce soit un type de données de la partie ou un pointeur de la partie, mais peu importe ce qu'elle s'applique seulement à un unique partie.

Une pléthore d'échantillons suit:

Pas D'Indirection:

const char ch;    //const character. must be initialized.
char const ch;    //same as above

Simple Indirection:

char *p;               //p is mutable, *p is mutable
const char *p;         //p is mutable, *p is const
char const *p;         //same as above.
char *const p;         //p is const, *p is mutable, must be initialized.
char const *const p;   //p is const, *p is const, must be initialized.

Double Indirection:

char **p;        //ptr-to-ptr-to-char
                 //p, *p, and **p are ALL mutable

const char **p;  //ptr-to-ptr-to-const-char
                 //p and *p are mutable, **p is const

char const **p;  //same as above

char *const *p;  //ptr-to-const-ptr-to-char
                 //p is mutable, *p is const, **p is mutable.

char **const p;  //const-ptr-to-ptr-to-char
                 //p is const, *p is mutable, **p is mutable.
                 //must be initialized.

const char **const p;  //const-ptr-to-ptr-to-const-char
                       //p is const, *p is mutable, **p is const.
                       //must be initialized.

char const **const p;  //same as above

char const *const *p;  //ptr-to-const-ptr-to-const-char
                       //p is mutable, *p is const, **p is const.

const char *const *p;  //same as above.

char *const *const p;  //const-ptr-to-const-ptr-to-char
                       //p is const, *p is const, **p is mutable.
                       //must be initialized.

Et de cours qui peuvent quitter la maison sans...

char const *const *const p;   //const-ptr-to-const-ptr-to-const-char
                              //everything is const.
                              //must be initialized.

const char *const *const p;   //same as above

Alors, comment cela affecte votre question? Lors de la compilation de ce code en C, sans un casting, vous aurez un avertissement du compilateur (ou une erreur si la compilation avec -Werror). Lors de la compilation en C++, vous aurez tout simplement l'erreur, car le paramètre de la signature ne correspond pas. Mais pourquoi?

Car ils ont pas d'équivalence directe:

const char **p;  //ptr-to-ptr-to-const-char
                 //p and *p are mutable **p is const

char **p;        //ptr-to-ptr-to-char
                 //p, *p, and **p are all mutable

Lors de la compilation avec clang, l'avertissement de C est donnée sous la forme:

principal.c:15:9: Passage char ** de paramètre de type const char ** rejets qualificatifs dans les types de pointeur.

VS2010 et VS2012 à la fois, sur l'autre main, jeter une erreur:

error C2440: 'initialisation' : impossible de convertir de 'char*' to 'const char **'

Il semble étrange, mais VS est en fait plus correct (merveilles jamais cesser).

Et qui fait beaucoup de sens. Niché dans la déclaration de type est le fait que le premier de ces ne permet pas de modification des données finales, la deuxième ne. À partir de ci-dessus, nous savons que char ** et const char ** (aka. char const **), sont pas le même. Au bas de l'un est un pointeur vers une const char, tandis que l'autre a un pointeur vers char.

L'avertissement vous indique que la fonction que vous appelez attend le paramètre donné que const char** mais vous êtes de passage un char** paramètre. Pour se débarrasser de cet avertissement vous pourriez

• vraiment passer dans un const char**
• jeté votre paramètre à une const char** (comme vous le faites actuellement)
• modifier le prototype de fonction, de sorte que la fonction attend un char**