Discussion :

[Francis Walter]

Bonjour,

Je vous présente un tutoriel sur les préconditions en C++ de Andrzej Krzemieński : https://akrzemi1.developpez.com/tuto...remiere-partie
Il s'agit de la première partie d'une série de quatre épisodes que nous allons faire l'effort de traduire et publier dans les jours à venir. Cette première partie a été traduite par kurtcpp que l'équipe de la rédaction tient à remercier sans oublier les autres contributeurs qui ont aidé à la correction.

N'hésitez pas à commenter le contenu de ce premier article en répondant à cette discussion.

P.-S. Si vous désirez contribuer aux traductions de ressources C++, vous pouvez me contacter par MP.



Les meilleurs cours et tutoriels pour apprendre la programmation C++

[RPGamer]

Excellente idée que cette traduction. Inspiré par un autre article sur le sujet, j'avais rédigé mes propres macros pour la validation de prédicats par le compilateur dans un simple fichier .hpp et c'est plutot efficace.

contract.hpp

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#ifndef __CONTRACT_HPP
#define __CONTRACT_HPP
 
#include <Uncopyable.hpp>
#include <type_traits>
#include <cassert>
 
/*!
 * \macro   require
 * \brief   Vérifie la validité d'une précondition.
 */
#if defined(CONTRACT_NO_PRECONDITION) || defined(CONTRACT_NO_CHECK)
    #define require(contract, text)
#else
    #define require(contract, text) assert(contract && text)
#endif
 
/*!
 * \macro   ensure
 * \brief   Vérifie la validité d'une postcondition.
 */
#if defined(CONTRACT_NO_POSTCONDITION) || defined(CONTRACT_NO_CHECK)
    #define ensure(contract, text)
#else
    #define ensure(contract, text) assert(contract && text)
#endif
 
/*!
 * \macro   invariant
 * \brief   Vérifie la validité d'un invariant.
 */
#if defined(CONTRACT_NO_INVARIANT) || defined(CONTRACT_NO_CHECK)
    #define invariant(contract, text)
#else
    #define invariant(contract, text) assert(contract && text)
#endif
 
/*!
 * \macro   invariants
 * \brief   Débute un bloc d'invariants de classe.
 */
#define invariants(classname) friend class InvariantsChecker<classname>; void _contract_check_invariants() const
 
/*!
 * \macro   check_invariants
 * \brief   Vérifie la validité des invariants de classe.
 */
#if defined(CONTRACT_NO_INVARIANT) || defined(CONTRACT_NO_CHECK)
    #define check_invariants()
#else
    #define check_invariants() _contract_check_invariants()
#endif
 
/*!
 * \macro   static_invariants
 * \brief   Débute un bloc d'invariants statiques de classe.
 */
#define static_invariants(classname) static void _contract_check_static_invariants() const
 
/*!
 * \macro   check_static_invariants
 * \brief   Vérifie la validité des invariants statiques de classe.
 */
#if defined(CONTRACT_NO_INVARIANT) || defined(CONTRACT_NO_CHECK)
    #define check_static_invariants()
#else
    #define check_static_invariants() _contract_check_static_invariants()
#endif
 
/*!
 * \class   InvariantsChecker
 * \brief   Vérifie la validité des invariants en début et en fin de scope.
 */
template <typename T>
class InvariantsChecker : private Uncopyable
{
    private:
 
        T *instance;
 
    public:
 
        InvariantsChecker(T *instance) :
            instance(instance)
        {
#if !defined(CONTRACT_NO_INVARIANT) && !defined(CONTRACT_NO_CHECK)
            instance->_contract_check_invariants();
#endif
        }
 
        ~InvariantsChecker()
        {
#if !defined(CONTRACT_NO_INVARIANT) && !defined(CONTRACT_NO_CHECK)
            instance->_contract_check_invariants();
#endif
        }
};
 
#endif // __CONTRACT_HPP

On peut alors facilement l'utiliser :

Code :

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

1
2
3
4
5
int divide(int dividend, int divisor)
{
    require(divisor != 0, "Division par zéro indéfinie.");
    return dividend / divisor;
}

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
class Square
{
    private:
 
        size_t width;
        size_t height;
 
        invariants(Square)
        {
            invariant(width == height, "Un carré a 4 côtés égaux.");
        }
 
    public:
 
        Square(size_t width, size_t height) : 
            width(width), height(height)
        {
            check_invariants();
        }
        void resize(size_t width, size_t height)
        {
            InvariantsChecker<Square> check(this);
            this->width = width;
            this->height = height;
        }
        size_t getWidth() const
        {
            InvariantsChecker<Square> check(this);
            return width;
        }
        size_t getHeight() const
        {
            InvariantsChecker<Square> check(this);
            return height;
        }
};

[Francis Walter]

Bonjour,

Je vous annonce la deuxième partie de la série de tutoriels sur les préconditions en C++ écrits par Andrzej Krzemieński. Elle a été traduite par kurtcpp.

Lire le tutoriel : Préconditions en C++ - Partie 2

Dans ce billet, je continuerai à partager mes réflexions sur les préconditions. Il traitera un peu de la philosophie qui est derrière le concept des préconditions (et des bugs), et étudiera la possibilité de mettre à profit le compilateur pour vérifier certaines préconditions. Plusieurs lecteurs ont fourni des retours utiles dans mon précédent billet, j'essaierai de les incorporer à celui-ci.

Autres ressources du même auteur : Blog de Andrzej Krzemieński.

[RPGamer]

En réutilisant les macros précédentes, faciles à mettre en oeuvre, on peut réaliser des "classes contractuelles" permettant d'imposer un contrat-type à une série de classes filles mais aussi de gérer les cas problématiques d'appels récursifs ou de retours multiples. 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
27
28
29
30
31
32
33
34
35
36
class ContractualClass
{
    private:
 
        virtual int doFunc(int n) // cette fonction est un exemple de retour multiple sans contrat
        {
            if (n > 0)
            {
                return 1/n;
            }
            else
            {
                return 2/n;
            }
        }
 
    public:
 
        int func(int n)
        {
            require(n != 0, "n différent de 0.");
            int ret = doFunc(n);
            ensure(ret >= -2 && ret <= 1, "Valeur de retour dans l'intervalle [-2, 1].");
            return ret;
        }
};
 
class InheritedContractClass : public ContractualClass
{
    private:
 
        virtual int doFunc(int n)
        {
            return 10*n; // violation du contrat de la classe mère !
        }
};

On peut même imaginer redéfinir un nouveau contrat qui entre dans le domaine du contrat hérité :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class InheritedContractClass : public ContractualClass
{
    public:
 
        int func(int n)
        {
            int ret = ContractualClass::func(n);
            ensure(ret >= -2 && ret <= 0, "Valeur de retour dans l'intervalle [-2, 0].");
            return ret;
        }
};

Ici la valeur de retour ne doit plus être comprise dans l'interval [-2, 1] mais dans un nouvel intervalle [-2, 0].

[Luc Hermitte]

Cela s'appelle le pattern NVI, pour Non-Virtual-Interface.
Par contre, cela se corse en cas d'héritage de multiple "interface/contrats" pour traiter les invariants.

-> http://luchermitte.github.io/blog/20...e-c-plus-plus/

[RPGamer]

Par contre, cela se corse en cas d'héritage de multiple "interface/contrats" pour traiter les invariants.

Avec l'approche que je donne, chaque implémentation (doFunc()) possède une fonction d'appel public (func()) vérifiant les invariants. Il n'y a donc aucune confusion sur le contrat. En revanche, un développeur imprudent pourrait alléger le contrat en redéfinissant la fonction d'appel public de façon erronée mais ça entre aussi dans le cadre du changement de portée permis par l'héritage C++ par exemple. En principe on ne le fait pas, à moins d'avoir une très bonne raison.