IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

fonction retournant toujours 0.000 ?


Sujet :

C

  1. #1
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut fonction retournant toujours 0.000 ?
    Bonjour, voilà j'ai crée une fonction mais lorsque je lui donne les paramètres nécessaires à son fonctionnement, elle me retourne 0.000 pour n'importe quelle valeur ?!?!?

    fichier .c du programme
    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
    #include <stdio.h>
    #include <stdlib.h>
    #include "samsoft_maths.h" //Contient les prototypes des fonctions de la Dll
     
    int main()
    {
        double x; //côté du dessus//
        double y; //base//
        double z; //hauteur//
        double aire;
     
                printf("\nTapez votre nombre x : ");
                fflush(stdout); 
                scanf("%lf", &x);
    	printf("\nTapez votre nombre y : ");
                fflush(stdout); 
                scanf("%lf", &y);
    	printf("\nTapez votre nombre z : ");
                fflush(stdout); 
                scanf("%lf", &z);
                aire = ss_aire_trapeze(x, y, z);//Appel de la fonction ss_aire_trapeze
                printf("l'air du trapèze vaut %lf\n", aire);
    	system("PAUSE");
    	return EXIT_SUCCESS;
    }
    fichier .c de la dll (contenant les fonctions)
    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
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    /*
    Fichier : samsoft_maths.c
    Auteur : Samy Hocine (SamSoft) http://www.samsoft.ift.fr ; samyhocine@hotmail.fr
    Date du commencement: Mercredi 4 fervrier 2007
    Description : Dll incluant divers fonctions mathématiques
    Licence : GNU/GPL
    Information : ss ou SS veut dire SamSoft
    */
     
    #include "samsoft_maths.h"
     
    const double PI = 3.1415926535897932384626433832795;
     
    double SAMSOFT_MATHSDLL_API ss_carre(double a)
    {
        return a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_cube(double a)
    {
        return a*a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_perimetre_cercle(double r)
    {
        return 2*PI*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_cercle(double r) //r = rayon//
    {
        return PI*r*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_triangle(double b, double h) //triangle quelconque, b = base et h = hauteur//
    {
        return (b*h)/2;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_equi(double a) //triangle équilateral, a est la longeur d'un côté//
    {
     
        int increment;
        double resultat;
        double an;
        double an1;
     
        if (a >= 0)
        {
            an=a;
            for (increment=0;increment<8;increment++)
            an1=(an+(a)/an)/2;
            resultat==an1;
            return resultat;
        }
        else if (a < 0)
        {
            return -0.00000;
        }
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_rect(double b, double c) //triangle rectangle, b et c sont les longeurs de deux côtés autres que l'hypothénuse//
    {
        return (b*c)/2;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_rectangle(double l, double m)//l = longeur ; m = largeur/
    {
        return l*m;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_carre(double a)//a étant la longeur d'un côté//
    {
        return a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_parallelogramme(double b, double h)//b étant la base et h la hauteur//
    {
        return b*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_losange(double b, double h)//b étant la base et h la hauteur//
    {
        return (b*h)/2;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_trapeze(double a, double b, double h)//b étant la base et h la hauteur et a la longeur du côté du dessus//
    {
        double r;
        r = (1/2)*(a+b)*h;
        return r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_shpere(double r)//r étant le rayon de la sphère//
    {
        return 4*PI*r*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_sphere(double r)//r étant le rayon de la sphère//
    {
        4/3*PI*r*r*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_pyramide(double b, double h)//b est la base d'aire et h la hauteur//
    {
        return 1/3*b*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_tetraedre(double b, double h)//b est la base d'aire et h la hauteur//
    {
        return 1/3*b*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_cone_revolution(double r, double h)//r est le rayon de la base qui est un cercle et h la hauteur//
    {
        return 1/3*PI*r*r*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_pave_droit(double a, double b, double c)//a, b et c sont des longeurs//
    {
        return 2*(a*b+b*c+a*c);
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_pave_droit(double a, double b, double c)//a, b et c sont des longeurs//
    {
        return (a*b*c);
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_cube(double a)//a étant la longeur d'un côté//
    {
        return 6*a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_cube(double a)//a étant la longeur d'un côté//
    {
        return a*a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_cylindre_revolution(double r, double h)//r est le rayon de la base (qui est un cercle) et h la hauteur entre la base et la surface du dessus//
    {
        return PI*r*r*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_addition(double a, double b)
    {
        return a+b;
    }
     
    double SAMSOFT_MATHSDLL_API ss_soustraction(double a, double b)
    {
        return a-b;
    }
     
    double SAMSOFT_MATHSDLL_API ss_multiplication(double a, double b)
    {
        return a*b;
    }
     
    double SAMSOFT_MATHSDLL_API ss_division(double a, double b)
    {
        return a/b;
    }
     
    double SAMSOFT_MATHSDLL_API ss_cal_a_b_fct_lineaire(double x, double fx, double y1, double y2, double x1, double x2)
    {
        //fonction permettant de trouver a et b d'une fonction linéaire de manière algébrique//
        //fonction exemple : f(x) = ax + b
        double a;
        double b;
        char r; //resultat//
     
        a = (y1 - y2)/(x1 - x2);
        b = fx - a*x;
        r = ("f(x) = %d%d + %d", a, x ,b);
        return r;
    }
    fichier .h à integrer dans la dll et dans le programme
    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
    /*
    Fichier : samsoft_maths.h
    Auteur : Samy Hocine (SamSoft) http://www.samsoft.ift.fr ; samyhocine@hotmail.fr
    Date du commencement: Mercredi 4 fervrier 2007
    Description : None
    Licence : GNU/GPL
    Information : ss ou SS veut dire SamSoft
    */
     
    #ifndef H_TC_SAMSOFT_MATHSDLL_20070214181222
    #define H_TC_SAMSOFT_MATHSDLL_20070214181222
     
    #ifdef SAMSOFT_MATHSDLL_BUILD
    #define SAMSOFT_MATHSDLL_API __declspec(dllexport)
    #else
    #define SAMSOFT_MATHSDLL_API __declspec(dllimport)
    #endif
     
    extern const double PI;
     
    double SAMSOFT_MATHSDLL_API ss_carre(double a);
    double SAMSOFT_MATHSDLL_API ss_cube(double a);
    double SAMSOFT_MATHSDLL_API ss_perimetre_cercle(double r);
    double SAMSOFT_MATHSDLL_API ss_aire_cercle(double r);
    double SAMSOFT_MATHSDLL_API ss_aire_triangle(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_equi(double a);
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_rect(double b, double c);
    double SAMSOFT_MATHSDLL_API ss_aire_rectangle(double l, double m);
    double SAMSOFT_MATHSDLL_API ss_aire_carre(double a);
    double SAMSOFT_MATHSDLL_API ss_aire_parallelogramme(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_losange(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_trapeze(double a, double b, double h);
    double SAMSOFT_MATHSDLL_API ss_ss_aire_shpere(double r);
    double SAMSOFT_MATHSDLL_API ss_volume_sphere(double r);
    double SAMSOFT_MATHSDLL_API ss_volume_pyramide(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_volume_tetraedre(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_volume_cone_revolution(double r, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_pave_droit(double a, double b, double c);
    double SAMSOFT_MATHSDLL_API ss_volume_pave_droit(double a, double b, double c);
    double SAMSOFT_MATHSDLL_API ss_aire_cube(double a);
    double SAMSOFT_MATHSDLL_API ss_volume_cube(double a);
    double SAMSOFT_MATHSDLL_API ss_volume_cylindre_revolution(double r, double h);
    double SAMSOFT_MATHSDLL_API ss_addition(double a, double b);
    double SAMSOFT_MATHSDLL_API ss_soustraction(double a, double b);
    double SAMSOFT_MATHSDLL_API ss_multiplication(double a, double b);
    double SAMSOFT_MATHSDLL_API ss_division(double a, double b);
    double SAMSOFT_MATHSDLL_API ss_cal_a_b_fct_lineaire(double x, double fx, double y1, double y2, double x1, double x2);
     
    #endif
    Quelle est la solution à mon problème ?

    Merci,

  2. #2
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par _SamSoft_
    Bonjour, voilà j'ai crée une fonction mais lorsque je lui donne les paramètres nécessaires à son fonctionnement, elle me retourne 0.000 pour n'importe quelle valeur ?!?!?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    double SAMSOFT_MATHSDLL_API ss_aire_trapeze(double a, double b, double h)//b étant la base et h la hauteur et a la longeur du côté du dessus//
    {
        double r;
        r = (1/2)*(a+b)*h;
        return r;
    }
    1/2 vaut 0 (division entière). Pour avoir une division réelle, il faut mettre 1.0/2 ou 1/2.0 ou 0.5

    Il y a des abominations dans ton code. Par 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
     
    double SAMSOFT_MATHSDLL_API ss_cal_a_b_fct_lineaire(double x, double fx, double y1, double y2, double x1, double x2)
    {
        //fonction permettant de trouver a et b d'une fonction linéaire de manière algébrique//
        //fonction exemple : f(x) = ax + b
        double a;
        double b;
        char r; //resultat//
     
        a = (y1 - y2)/(x1 - x2);
        b = fx - a*x;
        r = ("f(x) = %d%d + %d", a, x ,b);
        return r;
    }
    Pourquoi, avant de faire une DLL, tu n'as pas testé tes fonctions unes par unes dans un simple fichier séparé ?

    Tu additionnes les problèmes au lieu de les traiter un par un...
    (et tu n'as toujours pas retiré le TC_ ...)

  3. #3
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Par défaut
    A quoi te servent les paramètres x et fx dans le code mis en évidence Emmanuel. Si tu as deux points (x1, y1) et (x2, y2), cela suffit à calculer les paramètres d'une droite. On obtient deux équations à deux inconnues. Problème simple à résoudre.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    double SAMSOFT_MATHSDLL_API ss_cal_a_b_fct_lineaire(double x, double fx, double y1, double y2, double x1, double x2)
    {
        //fonction permettant de trouver a et b d'une fonction linéaire de manière algébrique//
        //fonction exemple : f(x) = ax + b
        double a;
        double b;
        char r; //resultat//
     
        a = (y1 - y2)/(x1 - x2);
        b = fx - a*x;
        r = ("f(x) = %d%d + %d", a, x ,b);
        return r;
    }
    Tu peux procéder comme cela:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    a = (y1 - y2)/(x1 - x2);
    b = a*x1 - y1;
    De plus, comme l'a rappelé Emmanuel, les tests unitaires sont incontournables afin de t'assurer que chaque unité de code fait correctement son travail (répond aux spécifications) et est robuste.

    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  4. #4
    Membre expérimenté
    Inscrit en
    Décembre 2003
    Messages
    272
    Détails du profil
    Informations forums :
    Inscription : Décembre 2003
    Messages : 272
    Par défaut
    Ta fonction ss_aire_triangle_equi fait n'importe quoi, en particulier le
    resultat==an1;
    ne fait rien. D'ailleurs ton compilateur aurait du te prévenir.

  5. #5
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    quelle horreur....

  6. #6
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut Réponse
    Je vais vous rédiger une réponse pour chaque commentaire :

    1/2 vaut 0 (division entière). Pour avoir une division réelle, il faut mettre 1.0/2 ou 1/2.0 ou 0.5
    1) Je n'ai même pas pensé une seconde que 1/2 valait 0, c'est bizarre, j'ai pourtant déclarer des doubles, mais bon , je vais donc écrire 0.5 la prochaine fois

    et tu n'as toujours pas retiré le TC_
    2) Désolé mais pour moi ce n'est pas très important, de plus je l'aurai retiré lors de la vérification finale de ma DLL.

    Il y a des abominations dans ton code. Par exemple :
    Code :

    double SAMSOFT_MATHSDLL_API ss_cal_a_b_fct_lineaire(double x, double fx, double y1, double y2, double x1, double x2) { //fonction permettant de trouver a et b d'une fonction linéaire de manière algébrique// //fonction exemple : f(x) = ax + b double a; double b; char r; //resultat// a = (y1 - y2)/(x1 - x2); b = fx - a*x; r = ("f(x) = %d%d + %d", a, x ,b); return r; }
    A quoi te servent les paramètres x et fx dans le code mis en évidence Emmanuel. Si tu as deux points (x1, y1) et (x2, y2), cela suffit à calculer les paramètres d'une droite. On obtient deux équations à deux inconnues. Problème simple à résoudre.
    3) Ceci est la dernière fonction (pour le moment) de ma dll, je l'ai écrite comme ca , il était environ minuit qand j'ai tapé les lignes de la fonction, naturellement à minuit on ne se pose pas de grandes questions comme "fx va t-il réelement servir...".

    De plus, comme l'a rappelé Emmanuel, les tests unitaires sont incontournables afin de t'assurer que chaque unité de code fait correctement son travail (répond aux spécifications) et est robuste.
    4) Hier soir, j'ai réalisé pour chaque fonction un programme en C pour voir si elle fonctionnait (je n'ai pas fais de test pour la dernière fonction de ma dll, ss_cal_a_b_fct_lineaire)
    Voilà le résultat des tests :
    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
    SamSoft_Maths_DLL par Samy Hocine : www.samsoft.ift.fr : samyhocine@hotmail.fr
     
    00:50 21/02/2007 : Vérifier la fonction ss_aire_triangle_equi //Recompiler la dll// cause : resultat reste le même.
     
    00:56 21/02/2007 : Vérifier la fonction ss_aire_trapeze //Recompiler la dll// cause : resultat = 0.000
     
    00:59 21/02/2007 : Modifier le nom de la fonction ss_volume_sphere en ss_aire_shpere et créer la fonction
    permettant de calculer le volume de la sphère. //02:27 21/02/2007 : FINI//
     
    01:01 21/02/2007 : Vérifier la fonction ss_volume_pyramide : cause : resultat = 0.000
     
    01:02 21/02/2007 : idem que la remarque de 01:01 du 21/02/2007 pour la fonction ss_volume_tetraedre.
     
    01:04 21/02/2007 : idem (c.f superieur) pour la fonction ss_volume_cone_revolution.
     
    01:10 21/02/2007 : Modifier le nom de la fonction ss_volume_cyclindre_revolution par ss_volume_cylindre_revolution //02:27 21/02/2007 : FINI//
     
    01:15 21/02/2007 : Le reste des fonctions est correct.
     
    01:17 21/02/2007 : Vérifier la fonction ss_cal_a_b_fct_lineaire et renommer cal en calc
    Ta fonction ss_aire_triangle_equi fait n'importe quoi, en particulier le
    resultat==an1;
    ne fait rien. D'ailleurs ton compilateur aurait du te prévenir
    5) la fonction ss_aire_triangle_equi n'est pas de moi, et je ne sais même plus ce qu'elle fait là, je vais en créer une moi même car elle n'est pas correcre, pour calculer l'air d'un triangle équilatéral, c'est :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    a au carré * racine de 3 / 4
    quelle horreur....
    6) Je ne répondrai pas ! lol

  7. #7
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par _SamSoft_
    1) Je n'ai même pas pensé une seconde que 1/2 valait 0, c'est bizarre, j'ai pourtant déclarer des doubles,
    Et alors ? 1 et 2 sont des entiers, la division est entière. C'est comme le 3/4 que tu évoque en fin de post. Ca fait 0. Il faut mettre soit le résultat de la division si il est évident, soit mettre au moins un des éléments de l'expression constante en double, d'où le '.0'.
    2) Désolé mais pour moi ce n'est pas très important, de plus je l'aurai retiré lors de la vérification finale de ma DLL.
    Certes, mais ça en dit long sur la portée de nos commentaires... D'autre part, l'expérience prouve que ce qu'on ne fait pas quand l'occasion se présente, on ne le fait jamais.

  8. #8
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    Certes, mais ça en dit long sur la portée de nos commentaires... D'autre part, l'expérience prouve que ce qu'on ne fait pas quand l'occasion se présente, on ne le fait jamais.
    1) Exact !

    Et alors ? 1 et 2 sont des entiers, la division est entière. C'est comme le 3/4 que tu évoque en fin de post. Ca fait 0. Il faut mettre soit le résultat de la division si il est évident, soit mettre au moins un des éléments de l'expression constante en double, d'où le '.0'.
    2) Je sais que la divison est entière car on divise deux entiers "1" et "2" mais je voulais dire que c'était étrange qu'elle retourne un entier "0" au lieu de 0.5.

    De toute facon le problème est résolu !

    Merci,

  9. #9
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par _SamSoft_
    2) Je sais que la divison est entière car on divise deux entiers "1" et "2" mais je voulais dire que c'était étrange qu'elle retourne un entier "0" au lieu de 0.5.
    Si c'est la cas, tu ne sais pas ce qu'est une division entière (ou euclidienne).

  10. #10
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    À deux entiers a et b, avec b non nul, la division euclidienne associe un unique quotient q et un unique reste r, tout deux entiers, vérifiant :
    J'ai un peut du mal, si je divise 1/2 ca me donne 0.5 mais 0.5 n'est pas un entier ?!?!

  11. #11
    Expert éminent
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 397
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 397
    Par défaut
    • La division entière de 1 par 2 donne "0, reste 1".
    • La division décimale de 1 par 2 donne 0.5
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  12. #12
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    OK merci , je comprend enfin !


  13. #13
    Membre expérimenté
    Inscrit en
    Décembre 2003
    Messages
    272
    Détails du profil
    Informations forums :
    Inscription : Décembre 2003
    Messages : 272
    Par défaut
    Tu n'as jamais fais de choses du genre : "7 divisé par 3 donne 2 et il reste 1" ?

  14. #14
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    Si bien sur en MPI et en maths en général mais là j'était un peu fatigué et j'avais oublié la diiférence entre division entière donnant un reste si le résultat à la base n'est pas un entier et la divion décimal

  15. #15
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Par défaut
    EDIT: je viens de voir ton autre discussion au sujet de la fonction que je discute ci-dessous. Ce qui suis ne correspond pas à ce qui a été proposé dans le post http://www.developpez.net/forums/sho...d.php?t=283519 . Le style de programmation proposé ci-dessous est plus avancé, et plus difficile d'accès... Comme tu as précisé sur l'autre post que tu débutais en C, ce qui suis va peut-être te sembler un peu dense et obscure. Je laisse le post tel quel pour documentation, même s'il faudrait peut-être que je l'efface.

    Citation Envoyé par _SamSoft_
    3) Ceci est la dernière fonction (pour le moment) de ma dll, je l'ai écrite comme ca , il était environ minuit qand j'ai tapé les lignes de la fonction, naturellement à minuit on ne se pose pas de grandes questions comme "fx va t-il réelement servir...".
    Mais j'imagine que si tu as codé cette fonction à minuit, tu t'est basé sur des spécifications et un document de conception qui ont débrousaillés le terrain au préalable. C'était donc avant minuit. Si tu passes du temps à écrire une bibliothèque pour te simplifier la vie, le travail préparatoire a une grande importance, car tu veux écrire du code robuste et réutilisable. Même si tu ne distribue pas ce code, et qu'il est voué à un usage exclusivement personnal, le réutiliseras-tu si ce dernier est mal conçu?

    Pour revenir à ta fonction ss_cal_a_b_fct_lineaire(), j'aimerai proposer une petite réflexion sur la conception de ton code. Tout d'abord, je ne comprends pas l'erreur de syntaxe suivante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    r = ("f(x) = %d%d + %d", a, x ,b
    );
    tu voulais certainement écrire:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    r = printf("f(x) = %d%d + %d", a, x ,b);
    Dans ce cas, r est de type int. Pourquoi le type de retour de ta fonction n'est-il pas de type int? D'autre part, quel est l'intérêt ici de retouner le valeur de retour de printf?

    Je ne suis pas là pour influer sur ton style de programmation, mais si c'était moi qui programmait ta bibliothèque, j'utiliserais une toute autre technique basée sur les types abstraits de données (ADT). Ce style de programmation est particulièrement adapté pour une bibliothèque à orientation géométrique comme la tienne, où on manipule des objets (lignes, points, cercles, trapèzes). Cette approche est très verbeuse, et gourmande en lignes de code. Les avantages sont toutefois une conception claire et une organisation du code qui facilite l'utilisation, et la réutilisation et l'évolution de ta bibliothèque.

    Voici un exemple dont tu feras ce que tu voudras. J'espère avoir été suffisamment concentré pour ne pas avoir introduit d'erreurs, mais le code compile sans erreur sous gcc avec les options -Wall -ansi -pedantic. Les tests démontrent une exécution sans erreur apparante. Considérons donc le cas où tu désires déterminer les paramètres d'une droite à partir de deux points (comme c'est le cas dans ta fonction ss_cal_a_b_fct_lineaire()). On va donc créer un ADT représentant un Point avec les fonctions qui y sont associées (constructeurs, destructeur, accesseurs, fonction d'affichage). L'interface de point est spécifiée dans un fichier point.h, et les différentes fonctions sont définies dans le fichier point.c (c'est un peu long, je m'en excuses, mais j'ai voulu montrer un exemple complet):
    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
    /* Contenu du fichier m-point.h */
    #ifndef H_TC_MPOINT_20070221160145
    #define H_TC_MPOINT_20070221160145
     
    /* Définition du type opaque Point_s */
    typedef struct Point_ Point_s;
     
    /* API du type Line_s */
     
    /**
     * Crée un objet Points à partir de l'abscisse et de l'ordonnée à
     * l'origine (Coordonnées cartésiènnes).
     *
     * @param x Abscisse.
     * @param y Ordonnée à l'origine.
     * @return Pointeur sur l'instance de Point_s fraichement créée. Retourne NULL
     *         si l'allocation a échoué.
     */
    Point_s *Point_new_from_cartesian_coords(double x, double y);
     
    /**
     * Crée un objet Points à partir d'un angle et d'une distance
     * (Système de coordonnées polaires).
     *
     * @param r Distance à partir de l'origine
     * @param Phi Angle
     */
    Point_s *Point_new_from_polar_coords(double r, double phi);
     
    /**
     * Détruit un objet de type Point_s et réinitialise
     * le pointeur correspondant à NULL.
     *
     * @param pp_self Pointeur sur un pointeur sur l'instance de Point_s à détruire.
     */
    void Point_destroy(Point_s **pp_self);
     
    /**
     * Affiche la représentation d'un point.
     *
     * @param p_self Pointeur sur l'instance de Point_s considérée.
     */
    void Point_print(Point_s *p_self);
     
    /**
     * Détermine si un point est confondu avec un autre point, ou s'ils sont
     * distincts.
     *
     * @param p_self Pointeur sur l'instance de Point_s considérée.
     * @param p_point Pointeur sur une 2ème point.
     * @return 1 si les points sont confondus, sinon 0. Retourne -1 si l'un des
     *         deux arguments vaut NULL.
     */
    int Point_is_equal(Point_s *p_self, Point_s *p_point);
     
    /**
     * Retourne l'abscisse x du Point (Coordonnées cartésiennes)
     *
     * @param p_self Pointeur sur l'instance de Point_s considérée.
     * @return Valeur de l'abscisse du point.
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
    double Point_get_abscissa(Point_s *p_self);
     
    /**
     * Retourne l'ordonnée y du Point (Coordonnées cartésiennes)
     *
     * @param p_self Pointeur sur l'instance de Point_s considérée.
     * @return Valeur de l'ordonnée  du point.
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
    double Point_get_ordinate(Point_s *p_self);
     
    #endif /* H_TC_MPOINT_20070221160145 */
    Voici l'implantation de cette interface:

    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
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    /* Contenu du fichier m-point.c */
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include <float.h>
    #include "m-point.h"
     
    /* Déclaration de la structure Point_s */
    struct Point_ {
        double x;
        double y;
    };
     
    /**
     * Crée un objet Points à partir de l'abscisse et de l'ordonnée à
     * l'origine (Coordonnées cartésiènnes).
     *
     * @param x Abscisse.
     * @param y Ordonnée à l'origine.
     * @return Pointeur sur l'instance de Point_s fraichement créée. Retourne NULL
     *         si l'allocation a échoué.
     */
    Point_s *Point_new_from_cartesian_coords(double x, double y)
    {
        Point_s *p_self = malloc(sizeof *p_self);
        if (p_self != NULL)
        {
            /* On initialise tous les champs de p_self à la valeur 0 */
            static Point_s tmp = {0};
            *p_self = tmp;
     
            p_self->x = x;
            p_self->y = y;
        }
        else
        {
            fprintf(stderr, "Allocation of Point_s instance failed!\n");
        }
        return p_self;
    }
     
    /**
     * Crée un objet Points à partir d'un angle et d'une distance
     * (Système de coordonnées polaires).
     *
     * @param r Distance à partir de l'origine
     * @param Phi Angle
     */
    Point_s *Point_new_from_polar_coords(double r, double phi)
    {
        /* A implanter */
        (void) r;
        (void) phi;
     
        return NULL;
    }
     
    /**
     * Détruit un objet de type Point_s et réinitialise
     * le pointeur correspondant à NULL.
     *
     * @param Pointeur sur un pointeur sur l'instance de Point_s à détruire.
     */
    void Point_destroy(Point_s **pp_self)
    {
        if (pp_self != NULL && *pp_self != NULL)
        {
            free(*pp_self), *pp_self = NULL;
        }
    }
     
    /**
     * Affiche la représentation d'un point.
     *
     * @param p_self Pointeur sur l'instance de Point_s considérée.
     */
    void Point_print(Point_s *p_self)
    {
        if (p_self != NULL)
        {
            printf("(%.3f, %.3f)", p_self->x, p_self->y);
        }
    }
     
    /**
     * Détermine si un point est confondu avec un autre point, ou s'ils sont
     * distincts.
     *
     * @param Pointeur sur l'instance de Point_s considérée.
     * @param Pointeur sur une 2ème point.
     * @return 1 si les points sont confondus, sinon 0. Retourne -1 si l'un des
     *         deux arguments vaut NULL.
     */
    int Point_is_equal(Point_s *p_self, Point_s *p_point)
    {
        int return_val = 0;
     
        if (p_self != NULL && p_point != NULL)
        {
            if (fabs(p_self->x - p_point->x) < FLT_EPSILON
                    && fabs(p_self->y - p_point->y) < FLT_EPSILON)
            {
                return_val = 1;
            }
        }
        else /* Un des arguments passés à la fonction vaut NULL */
        {
            return_val = -1;
        }
        return return_val;
    }
     
    /**
     * Retourne l'abscisse x du Point (Coordonnées cartésiennes)
     *
     * @param p_self Pointeur sur l'instance de Point_s considérée.
     * @return Valeur de l'abscisse du point.
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
    double Point_get_abscissa(Point_s *p_self)
    {
        double return_val = 0;
     
        if (p_self != NULL)
        {
            return_val = p_self->x;
        }
        else
        {
            fprintf(stderr, "Point_get_abscissa() must be passed non-NULL values!\n");
            exit(EXIT_FAILURE);
        }
        return return_val;
    }
     
    /**
     * Retourne l'ordonnée y du Point (Coordonnées cartésiennes)
     *
     * @param p_self Pointeur sur l'instance de Point_s considérée.
     * @return Valeur de l'ordonnée  du point.
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
    double Point_get_ordinate(Point_s *p_self)
    {
        double return_val = 0;
     
        if (p_self != NULL)
        {
            return_val = p_self->y;
        }
        else
        {
            fprintf(stderr, "Line_get_ordinate() must be passed non-NULL values!\n");
            exit(EXIT_FAILURE);
        }
        return return_val;
    }
    La gestion des erreurs est sommaire. Maintenant, on peut créer un ADT droite (ou line en anglais). Une doite est déterminée par deux points (2 instances du type Point_s précédamment créé), ou par sa pente et son ordonnée à l'origine. Dans le code suivant, un constructeur permet de créer un "objet" Line_s (droite) à partir de 2 Point_s. L'objet Line_s ainsi créé est représenté en interne par sa pente, et son ordonnée à l'origine. L'encapsulation des données via le type opaque Line_s interdit à l'utilisateur d'accéder directement à ces données. Ce dernier est obligé de passer par des fonctions (dites accesseurs) qui lui permettent d'obtenir la pente et l'ordonée à l'origine de la droite. Voici tout d'abord l'interface du type Line_s:
    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
     
    /* Contenu du fichier m-line.h */
    #ifndef H_TC_MLINE_20070221160812
    #define H_TC_MLINE_20070221160812
     
    #include "m-point.h"
     
    /* Représentation interne d'une droite */
    typedef struct Line_ Line_s;
     
    /* API du type Line_s */
     
    /**
     * Crée une droite à partir de deux points.
     *
     * @param p_pt1 Pointeur sur le 1er point définissant la droite
     * @param p_pt2 Pointeur sur le 2ème point définissant la droite
     * @return Pointeur sur l'instance de Line_s fraichement créée. Retourne NULL
     *         si l'allocation a échoué ou si p_pt1 et p_pt2 ne représentent pas
     *         des points distincts.
     */
    Line_s *Line_new_from_points(Point_s *p_pt1, Point_s *p_pt2);
     
    /**
     * Détruit un objet de type Line_s et réinitialise
     * le pointeur correspondant à NULL.
     *
     * @param pp_self Pointeur sur un pointeur sur l'instance de Line_s à détruire.
     */
    void Line_destroy(Line_s **pp_self);
     
    /** Affiche la représentation d'une droite.
     *
     * @param p_self Pointeur sur l'instance de Line_s considérée
     */
    void Line_print(Line_s *p_self);
     
    /**
     * Retourne la pente de la droite.
     *
     * @param p_self Pointeur sur l'instance de Line_s considérée
     * @return Valeur de la pente, vaut 0 si p_self vaut NULL.
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
    double Line_get_slope(Line_s *p_self);
     
     
    /**
     * Retourne l'ordonnée à l'origine de la droite.
     *
     * @param p_self Pointeur sur l'instance de Line_s considérée
     * @return Valeur de l'ordonnée à l'origine, vaut 0 si p_self vaut NULL.
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
     double Line_get_offset(Line_s *p_self);
     
     
    #endif /* guard H_TC_MLINE_20070221160812 */
    Et voici le fichier d'implantation:

    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
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    /* Contenu du fichier m-line.c */
    #include <stdio.h>
    #include <stdlib.h>
    #include "m-line.h"
     
    /* Représentation interne d'une droite */
    struct Line_
    {
        double a; /* pente de la droite */
        double b; /* ordonnée à l'origine */
    };
     
    /* API du type Line_s */
     
    /**
     * Crée une droite à partir de deux points.
     *
     * @param p_pt1 Pointeur sur le 1er point définissant la droite
     * @param p_pt2 Pointeur sur le 2ème point définissant la droite
     * @return Pointeur sur l'instance de Line_s fraichement créée. Retourne NULL
     *         si l'allocation a échoué ou si p_pt1 et p_pt2 ne représentent pas
     *         des points distincts.
     */
    Line_s *Line_new_from_points(Point_s *p_pt1, Point_s *p_pt2)
    {
        Line_s *p_self = NULL;
     
        if (p_pt1 != NULL && p_pt2 != NULL)
        {
            if (Point_is_equal(p_pt1, p_pt2) == 0)
            {
                p_self= malloc(sizeof *p_self);
                if (p_self != NULL)
                {
                    /* On initialise tous les champs de p_self à la valeur 0 */
                    static Line_s tmp = {0};
                    *p_self = tmp;
     
                    /* On calcul les paramètres de la droite */
                    p_self->a = (Point_get_ordinate(p_pt1) - Point_get_ordinate(p_pt2))
                                / (Point_get_abscissa(p_pt1) - Point_get_abscissa(p_pt2));
                    p_self->b = Point_get_ordinate(p_pt1) - p_self->a * Point_get_abscissa(p_pt1) ;
                }
                else
                {
                    fprintf(stderr, "Allocation of Line_s instance failed!\n");
                }
            }
            else
            {
                fprintf(stderr, "The points must be distinct!\n");
            }
        }
        return p_self;
    }
     
    /**
     * Détruit un objet de type Line_s et réinitialise
     * le pointeur correspondant à NULL.
     *
     * @param pp_self Pointeur sur un pointeur sur l'instance de Line_s à détruire.
     */
    void Line_destroy(Line_s **pp_self)
    {
        if (pp_self != NULL && *pp_self != NULL)
        {
            free(*pp_self), *pp_self = NULL;
        }
    }
     
    /** Affiche la représentation d'une droite.
     *
     * @param p_self Pointeur sur l'instance de Line_s considérée
     */
    void Line_print(Line_s *p_self)
    {
        if (p_self != NULL)
        {
            printf("%f * x %c %f = y", p_self->a,
                    (p_self->b < 0.0) ? '-' : '+',p_self->b);
        }
    }
     
    /**
     * Retourne la pente de la droite.
     *
     * @param p_self Pointeur sur l'instance de Line_s considérée
     * @return Valeur de la pente
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
    double Line_get_slope(Line_s *p_self)
    {
        int return_val = 0;
     
        if (p_self != NULL)
        {
            return_val = p_self->a;
        }
        else
        {
            fprintf(stderr, "Line_get_slope() must be passed non-NULL values!\n");
            exit(EXIT_FAILURE);
        }
        return return_val;
    }
     
     
    /**
     * Retourne l'ordonnée à l'origine de la droite.
     *
     * @param p_self Pointeur sur l'instance de Line_s considérée
     * @return Valeur de l'ordonnée à l'origine
     * @pre La valeur passée en argument ne doit pas valoir NULL.
     */
    double Line_get_offset(Line_s *p_self)
    {
        double return_val = 0;
     
        if (p_self != NULL)
        {
            return_val = p_self->b;
        }
        else
        {
            fprintf(stderr, "Line_get_offset() must be passed non-NULL values!\n");
            exit(EXIT_FAILURE);
        }
        return return_val;
    }
    C'est bientôt fini. Voici encore un micro exemple d'utilisation du type Line_s:
    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
    /* Contenu du fichier main.c */
    #include <stdio.h>
    #include <stdlib.h>
    #include "test-line.h"
    #include "m-line.h"
     
    #define SIZEOF_ARRAY(tab) ((sizeof(tab) / sizeof(*(tab))))
     
    int main(void)
    {
        int err = EXIT_SUCCESS;
     
        size_t i;
        Point_s *p_points[2] = {NULL};
        Line_s *p_line = NULL;
     
        /* On crée deux objets de type Point_s à l'aide du constructeur
            approprié */
        p_points[0] = Point_new_from_cartesian_coords(10, 20);
        p_points[1] = Point_new_from_cartesian_coords(0, 0);
        /* On vérifie que l'allocation s'est bien déroulée */
        if (p_points[0] != NULL && p_points[1] != NULL)
        {
            /* On crée maintenant l'objet de type Line_s à l'aide
                du constructeur approprié et des deux points */
            p_line = Line_new_from_points(p_points[0], p_points[1]);
            /* On vérifie que l'allocation s'est bien déroulée*/
            if (p_line != NULL)
            {
                /* On affiche la représentation d'une droite */
                Line_print(p_line);
                printf("\n");
                /* On affiche la valeur de la pente et l'ordonnée à l'origine 
                    de la droite via les accesseurs appropriés */
                printf("La pente a  vaut %f\n", Line_get_slope(p_line));
                printf("L'ordonnée à l'origine b vaut %f\n", Line_get_offset(p_line));
     
                /* On détuit l'objet droite */
                Line_destroy(&p_line);
                if (p_line == NULL)
                {
                    printf("p_line a été libéré!\n");
                }
            }
            else /* La création de la droite a échoué */
            {
                fprintf(stderr, "Creation of p_line failed!\n");
                err = EXIT_FAILURE;
            }
     
            /* On détruit les objets point*/
            for (i = 0; i < SIZEOF_ARRAY(p_points); ++i)
            {
                Point_destroy(&p_points[i]);
                if (p_points[i] == NULL)
                {
                    printf("p_points[%d] a été libéré!\n", i);
                }
            }
        }
        else /* La création d'un point a échoué */
        {
            fprintf(stderr, "Creation of one of p_points elements failed!\n");
            err = EXIT_FAILURE;
        }
     
        return err;
    }
    C'était dense, mais c'est fini! Je ne me vexerais pas si mon exemple passe à la corbeille... Je pense que ce style de programmation est approprié pour traiter des droites, points, trapèzes, cercles, etc. comme tu le fais. N'hésite pas à poser des questions, ou à me signaler si quelque chose ne joue pas avec mon code. (Bien entendu, on peut aller bien plus loin dans le modèle objet en supportant des relations d'héritage et le polymorphisme, mais l'approche utilisée ici a le mérite de rester relativement simple)

    Cordialement

    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  16. #16
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    Excellent , merci de votre qualité à fournir de très bons codes sources et qui fonctionnent (en tout cas je l'espère, je n'ai pas encore testé votre "programme" , je vais le faire dans 1 petite heure, et oui je me couche tard, j'ai encore 5 heures devant moi) par contre vous avez réalisé une erreur de compréhension, ma DLL ne sert pas à créer des objets (comme des droites, des cercles, des points...) mais simplement à partir de formules mathématiques (allant de la simple addition à l'équation du second degrès en passant par pythagore et cie) retourner des résultats.

    Voilà : je remet à jour mes fichiers car apparement les codes que vous avez mis ne sont plus exacts :

    Fichier.c de ma DLL :

    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
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    /*
    Fichier : samsoft_maths.c
    Auteur : Samy Hocine (SamSoft) http://www.samsoft.ift.fr ; samyhocine@hotmail.fr
    Date du commencement: Mercredi 4 fervrier 2007
    Description : Dll incluant divers fonctions mathématiques
    Licence : GNU/GPL
    Information : ss ou SS veut dire SamSoft
    Remarque : la fonction int racine à été prise sur http://c.developpez.com/sources/c/?page=VII
    Remerciements : www.developpez.com et aux membres du forum sur le C http://www.developpez.net/forums/forumdisplay.php?f=18
    */
     
    #include <string.h>
    #include "samsoft_maths.h"
     
    const double PI = 3.1415926535897932384626433832795;
     
    int racine(int nbr)//Par Anomaly, http://c.developpez.com/sources/c/?page=VII
    {
      int r1, r2;
     
      r1 = (nbr + 1) / 2;
     
      for (;;)
      {
        r2 = (r1 + nbr / r1) / 2;
     
        if (r2 >= r1)
          return r1;
     
        r1 = r2;
      }
    }
     
    double SAMSOFT_MATHSDLL_API ss_carre(double a)
    {
        return a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_cube(double a)
    {
        return a*a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_perimetre_cercle(double r)
    {
        return 2*PI*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_cercle(double r) //r = rayon//
    {
        return PI*r*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_triangle(double b, double h) //triangle quelconque, b = base et h = hauteur//
    {
        return (b*h)/2;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_equi(double a) //triangle équilateral, a est la longeur d'un côté//
    {
        double racine_3;
        racine_3 = racine(3);
        return (a*a*racine_3)/4;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_rect(double b, double c) //triangle rectangle, b et c sont les longeurs de deux côtés autres que l'hypothénuse//
    {
        return (b*c)/2;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_rectangle(double l, double m)//l = longeur ; m = largeur/
    {
        return l*m;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_carre(double a)//a étant la longeur d'un côté//
    {
        return a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_parallelogramme(double b, double h)//b étant la base et h la hauteur//
    {
        return b*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_losange(double b, double h)//b étant la base et h la hauteur//
    {
        return (b*h)/2;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_trapeze(double a, double b, double h)//b étant la base et h la hauteur et a la longeur du côté du dessus//
    {
        return 0.5*(a+b)*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_shpere(double r)//r étant le rayon de la sphère//
    {
        return 4*PI*r*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_sphere(double r)//r étant le rayon de la sphère//
    {
        4/3*PI*r*r*r;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_pyramide(double b, double h)//b est la base d'aire et h la hauteur//
    {
        return 0.3333333333*b*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_tetraedre(double b, double h)//b est la base d'aire et h la hauteur//
    {
        return 0.3333333333*b*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_cone_revolution(double r, double h)//r est le rayon de la base qui est un cercle et h la hauteur//
    {
        return 0.3333333333*PI*r*r*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_pave_droit(double a, double b, double c)//a, b et c sont des longeurs//
    {
        return 2*(a*b+b*c+a*c);
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_pave_droit(double a, double b, double c)//a, b et c sont des longeurs//
    {
        return (a*b*c);
    }
     
    double SAMSOFT_MATHSDLL_API ss_aire_cube(double a)//a étant la longeur d'un côté//
    {
        return 6*a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_cube(double a)//a étant la longeur d'un côté//
    {
        return a*a*a;
    }
     
    double SAMSOFT_MATHSDLL_API ss_volume_cylindre_revolution(double r, double h)//r est le rayon de la base (qui est un cercle) et h la hauteur entre la base et la surface du dessus//
    {
        return PI*r*r*h;
    }
     
    double SAMSOFT_MATHSDLL_API ss_addition(double a, double b)
    {
        return a+b;
    }
     
    double SAMSOFT_MATHSDLL_API ss_soustraction(double a, double b)
    {
        return a-b;
    }
     
    double SAMSOFT_MATHSDLL_API ss_multiplication(double a, double b)
    {
        return a*b;
    }
     
    double SAMSOFT_MATHSDLL_API ss_division(double a, double b)
    {
        return a/b;
    }
     
    char* SAMSOFT_MATHSDLL_API ss_calc_a_b_fct_lineaire(double y1, double y2, double x1, double x2)
    {
        //fonction permettant de trouver a et b d'une fonction linéaire de manière algébrique//
        //fonction exemple : f(x) = ax + b
        double a;
        double b;
        char* pBuffer = malloc(TAILLE_BUFFER * sizeof(*pBuffer));
     
        a = (y1 - y2)/(x1 - x2);
        b = a*x1 - y1;
     
        if(pBuffer != NULL)
        {
            sprintf(pBuffer, "f(x) = %fx + %f", a, b);
        }
     
        return pBuffer;
    }
    fichier .c d'un programme testant la fonction ss_calc_a_b_fct_lineaire :
    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
    #include <stdio.h>
    #include <stdlib.h>
    #include "samsoft_maths.h" //Contient les prototypes des fonctions de la Dll
     
    int main()
    {
        double x1, x2, y1, y2;
        char* resultat; //résultat//
     
               printf("\nTapez votre nombre x1 : ");
               fflush(stdout);
               scanf("%lf", &x1);
               printf("\nTapez votre nombre y1 : ");
               fflush(stdout);
               scanf("%lf", &y1);
               printf("\nTapez votre nombre x2 : ");
               fflush(stdout);
               scanf("%lf", &x2);
               printf("\nTapez votre nombre y2 : ");
               fflush(stdout);
               scanf("%lf", &y2);
               resultat = ss_calc_a_b_fct_lineaire(y1, y2, x1, x2);
               if (resultat != NULL)
               {
                  printf("\n%s\n\n", resultat);
                  free (resultat), resultat = NULL;
               }
               system("PAUSE");
               return EXIT_SUCCESS;
    }
    fichier .h (contenant les prototypes des fonctions de la DLL) :
    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
    /*
    Fichier : samsoft_maths.h
    Auteur : Samy Hocine (SamSoft) http://www.samsoft.ift.fr ; samyhocine@hotmail.fr
    Date du commencement: Mercredi 4 fervrier 2007
    Description : None
    Licence : GNU/GPL
    Information : ss ou SS veut dire SamSoft
    */
     
    #ifndef H_SAMSOFT_MATHSDLL_20070214181222
    #define H_SAMSOFT_MATHSDLL_20070214181222
     
    #ifdef SAMSOFT_MATHSDLL_BUILD
    #define SAMSOFT_MATHSDLL_API __declspec(dllexport)
    #else
    #define SAMSOFT_MATHSDLL_API __declspec(dllimport)
    #endif
     
    #define LONGUEUR_BUFFER (12+20+20)
    #define TAILLE_BUFFER (LONGUEUR_BUFFER+1)
     
    extern const double PI;
     
    int racine(int nbr);
    double SAMSOFT_MATHSDLL_API ss_carre(double a);
    double SAMSOFT_MATHSDLL_API ss_cube(double a);
    double SAMSOFT_MATHSDLL_API ss_perimetre_cercle(double r);
    double SAMSOFT_MATHSDLL_API ss_aire_cercle(double r);
    double SAMSOFT_MATHSDLL_API ss_aire_triangle(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_equi(double a);
    double SAMSOFT_MATHSDLL_API ss_aire_triangle_rect(double b, double c);
    double SAMSOFT_MATHSDLL_API ss_aire_rectangle(double l, double m);
    double SAMSOFT_MATHSDLL_API ss_aire_carre(double a);
    double SAMSOFT_MATHSDLL_API ss_aire_parallelogramme(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_losange(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_trapeze(double a, double b, double h);
    double SAMSOFT_MATHSDLL_API ss_ss_aire_shpere(double r);
    double SAMSOFT_MATHSDLL_API ss_volume_sphere(double r);
    double SAMSOFT_MATHSDLL_API ss_volume_pyramide(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_volume_tetraedre(double b, double h);
    double SAMSOFT_MATHSDLL_API ss_volume_cone_revolution(double r, double h);
    double SAMSOFT_MATHSDLL_API ss_aire_pave_droit(double a, double b, double c);
    double SAMSOFT_MATHSDLL_API ss_volume_pave_droit(double a, double b, double c);
    double SAMSOFT_MATHSDLL_API ss_aire_cube(double a);
    double SAMSOFT_MATHSDLL_API ss_volume_cube(double a);
    double SAMSOFT_MATHSDLL_API ss_volume_cylindre_revolution(double r, double h);
    double SAMSOFT_MATHSDLL_API ss_addition(double a, double b);
    double SAMSOFT_MATHSDLL_API ss_soustraction(double a, double b);
    double SAMSOFT_MATHSDLL_API ss_multiplication(double a, double b);
    double SAMSOFT_MATHSDLL_API ss_division(double a, double b);
    char* SAMSOFT_MATHSDLL_API ss_calc_a_b_fct_lineaire(double y1, double y2, double x1, double x2);
     
    #endif
    fichier pour les tests des fonctions :
    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
    SamSoft_Maths_DLL par Samy Hocine : www.samsoft.ift.fr : samyhocine@hotmail.fr
     
    00:50 21/02/2007 : Vérifier la fonction ss_aire_triangle_equi //Recompiler la dll// cause : resultat reste le même.
     
    00:56 21/02/2007 : Vérifier la fonction ss_aire_trapeze //Recompiler la dll// cause : resultat = 0.000 //14:01 21/02/2007 : FINI//
     
    00:59 21/02/2007 : Modifier le nom de la fonction ss_volume_sphere en ss_aire_shpere et créer la fonction
    permettant de calculer le volume de la sphère. //02:27 21/02/2007 : FINI//
     
    01:01 21/02/2007 : Vérifier la fonction ss_volume_pyramide : cause : resultat = 0.000 //14:01 21/02/2007 : FINI// 
     
    01:02 21/02/2007 : idem que la remarque de 01:01 du 21/02/2007 pour la fonction ss_volume_tetraedre. //14:01 21/02/2007 : FINI//
     
    01:04 21/02/2007 : idem (c.f superieur) pour la fonction ss_volume_cone_revolution. //14:01 21/02/2007 : FINI// 
     
    01:10 21/02/2007 : Modifier le nom de la fonction ss_volume_cyclindre_revolution par ss_volume_cylindre_revolution //02:27 21/02/2007 : FINI//
     
    01:15 21/02/2007 : Le reste des fonctions est correct. //OK//
     
    01:17 21/02/2007 : Vérifier la fonction ss_cal_a_b_fct_lineaire et renommer cal en calc //14:01 21/02/2007 : FINI//
     
    14:02 21/02/2007 : Vérifier la fonction ss_aire_triangle_equi : cause : resultat reste le même.
     
    14:55 21/02/2007 : 	Modifier la fonction ss_calc_a_b_fct_lineaire et recréer la fonction ss_aire_triangle_equi //01:11 22/02/2007 : FINI//
    Sinon pour la fonction ss_calc_a_b_fct_lineaire, je l'ai créée à minuit avant hier et je ne l'avais jamais marqué quelque part, je l'ai faite de tête comme ca à la va vite en comptant bien entendu la tester l'après midi même !

    Merci pour tout !

  17. #17
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    RHHAAAAAAA !!!!

    GRRRRR !!!!


    Non mais des fois, lis les post !!!!!!!!!!!!

    Il y a toujours, partout, des divisions entières !!!!!!!!

  18. #18
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    ????, mais ce n'est pas grave tant que ca fonctione, non ?

  19. #19
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Par défaut
    Citation Envoyé par _SamSoft_
    Excellent , merci de votre qualité à fournir de très bons codes sources et qui fonctionnent (en tout cas je l'espère, je n'ai pas encore testé votre "programme" , je vais le faire dans 1 petite heure, et oui je me couche tard, j'ai encore 5 heures devant moi) par contre vous avez réalisé une erreur de compréhension, ma DLL ne sert pas à créer des objets (comme des droites, des cercles, des points...) mais simplement à partir de formules mathématiques (allant de la simple addition à l'équation du second degrès en passant par pythagore et cie) retourner des résultats.
    C'est une façon de voir les choses. Lorsque je vois, ss_aire_triangle(), ss_aire_rectangle(), ss_volume_sphere(), je pense à comment je vais représenter en mémoire une sphère, un rectangle, etc. Pour représenter un cercle par exemple, il me faut utiliser un Point pour représenter le centre, et une valeur pour réprésenter le rayon. Ensuite, l'objet cercle est responsable de retourner son aire lorsque le cercle reçoit le message "get_area" (appel de la fonction:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    double Circle_get_area(Circle_s *p_self)
    ).

    C'est que pour l'addition, c'est pas adapté. Mais je vois pas l'intérêt de recourir à une bibliothèque pour effectuer une addition. Le langage C le fait sans cela. Idem pour cacluler tan(), cos(), etc. qui sont fournit par la bibliothèque standard du langage.

    Mais, c'est certain, ce style de programmation n'est pas forcément adapté dans toutes les situations. Cette parenthèse te présentait d'autres idées...

    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  20. #20
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    Ok mujigka, en tout tes commentaires sont très sympas , en réalité je vois bien qu'une fonction permettant d'additionner des nombres ne sert à rien d'être créer met j'ai voulu faire une DLL pouvant être à la base même d'un programme de style "calculette avancée" contenant tout ce que l'on peut faire du cp à la seconde en mathématique algèbre (calcul), pas de géométire (figures).

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 3 123 DernièreDernière

Discussions similaires

  1. fonction count() me retourne toujours 1
    Par Leclandestin dans le forum Langage
    Réponses: 2
    Dernier message: 26/12/2010, 18h28
  2. ma fonction retourne toujours null
    Par haco28 dans le forum ActionScript 3
    Réponses: 1
    Dernier message: 13/08/2009, 11h53
  3. [XSLT]fonction contains retourne toujours false
    Par wildmary dans le forum XSL/XSLT/XPATH
    Réponses: 1
    Dernier message: 01/08/2007, 11h22
  4. Declaration de fonction retournant un pointeur sur fonction
    Par pseudokifaitladifférence dans le forum C
    Réponses: 5
    Dernier message: 11/08/2003, 19h37
  5. [Manip de fichiers] Fonction retournant des infos
    Par sans_atouts dans le forum C
    Réponses: 3
    Dernier message: 24/07/2002, 14h16

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo