Discussion :

[poloDD]

Bonjour,

Voilà le code en question :

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
42
43
44
45
46
47
48
49
 
#include <iostream>
#include <string>
#include <cstdarg>
#include <csignal>
#include <unistd.h>
#include <cstring>
 
void tracer(const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
 
    while (*fmt != '\0')  {
        if (*fmt == 'd') {
            int i = va_arg(args, int);
            std::cout << i << " ";
        } else if (*fmt == 's') {
            char * s = va_arg(args, char*);
        std::cout << s << " ";           
        }
        ++fmt;
    }
    std::cout << std::endl;
 
    va_end(args);
}
 
int main()
{
    std::string str1( "Hello" ), str2( "world" );
 
    int k=10;
 
    // cas 1   
    //tracer("sds", str1.c_str(), 1, str2.c_str());  // OK 
    // cas 2
    //tracer("sds", str1.c_str(), k, str2.c_str(), 2, "ça marche");  // OK avec plus d'arguments que nécessaire
    // cas 3
    //tracer("sdsd", str1.c_str(), 3, str2.c_str(), "pas de SEGFAULT mais pas de sens");  // OK "pas de SEGFAULT mais pas de sens" affiche 4198152
    // cas 4
    //tracer("sdsdd", str1.c_str(), k, str2.c_str(), 5);  // OK la valeur de l'entier du dernier argument est aléatoire 
    // cas 5
    //tracer("sdss", str1.c_str(), k, str2.c_str(), 4);  // SEGFAULT : 4 n'est pas une chaîne  
    // cas 6
    tracer("sdsds", str1.c_str(), k, str2.c_str(), 5);  // SEGFAULT : manque une chaine dans les paramètres
 
    return 0 ;
}

Ainsi mon problème c'est que je n'arrive pas à trouver de moyen qui puisse m'éviter d'obtenir un SEGFAULT, si je ne rentre pas le bon format (cas 5) ou si j'oublie une chaîne dans les paramètres (cas 6).

Y aurait-t-il donc un moyen d'éviter ces SEGFAULT ?

Merci

[Médinoc]

À partir du C++11, tu peux faire une fonction template variadique à la place du ... classique.

[ternel]

Sinon, tu dois pouvoir vérifier le nombre d'argument, ou qu'il y en a assez.

à tout hasard, comment se comporte printf dans le même cas?
printf("%d%d",1); provoque-t-il une segfault?

[Ehonn]

à tout hasard, comment se comporte printf dans le même cas?
printf("%d%d",1); provoque-t-il une segfault?

C'est un comportement indéfini.
GCC émet des warnings si le format et le type son incohérent.

Note "amusante" : Si on inverse deux formats, GCC se permet d'inverser lui-même
Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// gcc -Wall -Wextra -Wconversion -Wsign-conversion -std=c99 -pedantic -fopenmp main.c -o main_c && ./main_c
// gcc -Wall -Wextra -Wconversion -Wsign-conversion -std=c99 -pedantic main.c -o main_c && valgrind ./main_c
 
#include <stdio.h>
 
 
int main()
{
	printf("int = %f | float = %d\n", 42, 73.21);
	return 0;
}

Compilation :

Code :

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

1
2
3
4
5
main.c: In function ‘main’:
main.c:9:2: warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
  printf("int = %f | float = %d\n", 42, 73.21);
  ^
main.c:9:2: warning: format ‘%d’ expects argument of type ‘int’, but argument 3 has type ‘double’ [-Wformat=]

Exécution :

Code :

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

int = 73.210000 | float = 42

[the Hound]

Au passage, sur GCC il y a __attribute__((format(printf, ...))) qui permet d'imiter le comportement de printf vis-à-vis des warnings à la compilation.

[Médinoc]

Note "amusante" : Si on inverse deux formats, GCC se permet d'inverser lui-même

Sous quelle plate-forme exactement? x86? x86-64? Peux-tu poster le code assembleur obtenu?

[poloDD]

Sinon, tu dois pouvoir vérifier le nombre d'argument, ou qu'il y en a assez.

Je peux compter le nombre d'arguments à partir du format. Mais comment faire pour compter le nombre de paramètres que je passe réellement à la fonction ? Et ainsi vérifier s'il correspond bien au format donné en premier argument.
Ce qui pose un problème notamment dans le cas 6 où le nombre de paramètre lors de l'appel de tracer() est inférieur au nombre d'arguments prévu par le format.

Et justement sur le modèle de printf qui permet de faire

Code :

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

printf("%d%d", 1)

ou

Code :

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

printf("%d%s", 1)

sans segfault, n'y aurait-il pas un moyen simple de faire la même chose. Ma fonction tracer() est en fait un printf low-cost mais j'aimerais tout de même la protéger contre les segfault.

[Médinoc]

Comme je le disais, en C++11 tu dois pouvoir vérifier cela avec une fonction template variadique; en C++03 tu dois pouvoir le simuler avec des surcharges de fonction templates, jusqu'à une certaine limite au nombre d'arguments (8 peut être raisonnable).

[PilloBuenaGente]

Bonjour,

comme l'a dit Médinoc, les variadiques templates serait préferable, à défaut de connaitre l'utilisation concrete de cette fonction voici un exemple :

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
//==============================================================================
#include <iostream>
//------------------------------------------------------------------------------
//Si seulement 1 argument
template<typename Type>
void draw(const Type& type)
{
    std::cout << type << std::endl;
}
//Plusieurs arguments
template<typename Type, typename... Tail>
void draw(const Type& type, const Tail&... tail)
{
    std::cout << sizeof...(Tail) << " ";//Compte le nombre d'arguments variadique
    static_assert(sizeof...(Tail) <= 4, "Trop d'arguments");//Tester à la compilation le nombre d'arguments
    std::cout << type << std::endl;
    draw(tail...);//Imprime le reste (fonction recursive)
}
//==============================================================================
int main(int, char**)
{
    draw("arg", 5, "bla", 85, 4);//ok
    draw("arg", 5, "bla", 85, 4, "arg_de_trop");//Erreur
    return 0;
}
//==============================================================================

[poloDD]

Comme je le disais, en C++11 tu dois pouvoir vérifier cela avec une fonction template variadique; en C++03 tu dois pouvoir le simuler avec des surcharges de fonction templates, jusqu'à une certaine limite au nombre d'arguments (8 peut être raisonnable).

Etant limité au C++03 j'ai utilisé les surcharges de fonctions templates de cette façon :

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
 
template<typename Type1>
void tracer1(const char * fmt, Type1 type1)
{
	if(strlen(fmt) <= 1)
		tracer(fmt, type1);
	else
		cout << "Trop d'arguments !" << endl; 
}
 
...
 
template<typename Type1, typename Type2, typename Type3, typename Type4, typename Type5, typename Type6, typename Type7, typename Type8, typename Type9>
void tracer9(const char * fmt, Type1 type1, Type2 type2, Type3 type3, Type4 type4, Type5 type5, Type6 type6, Type7 type7, Type8 type8, Type9 type9)
{
	if(strlen(fmt) <= 9)
		tracer(fmt, type1, type2, type3, type4, type5, type6, type7, type8, type9);
	else
		cout << "Trop d'arguments !" << endl; 
}

ça résout donc bien le problème du cas 6 (cf. 1er post) où j'ai moins de paramètres dans l'appel de tracer() que d'arguments prévu par le format.

Cependant, ça ne résout pas le segfault du cas 5 où je passe en paramètres un int au lieu d'un char* prévu par le format.

Une idée ?