la programmation modulaire

Version imprimable

29/01/2010, 14h47
nomadstorm

la programmation modulaire

Bonjour,

Pour un programme qui comporte deux modules ,le premier module contient six fonctions et le deuxième quatres fonctions ,
je veux utiliser 3 ou plus de modules par exemple pour le module de six fonctions ,je veux les diviser en deux modules ,
alors comment procéder pour faire tout cela,

merci
29/01/2010, 15h00
3DArchi

Bonjour,
Peux-tu préciser ta question ? Qu'entends-tu par module ? des fichiers ? Peux-tu monter exactement ce que tu souhaites faire ?
29/01/2010, 16h22
koala01
Salut,

Si le sens de ta question est de savoir le nombre d'unité de compilation (de "couples" de fichiers *.cpp / *.h ) que tu peux créer, tu es totalement libre.

En fonction des besoins, tu peux en effet envisager:
- de regrouper toutes les déclarations de fonctions dans un seul fichier d'en-tête et leur implémentation dans un seul fichier *.cpp
- de regrouper toutes les déclarations de fonctions dans un seul fichier d'en-tête et leur implémentation dans plusieurs fichiers *.cpp
- de placer une déclaration de fonction par fichier d'en-tête et de regrouper toutes les implémentations dans un seul fichier *.cpp
- de placer une déclaration de fonction par fichier d'en-tête et une implémentation de fonction par fichier *.cpp
- de regrouper seulement certaines déclarations de fonctions dans un fichier et / ou de regrouper seulement certaines implémentations dans un fichier *.cpp
Le tout étant, en gros, de respecter un minimum de logique, qui pourrait se traduire par:
- le fait de veiller à ce que les fonctions (qu'il s'agisse de leur déclaration ou de leur implémentation) soient regroupées de manière cohérente (par exemple, par objectif poursuivi par les différentes fonctions)
- le fait de trouver une "granularité" qui te permettra de travailler "sereinement"
- le fait d'éviter autant que possible les dépendances inutiles

programmation modulaire

voila les differents programme:
je vois plus ou es le probleme:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include"dot.h"
#include <iostream>
#include <cmath>
 
using namespace std;
 
void saisir_point(point &p)
{
    cout << "Tapez l'abscisse du point : "; cin >> p.x;
    cout << "Tapez l'ordonnée du point : "; cin >> p.y;
}
 
void afficher_point(point p)
{
    cout << "Abscisse du point : " << p.x << endl;
    cout << "Ordonnée du point : " << p.y << endl;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#ifndef POINT_H
#define POINT_H
 
struct point
{
    double x,y;
};
 
void saisir_point(point &p);
void afficher_point(point p);
 
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "fract.h"
#include <iostream>
#include <cmath>
 
using namespace std;
 
 void saisie_fract (fract &F)
       {
            cout<< "donnez la valeur de numerateur de la fraction "<<endl;
            cin>>F.N;
            cout<<endl;
            cout<< "donnez la valeur de denominateur de la fraction "<<endl;
            cin>>F.D;
            cout<<endl;
            }
       void affichage_fract (fract F)
       {
            cout<<F.N<<"/"<<F.D<<endl;
            cout<<endl;
            }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef FRACT_H
#define FRACT_H
 
struct fract
{
    double N,D;
};
 
void saisie_fract(fract &F);
void affichage_fract(fract F);
 
 
#endif

Code:

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 "fraction.h"
#include <iostream>
#include <cmath>
 
using namespace std;
 
       fract add_fract (fract A,fract B)
       {
              fract C;
              C.N=((A.N*B.D)+(B.N*A.D));
              C.D=A.D*B.D;
              return (C);
              } 
       fract diff_fract (fract A,fract B)
       {
              fract C;
              C.N=((A.N*B.D)-(B.N*A.D));
              C.D=A.D*B.D;
              return (C);
              }  
       fract pro_fract (fract A,fract B)
       {
              fract C;
              C.N=A.N*B.N;
              C.D=A.D*B.D;
              return (C);
              }    
        fract rapp_fract (fract A,fract B)
       {
              fract C;
              C.N=A.N*B.D;
              C.D=A.D*B.N;
              return (C);
              } 
                void reduct_fract(fract F,fract &M)
{ double x,y;
  x=F.N;
  y=F.D;
    while (x!=y)  
    {
    if (x>y)
    x=x-y;
    else 
    y=y-x;
    }
    M.N=F.N/x;
    M.D=F.D/x;
    cout<<"la reduction de la fraction "<<F.N<<"/"<<F.D<<"est:"<< M.N<<"/"<<M.D<<endl; 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef FRACT_H
#define FRACT_H
 
struct fract
{
    double N,D;
};
 
 
fract add_fract(fract A, fract B);
fract diff_fract(fract A, fract B);
fract pro_fract(fract A, fract B);
fract rapp_fract(fract A, fract B);
void reduct_fract(fract F,fract &M);
 
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include"point.h"
#include <iostream>
#include <cmath>
 
using namespace std;
 
void distance(point a, point b)
{
    double dx,dy,d;
    dx = a.x - b.x;
    dy = a.y - b.y;
    d=sqrt( dx*dx + dy*dy );
    cout << "La distance de X à Y est : " << d << endl;
 
}
 
void milieu(point a, point b, point &m)
{
    m.x = (a.x + b.x) /2;
    m.y = (a.y + b.y) /2;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef POINT_H
#define POINT_H
 
struct point
{
    double x,y;
};
 
void distance(point a, point b);
void milieu(point a, point b, point &m);
 
#endif

Code:

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
#include "dot.h"
#include "point.h"
#include "fract.h"
#include "fraction.h"
#include <iostream>
#include <cmath> 
using namespace std;
 
 
        int main()
        {
            fract a,b;
            fract add,diff,pro,rapp;
            fract ADD,DIFF,PRO,RAPP;
 
            cout<<" saisie de la fraction F1 "<<endl;
            saisie_fract (a);
            cout<<" saisie de la fraction F2 "<<endl;
            saisie_fract (b);
             add =add_fract (a,b);
             diff=diff_fract (a,b);
             pro =pro_fract (a,b);
             rapp=rapp_fract (a,b);
 
cout<<"votre fraction addition vaut   "<<"=";
 
            affichage_fract (add);
            reduct_fract(add,ADD);
	        cout<< " FIN "<<endl;
 
cout<<"votre fraction difference vaut   "<<"=";
 
            affichage_fract (diff);
            reduct_fract(diff,DIFF);
	        cout<< " FIN "<<endl;
 
cout<<"votre fraction produit vaut   "<<"=";
 
            affichage_fract (pro);
            reduct_fract(pro,PRO);
	        cout<< " FIN "<<endl;
cout<<"votre fraction rapport vaut   "<<"=";
 
            affichage_fract (rapp);
            reduct_fract(rapp,RAPP);
	        cout<< " FIN "<<endl;
 
    point X,Y,Z;
 
 
    cout << "SAISIE DE X" << endl;
    saisir_point(X);
 
    cout << "SAISIE DE Y" << endl;
    saisir_point(Y);
 
//    distance(X,Y);
 
 
    milieu(X,Y,Z);
    cout << "AFFICHAGE DU POINT Z" << endl;
    afficher_point(Z);
 
 
system("PAUSE");
return 0;
}

29/01/2010, 17h15
koala01

Le principal problème est que tu as deux fichiers qui définissent la structure fract et le symbole préprocesseur FRACT_H...

Si j'en juge par le code, le premier fichier est très certainement nommé fract.h et l'autre... fraction.h
Du coup, lors de l'édition de liens, le système "perd la boule", ne sachant pas trop quelle structure fract il s'agit d'utiliser.

L'idéal serait, très certainement, de fusionner ces deux fichier de telle manière à ce qu'il n'y ai qu'un définition de la structure fract du symbole préprocesseur FRACT_H ;)

tu pourrait aussi envisager de fusionner les fichiers *.cpp correspondants ;)
29/01/2010, 17h54
nomadstorm

programmation modulaire

Ce que vous avez dit c est certainement juste,mais moi je veux plus que deux modules c'est pour cela que j'essaye de procéder comme précedemment .bref je veux savoir comment dissocier 2 modules point et fract en plusieurs modules

merci
29/01/2010, 22h41
koala01

A vrai dire, je ne comprend pas vraiment pourquoi tu voudrais en arriver à avoir plus de module que de structures qu'il te faut gérer...

Typiquement, lorsque tu as un objet de type point, tu ne sais pas à l'avance laquelle des N fonctions te permettant d'utiliser le point seront nécessaires / utiles / indispensables...

Parfois, tu n'aura, effectivement, besoin que d'une des fonctions, mais, tu auras sans doute souvent besoin... de toutes les fonctions qui manipulent ton point.

Dés lors, il semble "cohérent" de regrouper dans une seule et unique unité de compilation ta structure point et toutes les fonctions qui l'utilisent ;)

Et la réflexion est identique en ce qui concerne ta structure fract ;)

Maintenant, si l'idée est d'arriver à "cacher" le fonctionnement interne de ta structure (un peut à l'instar de ce que l'on rencontre en C avec la structure FILE), il est possible d'y arriver sans *forcément* multiplier les unités de compilation, et, de manière générale, une approche orientée objet semble le moyen le plus simple et le plus sur d'arriver au résultat escompté...

Et, là encore, cela ne nécessite nullement la multiplication des unités de compilations ;)

EDIT: en un mot, si tu arrives à justifier le fait que tu veux plus de deux modules, je t'aiderai à y arriver, mais il va falloir me convaincre que c'est réellement nécessaire ou intéressant, et ce n'est pas forcément gagné ;)
30/01/2010, 00h29
nomadstorm

programmation modulaire

merci pour votre réponse
la cause est très simple:notre professeur nous a demandé de réaliser ce programme avec plus de deux modules et cela pour arriver à maitriser et savoir manipuler avec les modules ,ainsi que lorsque j'ai essayé de faire j'ai certainement trouvé énormement de difficultés,et je veux savoir ou es le défauts(déclaration,redondance,ou bien autre chose)je veux bien que tu le compile pour voir les erreurs,et faire tourner le programme.

un point important :je suis tellement d'accord avec vous pour tous ce que vous avez dit ,mais quand essaye de m'aider pour les causes déja cités

rq:j'aime savoir la signification d'un message d'erreur instantiated from here ,il m'affiche ce message au niveau de l'appel de la fonction distance;

merci

Citation:

Envoyé par nomadstorm

rq:j'aime savoir la signification d'un message d'erreur instantiated from here ,il m'affiche ce message au niveau de l'appel de la fonction distance;

merci

cela t'indique qu'il y a un problème lorsque l'objet est instancié (créé) à l'endroit indiqué...

Seulement, le problème est signalé plus haut, et il est donc difficile de dire exactement ce qui se passe si tu ne fournis pas l'ensemble des messages d'erreurs ou d'avertissements que te donne le compilateur :P
merci pour votre réponse

Citation:

la cause est très simple:notre professeur nous a demandé de réaliser ce programme avec plus de deux modules et cela pour arriver à maitriser et savoir manipuler avec les modules ,ainsi que lorsque j'ai essayé de faire j'ai certainement trouvé énormement de difficultés,et je veux savoir ou es le défauts(déclaration,redondance,ou bien autre chose)je veux bien que tu le compile pour voir les erreurs,et faire tourner le programme.

un point important :je suis tellement d'accord avec vous pour tous ce que vous avez dit ,mais quand essaye de m'aider pour les causes déja cités

Nous allons jouer à un petit jeu, histoire de ne pas faire ton devoir nous même et de te faire réfléchir un tout petit peu (c'est le meilleur moyen d'apprendre :D)...

En effet, si on fait ton devoir à ta place, tu auras, sans doute, de bons points, mais tu n'aura rien appris :D

Je vais écrire ici les différentes remarques que ton code m'inspire, sans t'indiquer dans quelle partie du code le problème apparait.

Je vais essayer de regrouper les différentes remarques de manière à faire un tout cohérent :D

Et toi, tu va essayer de modifier ton code de manière à prendre ces remarques en compte, et tu nous le montrera afin que l'on puisse "rectifier le tir" en cas d'erreur.

Les directives préprocesseur:
Les directive préprocesseur sont toutes ces lignes qui commence par un "becarre" (sharp en anglais :D) " # "

Ce sont les premières expressions qui sont évaluées, juste après la suppression des commentaires, avant même de commencer la compilation proprement dite.

Lorsque tu crées un garde anti inclusion, il faut veiller à ce que le symbole que tu utilise soit défini de manière unique et non ambigüe, de manière à ce qu'il ne puisse jamais représenter plus d'un fichier d'en-tête donné.

La directive #include va se "contenter" de "copier" le fichier dont le nom est donné à l'endroit où la directive se trouve, et sert, de manière générale, à permettre au compilateur de disposer du contenu du fichier inclus.

La copie se fait de manière récursive, c'est à dire que, si un fichier A.h est inclus dans un fichier B.h et que ce fichier est lui-même inclus dans un fichier C.h, tu aura au final un résultat proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 début du fichier C.h /* la directive include B.h était ici */ début du fichier B.h /* la directive include A.h était ici dans B.h */ début du contenu A.h /* contenu du fichier A.h */ fin du fichier A.h /* reste du fichier B.h */ fin du fichier B.h /* reste du fichier C.h */ fin du fichier C.h
Le compilateur doit, entre autre, connaitre le contenu (la définition) des structures et des classes dés qu'il dois manipuler un objet, ou accéder à l'un des membres de l'objet, car il doit savoir quel espace mémoire est utilisé par l'objet et, au delà, où commencent les différents membre de l'objet afin d'y accéder

Par contre, si tu veux fournir, dans la déclaration d'une fonction, une référence ou un pointeur sur un objet, le compilateur peut se contenter de savoir... que le type existe (sans savoir de quoi il est réellement composé), pour autant que tu n'essaye pas d'effectivement accéder au contenu de l'objet passé en argument.

Il est alors possible d'utiliser le concept de déclaration anticipée des types.

Les références:
Une référence sont, tout simplement, l'alias d'un objet particulier.

Elles sont, entre autres, particulièrement utiles pour:

s'assurer qu'une modification apportée à l'objet à l'intérieur d'une fonction appelée soit répercutée sur l'objet dans la fonction appelante
éviter les copies inutiles d'objets, qui peuvent être gourmandes en ressources, tant en temps qu'en espace mémoire nécessaire, et qui peuvent parfois ne pas être autorisées (il existe certains mécanismes qui permettent de rendre un type non copiable, lorsque le type en question a sémantique d'objet et non sémantique de valeur)
s'assurer de l'existence de l'objet auquel elle font référence (du moins, au moment où l'on crées la référence) du fait de leur garantie de non nullité
Autant que faire se peut, nous essayerons de passer les objets "complexes" (comprend: tout ce qui entre dans la catégorie des type définis par l'utilisateur et qui n'est pas un simple typedef des types "primitifs") par référence, de manière à, justement, éviter les copies inutiles.

Si l'on souhaite s'assurer que la fonction appelée ne modifiera pas un objet passé par référence, nous pouvons déclaré l'argument comme étant une référence constante ( type const & ),et le compilateur nous appellera alors arthur si on essaie, effectivement, de modifier l'objet dans la fonction.

Il faut veiller en tout temps (à l'aide des gardes anti inclusion multiples) a respecter des règles connues en anglais sous les vocable "one definition rule" et "one declaration rule" (nous pouvons les traduire par "règle de la définition unique" et "règle de la déclaration unique").

La déclaration (le fait de dire qu'une fonction portant un nom donné et prenant un (ou des) type donnés en argument) des fonctions se fait, typiquement, dans un fichier d'en-tête (*.h *.hpp, pour les principales extensions) si elle est destinée à être invoquée au départ de plusieurs fichiers d'implémentation. (il est possible de déclarer une fonction dans un fichier d'implémentation si l'on a la certitude qu'elle ne sera jamais appelée que... par les fonctions qui sont définie dans le fichier d'implémentation... mais c'est un cas assez rare ;))

Deux fonctions peuvent avoir un même nom pour autant qu'elles prennent un nombre d'argument ou des arguments de types différents (chaque type d'argument étant évalué selon sa position)

Le type de retour d'une fonction n'intervient pas dans l'évaluation de la fonction qui sera effectivement appelée (Tu n'a pas besoin des deux infos précédentes ici, c'est juste "pour la culture générale" :D)

La définition (le fait de "donner un corps") des structures, classes et unions se fait, elle aussi, typiquement à l'intérieur d'un fichier d'en-tête, à moins, encore une fois, que l'on ait la certitude que le contenu de la dite structure ne soit jamais utilisée que dans un fichier d'implémentation particulier

La déclaration de fonction et la définition de structure doit se faire, lorsqu'elle a lieu dans un fichier d'en-tête, à l'intérieur des gardes anti inclusions multiples, de manière à être sur que si le fichier d'en-tête est inclus (souvent du fait des inclusions en cascades) plusieurs fois, les fameuses "one definition/declaration rules" soient respectées.

Une déclaration anticipée peut être répétée aussi souvent qu'on le souhaite, pour autant qu'elle survienne avant la définition réelle de la structure

Évidemment, pour respecter la "one definition rule", il ne faut implémenter une fonction que dans un et un seul fichier d'implémentation (*.cpp pour l'extension la plus couramment utilisée) ;)

Maintenant, à toi de jouer :D

30/01/2010, 22h54
nomadstorm

re:programmation modulaire

merci pour votre effort,

Sincérement,j'ai lit votre réponse plusieurs fois et j'ai essayé de suivre tes conseils remarquables,mais franchement je suis perdu sachant que je suis un débutant en C++ ,donc si tu corrige mon programme je te le jure de rester au moins 3 heures pour le comprendre.

désolé pour le dérrangement et merci pour vos aides.

pour les erreurs que tu m'a demandé:

In instantiation of `std::iterator_traits<point>':
instantiated from here
no type named `iterator_category' in `struct point'
no type named `value_type' in `struct point'
no type named `difference_type' in `struct point'
no type named `pointer' in `struct point'
no type named `reference' in `struct point'
31/01/2010, 19h05
nomadstorm

programmation modulaire

bonsoir
j'ai perdu énormément de temps à savoir ou es le problème,
si possible aidez moi,c'est très urgent

merci
02/02/2010, 20h54
nomadstorm

bizarre

salut tous le monde,

j'ai une petite et simple question à vous poser;est ce que mon problème admet une solution ou non ,comment utiliser 4 modules dans ce programme.
merci
02/02/2010, 21h03
koala01

Bien sur que ce problème admets des solutions...

Tu pourrais, très facilement créer jusqu'à 6 modles, même si tu le voulais, et si tu respectais les règles que j'ai tenté de faire passer ;)

Mais, comme je te l'ai dit, si on fait les choses à ta place, le jeu perd de son intérêt :D

N'ai pas peur de te "ridiculiser" en nous présentant tes solutions, fais juste de ton mieux ;)

Nous te "reprendrons" au fur et à mesure, en donnant des précisions ou en relevant les erreurs :D
03/02/2010, 12h24
nomadstorm

MERCI INFINIMENT

avant de commencer à vous présenter les inombrables modifications effecutés,j'insiste à vous remercier pour vos conseils:

pour les préprocesseu ,j'ai changé la nomenclature entre les deux modules de point,l'un POINT_H et l'autre DOT_H,ainsi que la meme chose pour la fraction.

autre modification:j'ai annulé la redéclaration de la structure point et fraction,j'ai déclaré la structure point dans le premier module et j'ai fai l'appel du fichier header .h dans le deuxieme modules

finalement ,le programme tourne,mais quand meme je veux savoir est qu'il ya d'autres améliorations,et avant tout est ce que cela coincide avec vos remarques

merci
03/02/2010, 22h14
koala01

Ce serait beaucoup plus facile si tu nous montrais le code tel qu'il est maintenant :D