Discussion :

[boboss123]

Bonjour

voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
int parseArgs(const char* arg_list[], int arg_nb){
...
// => la fonction ne change pas le contenu des cahines pointées par arg_list
 
}
 
 
int main(void){
 
	char* arg_list[4]; // tableau de pointeur de string
 
	strcpy(arg_list[0], "toto");
	strcpy(arg_list[1], "tutu");
	strcpy(arg_list[2], "titi");
	strcpy(arg_list[3], "tata");
 
	parseArgs(arg_list, 4);
}

Dans la déclaration de ma fonction, le mot "const" dans "const char* arg_list[]" veut bien dire "la valeur pointée par le pointeur qui est dans le tableau arg_list[] ne peut être modifiée à l’intérieur de la fonction" ?

Si c'est le cas, alors pourquoi le compilo me renvoi comme erreur (sur l'appel de la fonction) :

note: expected 'const char **' but argument is of type 'char **'

Remarque : le code suivant ne génère pas de warning :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
void fooConst(const char *str){
...
}
 
int main(void){
	char *myStr = "hello world";
 
	fooConst(myStr); // pas de warning
}

[Bktero]

http://c.developpez.com/faq/index.ph...OINTEURS_const --> cette entrée de la FAQ devrait t'intéresser. Si tu échanges la position de const et char* dans la définition de ta fonction, tu n'as plus le warning.

[boboss123]

bonjour,

je ne suis pas sure de tout comprendre.

Ce que je veux définir : c'est un tableau qui contient des pointeurs qui pointe sur quelque chose de constant. Ce n'est pas le cas de ça ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
	char const * arg_list[4] = {"toto", "tutu", "titi", "tata"}; 
	const * arg_list2[4] = {"toto", "tutu", "titi", "tata"};
 
	arg_list[0] = "roro"; // je peux bien changer modifier les valeurs de mon tableau
	char const * ptStr = arg_list[0]; ptStr = "roro"; // fait la même chose que la ligne précédente
 
	//arg_list[0][0] = 'a'; // génère bien une erreur
	//ptStr[0] = 'a'; // génère bien une erreur
 
	foo(arg_list2, 4); // affiche ma liste
	// => génère un warning

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
void foo(char const * *argv,  int argNb){
	int i;
 
	for(i=0; i<argNb; i++){
		printf("%s\r\n", argv[i]);
	}	
}

=> je ne vois pas pourquoi avec arg_list2 j'ai un warning : on peut bien passer une variable non constante à une fonction qui attend une variable constante, non ?

[Bktero]

Dans ce cas, ce n'est pas uniquement dans la fonction que tu souhaites que les chaînes soit non modifiables, c'est tout le temps ?

Si je ne m'abuse, "const char* arg_list[]" est tableau contenant des pointeurs sur const char (chaînes non modifiables).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int parseArgs(const char* arg_list[], int arg_nb)
{
    printf("Fonction parseArgs");
    return 0;
}
 
int main(void){
 
    const char* arg_list[4]; // tableau de pointeur de string
 
    const char* chaine1 = "bonjour";
    const char* chaine2 = "je";
    const char* chaine3 = "suis";
    const char* chaine4 = "Bktero";
 
    //*(chaine4)="b"; // genere une erreur, chaine4 pointant sur une zone constante
    chaine4="Pierre"; // autorise, le pointeur n'est pas constant
 
    arg_list[1]=chaine1;
    arg_list[2]=chaine2;
    arg_list[3]=chaine3;
    arg_list[4]=chaine4;
 
    parseArgs(arg_list, 4);
 
    return 0;
}

Si tu reprends le code de ton premier message et que tu déclares arg_list comme moi (avec le const), tu verras les soucis. Tu ne peux pas copier avec strcpy dans une zone déclarée comme constante (d'ailleurs, tu n'as pas alloué les zones mémoires avec strcpy !) Je n'arrive pas à expliquer pourquoi ta fonction fooConst ne provoque pas de warning par contre....


Dans ton 2e message, n'aurais tu pas oublié un char dans "const * arg_list2[4] = {"toto", "tutu", "titi", "tata"};". Le code ne compile pas chez moi. Si je le rajoute, je n'ai pas de warning sur l'appel à foo. Je suis d'accord avec tes autres commentaires. D'ailleurs, tu peux réécrire la définition de la fonction ainsi "void foo(const char *argv[], int argNb)", pour retrouver ce que tu fais dans parseArgs de ton premier message.

[boboss123]

Dans ton 2e message, n'aurais tu pas oublié un char

Oui effectivement : c'est bien ça que je voulais écrire

Si je ne m'abuse, "const char* arg_list[]" est tableau contenant des pointeurs sur const char (chaînes non modifiables).

Donc c'est bien ce que je veux faire

Dans ce cas, ce n'est pas uniquement dans la fonction que tu souhaites que les chaînes soit non modifiables, c'est tout le temps ?

Non, c'est bien là le problème : je veux pouvoir modifier mes chaines en dehors de la fonctions (donc déclarer arg_list sans le mot "const") mais que le compilateur me génère une erreur si je tente de les modifier à l'intérieur de ma fonction la chaine.
En gros, je veux faire une fonction qui accepte en entrée des chaines modifiables et non modifiables => c'est par exemple le cas de la fonction strcpy :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
char * strcpy ( char * destination, const char * source );

Je n'arrive pas à expliquer pourquoi ta fonction fooConst ne provoque pas de warning par contre....

Chez toi aussi, il ne provoque pas d'erreur ?
Voici mon explication (à confirmer, je dis peut-être n'importe quoi :
Une variable 'const' est une variable dont on ne peut changer la valeur mais on peut la lire => donc on peut très bien affecter dans une variable 'non const' une valeur de variable 'const'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
char var;
const char cvar = 'a';
 
var = cvar; // normalement pas de warning
 
// par contre l'inverse n'est pas possible :
cvar = var;

Donc il me semble tout à fait normal que l'on puisse caster un pointeur de char sur un pointeur de const char vu que tout ce qu'il est possible de faire sur un const char (c'est à dire faire de la lecture) est faisable sur un char

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
char *ptVar;
const char *ptcVar;
 
ptcVar = &cvar;
ptVar = &var;
 
ptcVar = ptVar; // normalement pas de warning
 
// par contre l'inverse n'est pas possible :
// => car ptVar à le droit de modifier la valeur donc ça serait dangereux
ptVar = ptcVar;

=> est-ce que tu es d'accord avec moi ? tu comprend pourquoi ça marche maintenant ?
=> Si ce que j'ai dit est donc vrai, je ne comprend pas pourquoi mon premier exemple ne fonctionne pas : ne devrait-il pas y avoir un cast implicite dans mon premier exemple et donc ne pas générer de warning ?

[boboss123]

D'ailleur je viens de penser que vu que ma fonction ne va modifier aucun élément de arg_list, le prototype de la fonction devrait plutôt être :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int parseArgs(const char * const * arg_list, int arg_nb);

=> mais ça ne change rien