Ce char* const argv[]?

Est-il un tableau de pointeurs const char ou un tableau de pointeurs const char?

Lire les types de droite à gauche:

const se lie toujours à gauche (sauf si il est sur la gauche)

char *const argv[]

                ^^ Array of
      ^^^^^        const
     ^             pointer to
^^^^               char

Un tableau de "const pointer" char

Donc les pointeurs dans le tableau ne peut pas être modifié.

Mais ce qu'ils pointent ne peut être modifiée.

Remarque: Comme l'a souligné Steve ci-dessous. Parce que c'est utilisé en tant que paramètre. Il fait se désintègre à un "Un pointeur vers "const pointer" à char" ou "char* const *".

Et j'ai un vector<string> maintenant, comment faire pour le convertir en char *const argv[]?

int execve(const char *path,
       char *const argv[],
       char *const envp[]);

int main()
{
    std::vector<std::string>   data;  ///fill
    std::vector<char*>         argv;
    std::vector<char*>         envp;

    for(std::vector<std::string>::iterator loop = data.begin(); loop != data.end(); ++loop)
    {
        argv.push_back(&(*loop)[0]);
    }

    //I also bet that argv and envp need to be NULL terminated
    argv.push_back(NULL);
    envp.push_back(NULL);
    execve("MyAppName", &argv[0], &envp[0]);
}

//says: argv is a constant pointer pointing to a char*
int main(int c, char *const argv[]);

Vous ne serez pas en mesure de changer "argv" à l'intérieur de la fonction.

Que vous êtes seulement à apprendre le C, je vous conseille de l'essayer vraiment de comprendre les différences entre les tableaux et les pointeurs d'abord au lieu de les choses communes.

Dans la zone de paramètres et de tableaux, il y a un peu de confusion des règles qui devraient être clairs avant d'aller sur. Tout d'abord, ce que vous déclarez dans une liste de paramètres est traité spécial. Il y a des situations où les choses n'ont pas de sens en tant que paramètre d'une fonction en C. ce sont

• Fonctions en tant que paramètres
• Les tableaux comme paramètres

Les tableaux comme paramètres

La deuxième est peut-être pas immédiatement clair. Mais il devient évident si l'on considère que la taille d'un tableau de dimension fait partie du type en C (et un tableau dont la taille de dimension n'est pas donné a un type incomplète). Ainsi, si vous créez une fonction qui prend un tableau par valeur (en reçoit une copie), alors il ne peut le faire que pour une taille! En outre, les tableaux peuvent être importantes, et C essaie d'être aussi rapide que possible.

En C, pour ces raisons, la matrice de valeurs ne sont pas inexistants. Si vous voulez obtenir la valeur d'un tableau, ce que vous obtenez à la place est un pointeur vers le premier élément de ce tableau. Et c'est en fait déjà se trouve la solution. Au lieu de dessiner un tableau de paramètre non valide à l'avant, un compilateur C va transformer le type de chaque paramètre un pointeur. Rappelez-vous ceci, c'est très important. Le paramètre ne sera pas un tableau, mais au lieu de cela, il sera un pointeur à chaque type d'élément.

Maintenant, si vous essayez de passer un tableau, ce qui est passé, au contraire, est un pointeur vers les matrices premier élément.

Excursion: Fonctions en tant que paramètres

La fin, et parce que je pense que cela va vous aider à mieux comprendre la question, regardons ce que l'état des choses, lorsque vous essayez d'une fonction en tant que paramètre. En effet, d'abord, il ne fera pas de sens. Comment un paramètre à une fonction? Hein, nous voulons une variable à la place, bien sûr! Donc, ce que le compilateur ne lorsque cela se produit, est, de nouveau, afin de transformer la fonction dans un pointeur de fonction. Essayez de passer une fonction va passer un pointeur à cette fonction à la place. Ainsi, les éléments suivants sont les mêmes (analogue à l'exemple du tableau):

void f(void g(void));
void f(void (*g)(void));

Notez que les parenthèses autour de *g est nécessaire. Sinon, elle serait de spécifier une fonction retournant void*, au lieu d'un pointeur à une fonction retournant void.

Retour à tableaux

Maintenant, je l'ai dit au début que les tableaux peuvent avoir un type incomplète - ce qui arrive si vous ne donnez pas une taille encore. Depuis que nous avons déjà compris qu'un paramètre de tableau n'est pas nulle, mais au lieu de tout paramètre de tableau est un pointeur, la taille du tableau n'a pas d'importance. Cela signifie que le compilateur va traduire tout ce qui suit, et tous sont la même chose:

int main(int c, char **argv);
int main(int c, char *argv[]);
int main(int c, char *argv[1]);
int main(int c, char *argv[42]);

Bien sûr, il ne fait pas beaucoup de sens pour être en mesure de mettre n'importe quelle taille, et il est tout simplement jetés. Pour cette raison, le C99 est venu avec un nouveau sens de ces chiffres, et permet d'autres choses à apparaître entre les parenthèses:

//says: argv is a non-null pointer pointing to at least 5 char*'s
//allows CPU to pre-load some memory. 
int main(int c, char *argv[static 5]);

//says: argv is a constant pointer pointing to a char*
int main(int c, char *argv[const]);

//says the same as the previous one
int main(int c, char ** const argv);

Les deux dernières lignes dire que vous ne serez pas en mesure de changer "argv" dans la fonction, il est devenu un const pointeur. Seulement quelques compilateurs C support de ces fonctions C99 bien. Mais ces caractéristiques, il est clair que le "tableau" n'est pas vraiment une. C'est un pointeur.

Un mot d'Avertissement

Remarque que tout ce que je dit plus haut est vrai que si vous avez un tableau comme paramètre d'une fonction. Si vous travailler avec les tableaux, un tableau ne sera pas un pointeur. Il se comporte comme un pointeur, parce que, comme expliqué plus tôt, un tableau sera converti en pointeur lorsque sa valeur est lue. Mais il ne doit pas être confondue avec les pointeurs.

Un exemple classique est le suivant:

char c[10]; 
char **c = &c; //does not work.

typedef char array[10];
array *pc = &c; //*does* work.

//same without typedef. Parens needed, because [...] has 
//higher precedence than '*'. Analogous to the function example above.
char (*array)[10] = &c;