Editer un tableau de chaînes depuis une fonction en C

[Goldoark]

J'ai besoin d'aide. C'est assez rare mais là je décroche.

 

Je voudrais créer une fonction qui copie un tableau de chaîne dans un autre, en C (compilateur mingw et code::block).

Voici le prototype de ma fonction :

int copy_string_array(
const char *ARRAY_OF_STRINGS_TO_COPY[],
int total_number_of_strings_in_the_array_to_copy,
char *copy_of_the_string_array[],
int length_of_a_string_in_the_copy_array,
int maximum_number_of_strings_in_the_copy_array)

 

La fonction renvoie le code d'erreur 0 (pas d'erreur) si tout s'est bien passé.

Son rôle est simple : elle lit chaque chaîne du premier tableau jusqu'à arriver au caractère '\0' qui marque la fin de la chaîne, et elle écrit dans le tableau copie la chaîne qu'elle a lu, caractère par caractère

(avec bien entendu des contrôles pour vérifier qu'il y a assez de place).

 

1 - Déjà, je ne sais pas comment déclarer mes tableaux de chaînes.

 

Habituellement, je fais comme ça pour le tableau déjà rempli :

char *string_array_1[] = {"machin", "truc", "bidule", "chose", "jesaispas"};

 

Mais pour le tableau vide, je fais comment ?

Comme ça ?

char string_array_2[100][6] = {0};

 

Donc en gros, mon appel de fonction ressemble à ça :

copy_string_array(string_array_1, 5, string_array_2, 100, 6);

 

Dans le corps de la fonction, j'arrive parfaitement à lire chaque chaîne du tableau, et à en extraire chaque caractère :

printf("%s\n", ARRAY_OF_STRINGS_TO_COPY[1]);
printf("%s\n", *(ARRAY_OF_STRINGS_TO_COPY + 1));
printf("%i\n", strlen(ARRAY_OF_STRINGS_TO_COPY[1]));
printf("%c\n", *(*(ARRAY_OF_STRINGS_TO_COPY + 1) + 2));

 

A noter que cette écriture fait planter le programme (pas la compilation) :

printf("%s\n", ARRAY_OF_STRINGS_TO_COPY[1][2]);

 

2 - Je croyais que les tableaux étaient des pointeurs, et qu'un tableau 2D était un pointeur sur pointeur, peut-être avais-je tort (ou peut-être est-ce mon compilateur qui ne supporte pas) ?

Pourquoi ne puis-je pas écrire comme ça ?

Et le problème fondamental se pose lorsque j'essaye d'écrire :

*(*(copy_of_the_string_array + 1) + 1) = *(*(ARRAY_OF_STRINGS_TO_COPY + 1) + 2);

Cette ligne fait planter le programme (mais pas la compilation).

Je soupçonne un problème de droits d'écriture avec les pointeurs, ou un truc plus complexe.

3 - Quelle est la bonne écriture pour écrire dans une chaîne d'un tableau de chaînes ?

Merci d'avance...

[BreizFenrir]

Ca fait quelques années que je n'ai pas sérieusement fait de C, mais je vais essayer de répondre à tes questions étant donné qu'elles ont (vaguement) l'air de rester à ma portée.

 

Quand tu déclares un tableau déjà initialisé, le compilateur se charge de gérer la mémoire nécessaire. Par contre, quand tu ne connais la taille du tableau qu'au cours de l'exécution, tu dois gérer la mémoire toi-même. Jette un coup d'oeil aux instructions malloc et free, qui sont conçues pour ça. Si tu ne réserves pas de la mémoire avec malloc, et que tu tentes d'écrire dedans... c'est la merde. Ou bien tu écrases des données inutiles, et bon le programmes fonctionne ; ou bien tu écrases des données utiles et ton programme ne fonctionne pas comme tu l'attends (mais peut en donner l'impression si on ne fait pas attention !) voire plante. Je suppose que c'est ce qui t'arrive justement ici.

[jrbleboss]

Premièrement, pourquoi as-tu besoin d'autant de paramètres dans ta méthode?

 

output est un tableau de pointeurs sur un char. Donc output[n] est un pointeur sur un char, dans le cas présent, c'est la string a l'index n dans output.

Comment initialiser ce tableau ? En deux étapes, premièrement, créer un tableau de char*, ca tu sais faire. Ensuite, il faut pour chaque string allouer la mémoire qui va contenir la copie de la string d'origine. Une fois l'espace alloué, une simple copie suffit (dans du vrai code il faut vérifier que malloc a bien fonctionné et utiliser une version safe de strcpy).

void copy_array_of_string(const char **input, int input_length, char **output)
{
	for (int i = 0; i < input_length; ++i)
	{
		output[i] = (char *)malloc(sizeof(char) * (strlen(input[i]) + 1));
		strcpy(output[i], input[i]);
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	const char * array[] = { "one", "two", "three", "four" };
	for (int i = 0; i < 4; ++i)
	{
		printf("array[%d] = %s\n", i, array[i]);
	}

	char * copy[4];
	copy_array_of_string(array, 4, copy);

	for (int i = 0; i < 4; ++i)
	{
		printf("array[%d] = %s\n", i, copy[i]);
	}

	getchar();

	return 0;
}

Qu'est sensé faire ce code ? 

*(*(copy_of_the_string_array + 1) + 1) = *(*(ARRAY_OF_STRINGS_TO_COPY + 1) + 2);

[lorinc]

Qu'est sensé faire ce code ? 

*(*(copy_of_the_string_array + 1) + 1) = *(*(ARRAY_OF_STRINGS_TO_COPY + 1) + 2);

 

Ben copier la troisième case de la deuxième chaine d'entrée dans la deuxième case de la deuxième chaine de sortie, pouqruoi ?

[Goldoark]

Désolé de la réponse tardive, j'ai eu un mémoire à faire entre temps.

J'ai trouvé ma réponse : il faut construire des tableaux dynamiques et passer leurs pointeurs, seule la première dimension peut-être laissée vide, que ce soit dans la déclaration ou dans les paramètres.