Discussion :

[cypher.sephiroth]

Bonjour,

Pour mon application GTK, je fais appel à une fonction de concaténation en C dont le code est le suivant :

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
32
33
34
35
36
37
38
39
40
41
char *concat (int Nombre_Args, ...)
{
    //Liste -variable- de chaînes de caractères à traiter
    va_list Liste_A_Traiter;
    //Compteur d'arguments
    int Compteur_Args;
    //Taille de la chaîne résultat
    size_t Taille;
    //Chaîne résultat
    gchar *Resultat_Concatene;
 
    //Initialisation de la liste à traiter, avec "Nombre_Args" variables
    va_start(Liste_A_Traiter, Nombre_Args);
    for (Taille = Compteur_Args = 0; Compteur_Args < Nombre_Args;
            Compteur_Args++)
        //Ajoute "Taille" et longueur de l'argument "Chaine de caractères"
        //courant à "Taille"
        Taille += strlen(va_arg(Liste_A_Traiter, gchar *));
    //Fin de traitement de la liste
    va_end(Liste_A_Traiter);
 
    //Réservation d'un bloc de taille "Taille + 1" en char
    Resultat_Concatene = (gchar *) malloc(Taille + 1);
    //Si la réservation s'est bien passée
    if (NULL != Resultat_Concatene)
    {
        //Initialisation de la liste à traiter, avec "Nombre_Args" variables
        va_start(Liste_A_Traiter, Nombre_Args);
        //On copie "" dans la chaine "Résultat_Concatene"
        strcpy(Resultat_Concatene, "");
        //Pour "Compteur_Args" allant de 0 à "Nombre_Args", et + 1
        for (Compteur_Args = 0; Compteur_Args < Nombre_Args; Compteur_Args++)
            //"Resultat_Concatene" recevra la copie des
            //différents éléments de la liste à traiter
            strcat(Resultat_Concatene, va_arg(Liste_A_Traiter, gchar *));
        //Fin de traitement de la liste
        va_end(Liste_A_Traiter);
    }
    //Renvoi de la chaine concaténée
    return Resultat_Concatene;
}

Je l'appelais par :

Code :

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

Nom_Complet = concat(2, Nom_Dossier, Nom_Fichier);

Et là, d'un coup, il me dit SegFault. Y'a quelque chose qui m'échappe. Pouvez-vous me donner des indices ?

[Médinoc]

Ne t'avais-je pas conseillé de séparer cette fonction en deux?

[Médinoc]

Tiens, essaie cette version corrigée:

Code C :

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
char *vconcat(int Nombre_Args, va_list Liste_A_Traiter)
{
	/*Copie du curseur de liste d'arguments,
	  (ou selon la plate-forme, de la liste entière)
	  pour mesurer la taille (oui, il faut deux parcours)*/
	va_list Liste_Comptage;
 
	/*Index de l'argument courant*/
	int Index_Arg;
	/*Longueur de la chaîne résultat, en caractères
	  ("taille" signifie qu'on compte le zéro terminal avec)*/
	size_t Longueur = 0;
	/*Chaîne résultat*/
	gchar *Resultat_Concatene;
 
	/*Crée la copie*/
	#ifdef va_copy
	va_copy(Liste_Comptage, Liste_A_Traiter);
	#else
	Liste_Comptage = Liste_A_Traiter;
	#endif
 
	/*Pour chaque argument de la copie*/
	for (Index_Arg=0; Index_Arg < Nombre_Args ; Index_Arg++)
		/*Ajoute longueur de l'argument "Chaine de caractères"
		  courant au total de longueur*/
		Index_Arg += strlen(va_arg(Liste_Comptage, gchar const*));
 
	/*Fin de traitement de copie:
	  Nettoie la copie.*/
	va_end(Liste_Comptage);
 
 
	/*Réservation d'un bloc de "Longueur + 1" caractères*/
	Resultat_Concatene = /*(gchar *)*/ malloc(Longueur + 1);
	/*Si la réservation s'est bien passée*/
	if (NULL != Resultat_Concatene)
	{
		/*Initialise le buffer de résultat à une chaîne vide*/
		strcpy(Resultat_Concatene, "");
		/*Pour chaque argument*/
		for (Index_Arg=0; Index_Arg < Nombre_Args; Index_Arg++)
			/*Concatène l'argument courant au résultat*/
			strcat(Resultat_Concatene, va_arg(Liste_A_Traiter, gchar const*));
	}
	/*Retour de la chaine concaténée*/
	return Resultat_Concatene;
}
 
char *concat(int Nombre_Args, ...)
{
	/*Liste -variable- de chaînes de caractères à traiter*/
	va_list Liste_A_Traiter;
	/*Chaîne résultat*/
	gchar *Resultat_Concatene;
 
	/*Initialisation de la liste à traiter, 
	  avec les arguments suivant Nombre_Args*/
	va_start(Liste_A_Traiter, Nombre_Args);
	/*Appel de la fonction qui prend une va_list*/
	vconcat(Nombre_Args, Liste_A_Traiter);
	/*Fin de traitement de la liste*/
	va_end(Liste_A_Traiter);
 
	/*Retour de la chaine concaténée*/
	return Resultat_Concatene;
}

Ça compile, mais je n'ai pas testé.

Quand au code d'avant, il a quand même l'air correct. Vérifie que les chaînes que tu lui passes sont valides (notamment, aucun des deux pointeurs ne doit être nul).

[cypher.sephiroth]

Ne t'avais-je pas conseillé de séparer cette fonction en deux?

Je le reconnais et bats ma coulpe sur la place du Capitole...
(mais ton bout de code me provoque : "Program received signal SIGABRT, Aborted.")
Et je re-bats ma coulpe, j'avais un des deux qui était initialisé à NULL.