Discussion :

[CLeBeR]

Bonjour,
Je suis en train de refaire tous les TP que j'ai fais en cours C++ pour m'entrainer à la dérivation de classe, polymorphisme... Car j'ai du mal avec ces notions.

J'ai une correction de l'exercice mais il y a plusieurs bouts de code que je ne comprends pas. Je mets la consigne en premier :



Je mets le code IntegrTrapezes.cxx :

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
/**
*
* @file    IntegrTrapezes.cxx
*
* @authors D. Mathieu
*
* @date    06/11/2007
*
* @version V1.0
*
* @brief   Integration par la methodes des trapezes au moyen de
*             pointeurs de fonctions
 
*
**/
#include <iostream>
#include <cmath>               // cos(), sin(), M_PI_2
 
using namespace std;
 
namespace
{
	template <typename T, typename TRes>
	class IUnaryFunction
	{
	public:
		virtual ~IUnaryFunction(void) {}
		virtual TRes operator () (const T &) const throw () = 0;
 
	}; // IUnaryFunction
 
	typedef double(*FdeX) (double);
 
	double IntegrTrapezes(FdeX f, double a, double b, unsigned n)
	{
		double S = (f(a) + f(b)) / 2.0;
		double Delta = (b - a) / double(n);
 
		for (; --n;) S += f(a += Delta);
 
		return S * Delta;
 
	} // IntegrTrapezes
 
	void TestIntegrTrapezes(void)
	{
		cout << "IntegrTrapezes : \n\n";
 
		cout << "Methode des trapezes : \n";
 
		cout << "S (cos (x)) entre 0 et +Pi/2  avec   5 intervalles = "
			<< IntegrTrapezes(cos, 0, M_PI_2, 5) << '\n';
 
		cout << "S (cos (x)) entre 0 et +Pi/2  avec  10 intervalles = "
			<< IntegrTrapezes(cos, 0, M_PI_2, 10) << '\n';
 
		cout << "S (cos (x)) entre 0 et +Pi/2  avec  50 intervalles = "
			<< IntegrTrapezes(cos, 0, M_PI_2, 50) << '\n';
 
		cout << "S (cos (x)) entre 0 et +Pi/2  avec 100 intervalles = "
			<< IntegrTrapezes(cos, 0, M_PI_2, 100) << '\n';
 
		cout << '\n';
 
		cout << "S (sin (x)) entre -Pi/2 et 0  avec   5 intervalles = "
			<< IntegrTrapezes(sin, -M_PI_2, 0, 5) << '\n';
 
		cout << "S (sin (x)) entre -Pi/2 et 0  avec  10 intervalles = "
			<< IntegrTrapezes(sin, -M_PI_2, 0, 10) << '\n';
 
		cout << "S (sin (x)) entre -Pi/2 et 0  avec  50 intervalles = "
			<< IntegrTrapezes(sin, -M_PI_2, 0, 50) << '\n';
 
		cout << "S (sin (x)) entre -Pi/2 et 0  avec 100 intervalles = "
			<< IntegrTrapezes(sin, -M_PI_2, 0, 100) << '\n';
 
	} // TestIntegrTrapezes()
 
} // namespace anonyme
 
int main()
{
	TestIntegrTrapezes();
 
	return 0;
 
} // main()

Voici la correction :

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
/**
 *
 * @file     FunctorIntegrTrapezes.cxx
 *
 * @authors  D. Mathieu
 *
 * @date     07/12/2011
 *
 * @version  V1.0
 *
 * @brief    Integration par la methodes des trapezes au moyen de
 *             functor
 
 *
 **/
#include <iostream>
#include <cmath>               // cos(), sin(), M_PI_2
 
using namespace std;
 
#define classdef typedef
 
namespace 
{
    template <typename T, typename TRes>
    class IUnaryFunction
    {
      public :
        virtual ~IUnaryFunction (void) {}
        virtual TRes operator () (const T &) const throw () = 0;
 
    }; // IUnaryFunction
 
    typedef IUnaryFunction <double, double> CUnFctor_dd;
 
    struct CFctor_cos : public CUnFctor_dd
    {
        virtual ~CFctor_cos() {}
        virtual double operator() (const double & x) const throw ()
        {
            return cos (x); 
 
        } // operator()
 
    }; // CFctor_cos
 
    struct CFctor_sin : public CUnFctor_dd
    {
        virtual ~CFctor_sin() {}
        virtual double operator() (const double & x) const throw ()
        {
            return sin (x); 
 
        } // operator()
 
    }; // CFctor_sin
 
    double IntegrTrapezes (const CUnFctor_dd & f,
                           double a, double b, unsigned n)
    {
        double S     = (f (a) + f (b)) / 2.0; 
        double Delta = (b - a) / double (n);
 
        for ( ; --n; ) S += f (a += Delta);
 
        return S * Delta;
 
    } // IntegrTrapezes
 
    void TestIntegrTrapezes (void)
    {
        cout << "IntegrTrapezes : \n\n";
 
        cout << "Methode des trapezes : \n";
 
        cout << "S (cos (x)) entre 0 et +Pi/2  avec   5 intervalles = " 
             << IntegrTrapezes (CFctor_cos(), 0, M_PI_2,   5) << '\n';
 
        cout << "S (cos (x)) entre 0 et +Pi/2  avec  10 intervalles = " 
             << IntegrTrapezes (CFctor_cos(), 0, M_PI_2,  10) << '\n';
 
        cout << "S (cos (x)) entre 0 et +Pi/2  avec  50 intervalles = " 
             << IntegrTrapezes (CFctor_cos(), 0, M_PI_2,  50) << '\n';
 
        cout << "S (cos (x)) entre 0 et +Pi/2  avec 100 intervalles = " 
             << IntegrTrapezes (CFctor_cos(), 0, M_PI_2, 100) << '\n';
 
        cout << '\n';
 
        cout << "S (sin (x)) entre -Pi/2 et 0  avec   5 intervalles = " 
             << IntegrTrapezes (CFctor_sin(), -M_PI_2, 0,   5) << '\n';
 
        cout << "S (sin (x)) entre -Pi/2 et 0  avec  10 intervalles = " 
             << IntegrTrapezes (CFctor_sin(), -M_PI_2, 0,  10) << '\n';
 
        cout << "S (sin (x)) entre -Pi/2 et 0  avec  50 intervalles = " 
             << IntegrTrapezes (CFctor_sin(), -M_PI_2, 0,  50) << '\n';
 
        cout << "S (sin (x)) entre -Pi/2 et 0  avec 100 intervalles = " 
             << IntegrTrapezes (CFctor_sin(), -M_PI_2, 0, 100) << '\n';
 
    } // TestIntegrTrapezes()
 
} // namespace
 
int main()
{
    TestIntegrTrapezes ();
 
    return 0;
 
} // main()

La première ligne que je ne comprends pas c'est dans le fichier IntegrTrapezes.cxx ligne 23,

Code :

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

 typedef double (*FdeX) (double);

Je ne comprends pas pourquoi faire un pointeur mélangé avec un double... J'ai du mal.

Maintenant dans le fichier FunctorIntegrTrapezes.cxx
Si j'ai bien compris, on dérive la classe IUnaryFunction en deux nouvelles classes cos et sin mais pourquoi faire cela car on utilisait une seule classe avant ? Est-ce pour qu'elle accepte plusieurs types de données ? ça ne m'a pas l'air d'être cela car on définit un typedef juste après (je ne comprends pas non plus ce typedef :

Code :

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

typedef IUnaryFunction <double, double> CUnFctor_dd;

ligne 35.

Enfin ligne 37, on définit une structure que l'on dérive, pourquoi faire cela ? Quand j'ai essayé de faire l'exercice j'ai crée une classe et non une structure :

Code :

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

struct CFctor_cos : public CUnFctor_dd

.
Merci de votre aide !

[Bousk]

typedef double (*FdeX) (double); est un pointeur de fonction. Vers une fonction qui retourne un double et prend un double en paramètre.

Enfin ligne 37, on définit une structure que l'on dérive, pourquoi faire cela ? Quand j'ai essayé de faire l'exercice j'ai crée une classe et non une structure :

http://cpp.developpez.com/faq/cpp/?p...lass-et-struct

[ternel]

Code :

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

typedef double (*FdeX) (double);

typedef déclare un qu'un nom n'est pas une variable mais un type

décomposont le dans l'ordre:
double (*FdeX) (double) est un type.
(*FdeX) (double) est le type d'une fonction qui retourne un double.
(*FdeX) est le type d'une fonction qui retourne un double et prend en argument un double.
FdeX est le type d'un pointeur de fonction qui retourne un double et prend en argument un double.

En fait, en C++11, tu pourrais écrire using FdeX = double (*)(double);, ce qui est un peu plus clair.


J'ai l'impression que tu n'as pas saisi qui dérive de quoi.

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 T, typename TRes>
class IUnaryFunction {
public :
    virtual ~IUnaryFunction() {}
    virtual TRes operator () (const T &) const throw () = 0;
};
 
typedef IUnaryFunction <double, double> CUnFctor_dd;
 
struct CFctor_cos : public CUnFctor_dd {
    virtual ~CFctor_cos() {}
    virtual double operator() (const double & x) const throw () { return cos (x); }
}; // CFctor_cos
 
struct CFctor_sin : public CUnFctor_dd {
    virtual ~CFctor_sin() {}
    virtual double operator() (const double & x) const throw () { return sin (x); }
};
 
double IntegrTrapezes (const CUnFctor_dd & f, double a, double b, unsigned n);

Voici dans l'ordre:

Code :

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

template <typename T, typename TRes> class IUnaryFunction {...}

Un modèle de classe, paramétré par deux types, T et TRes.
Il n'existe pas encore de class, mais pour chaque couple (A, B) de types, le compilateur pourra générer une class IUnaryFunction<A, B>.
Le I en début de nom semble suggérer que la classe sert d'interface (au sens javateux)

Remarque comme les seules fonctions sont virtuelles.
Cette interface défini une fonction qui est l'opérateur (). Cela permet d'utiliser un objet de cette classe comme une fonction.
Le fait que cette fonction prend un seul argument en fait une fonction unaire, d'où le nom de la classe.

Personnellement, j'aurai ajouté T comme valeur par défaut à TRes:
template <typename T, typename TRes = T> class IUnaryFunction {...}.

Code :

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

typedef IUnaryFunction <double, double> CUnFctor_dd;

Ceci annonce que CUnFctor_dd est le type IUnaryFunction<double, double>, c'est à dire la variante pour T=double et TRes = double de IUnaryFunction
Avec la valeur par défaut de TRes pour IUnaryFunction, on aurait pu écrire typedef IUnaryFunction <double> CUnFctor_dd;.

Code :

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

1
2
3
4
struct CFctor_cos : public CUnFctor_dd {
    virtual ~CFctor_cos() {}
    virtual double operator() (const double & x) const throw () { return cos (x); }
};

Voici la version matheuse mais française de ce fragment:
Soit CFctor_cos une classe héritant publiquement de CUnFctor_dd.
Son destructeur est virtuel, et ne fait rien de particulier.
Elle possède une fonction virtuelle nommée operator() qui renvoie un double, et prend un double nommé x en référence constante, et ne lève aucune exception (ce qu'on écrirait plutot nothrow en C++11). Sa défini est de renvoyer la valeur de cos(x).

Grosse remarque:
Une structure est une classe, une classe est une structure.
La différence, c'est que si tu ne précises rien, une classe hérite de manière privée de chacune de ses classes de bases, tandis qu'une structure le fait publiquement.
De même, une classe commence implicitement par un private: tandis qu'une structure commence implicitement par public:C'est la raison pour laquelle CFctor_cos ne commence pas par public:, alors que IUnaryFunction le faisait.

Au niveau compréhension, ca veut dire qu'une variable du type CUnFctor_dd const& peut référer un CFctor_cos, et sera utilisable comme une fonction.
Cette même référence peut être initialisée arbitrairement avec un CFctor_sin.

Du coup, si une fonction a cette variable comme argument, comme ta IntegrTrapezes le fait, on peut lui donner un foncteur arbitraire qu'elle utilisera comme elle le veut.

[CLeBeR]

Merci beaucoup pour vos explications !
Juste une petite précision :

ca veut dire qu'une variable du type CUnFctor_dd const& peut référer un CFctor_cos, et sera utilisable comme une fonction.

Grâce à l'opérateur virtuel justement ?
Pour le throw, on utilise maintenant noexcept, la correction date d'avant le C++11.

[ternel]

oui au deux remarques.

Une référence permet d'utiliser les fonctions virtuelles, dont l'opérateur ().

[CLeBeR]

Bonsoir,
J'ai encore une question qui porte sur le même thème, je me permets donc de poster sur le même sujet !
J'ai une autre classe abstraite ILessThanGen et deux classes dérivées CTriParAgeAsc et CTriParNomDesc qui permettent de trier des personnes en fonction de l'âge et du nom.

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
	class CPers
	{
		string   m_Nom;
		unsigned m_Age;
 
	public:
		CPers(const string & Nom, unsigned Age)
			: m_Nom(Nom), m_Age(Age) {}
 
		const string & GetNom(void) const throw () { return m_Nom; }
		unsigned       GetAge(void) const throw () { return m_Age; }
 
	private:
		ostream & _Edit(ostream & os)  const
		{
			return os << GetAge() << " - " << GetNom();
 
		} // _Edit()
 
	public:
		friend ostream & operator << (ostream & os, const CPers & P)
		{
			return P._Edit(os);
 
		}
 
	}; // CPers

Code :

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

1
2
3
4
5
6
7
8
	template <typename T>
	class ILessThanGen
	{
	public:
		virtual ~ILessThanGen(void) {}
		virtual bool operator () (const T &, const T &) const = 0;
 
	}; // ILessThanGen

Code :

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

1
2
3
4
5
6
7
8
9
10
11
	class CTriParAgeAsc : public ILessThanGen <CPers>
	{
	public:
		virtual bool operator () (const CPers & P1, const CPers & P2)
			const throw ()
		{
			return P1.GetAge() <= P2.GetAge();
 
		} // operator ()
 
	}; // CTriParAgeAsc

Code :

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

1
2
3
4
5
6
7
8
9
10
11
	class CTriParNomDesc : public ILessThanGen <CPers>
	{
	public:
		virtual bool operator () (const CPers & P1, const CPers & P2)
			const throw ()
		{
			return P1.GetNom() >= P2.GetNom();
 
		} // operator ()
 
	}; // CTriParNomDesc

je ne comprends pas pourquoi après la dérivation de ILessThanGen il y a <CPers>, à quoi cela correspond ?

De même, afin de rendre polymorphique le traitement des personnes, dans la fonction de tri, on utilise en paramètre un CLessThan, pourriez-vous m'expliquer la premier ligne où l'on utilise le template ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	template <typename Iter_t, class CLessThan>
	void SelectSort(Iter_t Deb, Iter_t Fin, const CLessThan & IsInf)
	{
		if (Fin <= Deb) return;
 
		for (; Deb < Fin - 1; ++Deb)
		{
			Iter_t RgMin = Deb;
			for (Iter_t j(Deb + 1); j < Fin; ++j)
				if (IsInf(*j, *RgMin)) RgMin = j;
			swap(*Deb, *RgMin);
		}
 
	} // SelectSort()

Merci de votre aide !

[bacelar]

je ne comprends pas pourquoi après la dérivation de ILessThanGen il y a <CPers>, à quoi cela correspond ?

ILessThanGen est une classe template, pour qu'une classe non template puisse en dériver, il faut la définition de la classe Mère soit complète.
Pour une classe template, il faut fournir tous les "paramètres template", donc ici le paramètre T de ILessThanGen.
ILessThanGen se sert de ce "paramètres template" pour la signature de son opérateur ().

, pourriez-vous m'expliquer la premier ligne où l'on utilise le template ?

ligne 2

Code :

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

void SelectSort(Iter_t Deb, Iter_t Fin, const CLessThan & IsInf)

C'est le type (+ou-) du 3ème paramètre de la fonction template.