Discussion :

[coberle]

Bonjour,

J'ai une classe (A) qui possède une fonction (float getLength()) retournant un valeur. Dans certains cas, il peut se produire des erreurs au sein de cette fonction. Je me demandais donc quelle est la "best practice" pour gérer ce situations:
- possibilité 1 : je passe un code d'erreur : float getLength(int *erCode) et effecture un test en sortie :

Code :

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

1
2
3
4
5
 
int erCode=0;
float l=A.getLength(&erCode);
 
if erCode==1 // traitement de l'erreur

- possibilité 2 : je la méthode retourne le code d'erreur :int getLength(float *length) et effectue un test en sortie :

Code :

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

1
2
3
4
5
 
float length=0.0;
int erCode=A.getLength(&length);
 
if erCode==1 // traitement de l'erreur

Que recommande la pratique courante ? L'une de ces deux méthodes ou autre chose ?

Merci d'avance pour vos conseils.
Christian

[nikko34]

Tu peux utiliser les exceptions en C++.

[white_tentacle]

Ça dépend aussi de plusieurs choses :
- l'échec est-il un cas normal/fréquent ?
- veux-tu obliger le client à gérer le cas d'échec ?

Si la réponse est oui à la première question, il vaut mieux ne pas utiliser les exceptions. Si la réponse est oui à la deuxième, il vaut mieux utiliser les exceptions.

Si la réponse est oui aux deux, alors, mettre l'erreur en paramètre inout me semble assez adapté, car cela force le développeur à déclarer cette variable d'erreur, et donc, l'incite fortement à la gérer (alors qu'il est très facile d'ignorer une valeur de retour), tout en évitant la lourdeur des exceptions.

[Cheps]

Dans certains cas, il peut se produire des erreurs au sein de cette fonction.

C'est quel genre d'erreur qui peut se produire? Division par 0? Pointeur null? Bad alloc? ...?

L'erreur est-elle dépendante de l'objet appelant, ou uniquement de l'objet appelé?

[3DArchi]

Bonjour,
Si tu ne souhaites pas utiliser d'exceptions pour les raisons citées précédemment, tu peux utiliser Boost.Optional pour gérer les cas d'erreur. C'est le genre d'exemple approprié il me semble.

[NiamorH]

Si tu choisis un code d'erreur, penses à utiliser une enum plutôt qu'un bête int.

[Kalith]

Hum, d'après ce que j'ai lu sur Boost.Optional dans le lien que tu as donné, il me semble que ça fonctionne un peu comme un pointeur... avec l'inconvénient du "qui doit faire le delete?" en moins .
Ca peut être pratique, mais ça alourdi quand même un peu l'écriture (particulièrement gênant si c'est une fonction souvent utilisée).

Autre chose que tu pourrais éventuellement faire (un peu moins lourdingue que le std::pair<bool, T>) :

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
template<class T>
class Check
{
public :
 
    Check()
    {
        isValid = false;
    }
 
    Check(const T& init)
    {
        isValid = true;
        value = init;
    }
 
    T& Get()
    {
        return value;
    }
 
    bool IsValid() const
    {
        return isValid;
    }
 
    operator T() const
    {
        return value;
    }
 
    operator bool() const
    {
        return isValid;
    }
 
    static const Check<T> INVALID;
 
private :
 
    T    value;
    bool isValid;
 
};
 
template<class T>
const Check<T> Check<T>::INVALID = Check<T>();

Je l'ai rapidement testé, ça à l'air de fonctionner
Les soucis : ce template ne peux pas être utilisé avec le type bool à cause de l'opérateur de conversion implicite. Je ne pense pas non plus que ça soit une bonne idée de l'utiliser avec des types autres que ceux de base.

Exemple d'utilisation :

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
Check<float> SquareRoot(float value)
{
    if (value < 0.0f)
        return Check<float>::INVALID;
    else
        return sqrt(value);
}
 
int main()
{
    Check<float> f = SquareRoot(-1.0f);
    if (f)
    {
        float toto = 2+f;
        printf("%f\n", toto);
    }
}

[NiamorH]

@Kalith

sous Visual 2008 j'ai l'erreur C2593: 'operator +' is ambiguous

Il est déconseillé d'utiliser l'opérateur bool justement pour éviter cette ambiguïté avec les opérateurs mathématiques. On utilise plus souvent les opérateur void* et ! (cf. ofstream et ifstream).

Mais si j'ai le choix entre gérer le type bool ou permettre la syntaxe if (f), je préfère de loin la première option.