Calculatrice inteligente

Fermé
doumbia.danse Messages postés 46 Date d'inscription jeudi 3 juillet 2014 Statut Membre Dernière intervention 16 mars 2015 - Modifié par doumbia.danse le 22/10/2014 à 16:03
Bonjour,


Le but consiste en ce que l'on tape une opération en intégralité et que le programme l'effectue :-)
Eh bien voici le code en bas
Essayez de voir s'il y a à faire mieux ou si je devais ne pas utiliser certaines fonctions :
- Le main
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include"calc.h"

int main()
{
    char quiter=0,i;
    int resultat=0,A=0;
    char chaine[100]="";
    int nombre[TAILLE_M];
    chara operateur[TAILLE_M];

    //printf("%d octets\n%d octets\n%d octets\n%d octets \n %d octets ",sizeof(int),sizeof(long),sizeof(double),sizeof(char),sizeof(chara));

    //int i,k=0,j,h=0,m,p=0,r=0,s,y;
    do
    {
        En_tete();
        printf("\t\t Votre operation s'il vous plait!\n");
        InitialiseStructure(operateur,TAILLE_M);
        for(i=0;i<TAILLE_M;i++)
            nombre[i]=0;
        InitailiseCaractere(chaine,100);
        //="ui84t47+nhb123mlk";
        scanf("%99s",chaine);
        //fgets(chaine,99,stdin);
        //chaine[strlen(chaine)-1]='\0';

        PartageurOperation(chaine,operateur,nombre);
        /**
            une fois sorti de cette boucle, on aura un tableau contenant les operateur et un contenant les donnees
            On essaie d'envoyer ces deux tableau à la fonction Calculatrice pour qu'elle s'en serve et ainsi modifie la valeur de resultat
        */
        //int base=1;
        /*for(j=0;j<TAILLE_M;j++)
            printf("%s\t%d\n",operateur[j].chaine,nombre[j]);
        printf("%d -->%d",operateur,nombre);*/
        resultat=Calculatrice(operateur,nombre);
        system("color 06");
        printf("le resultat est %d\n",resultat);
        printf("Une autre operation? Tapez 1 pour confirmer et 0 pour quiter\n->");
        A=resultat;
        do
        {
            scanf("%c",&quiter);
        }while(quiter!='1' && quiter!='0');
        system("cls");
        system("color 0F");
    }while(quiter!=0);

    return 0;
}

-La Calc.c
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include "calc.h"

void En_tete()
{
    printf("================================================================================\n");
    printf("================================================================================\n");
    printf("\n\t\t------------------------------------------------\n");
    printf("\t\t|Bienvenu sur MoloBALA-Calculatrice version 0.1|\n");
    printf("\t\t------------------------------------------------\n\n");
    printf("\n\t--------------------------------------------------------------------\n");
    printf("\t|Ce programme est concu par DOUMBIA Mahamadou, l'enfant de MoloBALA|\n");
    printf("\t--------------------------------------------------------------------\n\n");
    printf("\n================================================================================\n");
    printf("================================================================================\n");
}
void InitialiseStructure(chara *structure,int taille)
{
    int i=0,j=0;
    for(i=0;i<taille;i++)
    {
        for(j=0;j<TAILLE_M;j++)
            structure[i].chaine[j]=0;
    }
}
void PartageurOperation(char *chaine,chara *operateur, int *nombre)
{
    int i=0,y=0,s=0,r=0,k=0,p=0;//Les variables de parcours des tableaux
    for(i=0;i<TAILLE;i++)
    {
        if(!(chaine[i]>='0' && chaine[i]<='9'))
        {
            operateur[p].chaine[r]=chaine[i];
            r=r+1;
        }
        else if(chaine[i]>='0' && chaine[i]<='9')
        {
            nombre[k]=atoi(&chaine[i]);
            k=k+1;
            s=0;
            r=0;
            for(y=i;y<(TAILLE-i);y++)
            {
                if(chaine[y]>='0' && chaine[y]<='9')
                    s=s+1;
                else
                {
                    break;
                }
            }
            i=i+(s-1);
            p=p+1;
        }
    }
}
void InitailiseCaractere(char *chaine,int taille)
{
    int i;
    for(i=0;i<(taille-1);i++)
        chaine[i]=0;
}

/*int Calculatrice(int resultat,chara operateur,int donnee,int base)
{

}*/
int Calculatrice(chara *operateur, int *donnee)
{
    int valeurInstantane,valeurIntermediaire=0;
    if(strcmp(operateur[0].chaine,"")==0)
        valeurInstantane=donnee[0];
    else if(strcmp(operateur[0].chaine,"-")==0)
        valeurInstantane=-donnee[0];
    else if(strcmp(operateur[0].chaine,"+")==0)
        valeurInstantane=donnee[0];
    else return 0;
    int confCalValeurIntermediaire=0;
    int resultat;
    int i=0,j=0,m=0,k=0;//pour parcourir
    int *nombre=NULL;//Permet de stocker  les donnes apres premier tritement
    chara *operatTraites=NULL;//permet de stocker les operateurs apres premier traitement

    for(i=1;i<TAILLE_M;i++)
    {
        k=0;
        confCalValeurIntermediaire=0;
        //if(strcmp(operateur[i].chaine,"")==0)
            //break;
        //la partie traitant l'addition
        if(strcmp(operateur[i].chaine,"+")==0)
        {
            valeurIntermediaire=0;
            for(j=(i+1);j<TAILLE_M;j++)
            {
                if(strcmp(operateur[j].chaine,"+")==0||strcmp(operateur[j].chaine,"-")==0 || strcmp(operateur[j].chaine,"")==0)
                {
                    //m=j;
                    valeurIntermediaire=valeurIntermediaire;
                    break;
                }
                else if(strcmp(operateur[j].chaine,"*")==0)
                {
                    if(valeurIntermediaire!=0)
                    {
                        valeurIntermediaire=valeurIntermediaire*donnee[j];
                        confCalValeurIntermediaire++;
                    }
                    else
                    {
                        valeurIntermediaire=donnee[j-1]*donnee[j];
                    }
                    confCalValeurIntermediaire=confCalValeurIntermediaire+1;
                }
                else if(strcmp(operateur[j].chaine,"/")==0)
                {
                    if(valeurIntermediaire!=0)
                    {
                        valeurIntermediaire=valeurIntermediaire/donnee[j];
                        confCalValeurIntermediaire++;
                    }
                    else
                    {
                        valeurIntermediaire=donnee[j-1]/donnee[j];
                    }
                    confCalValeurIntermediaire=confCalValeurIntermediaire+1;
                }
                k++;
            }

            if(confCalValeurIntermediaire!=0)
            {
                //il y a donc eu un calcul intermediaire
                valeurInstantane=valeurInstantane+valeurIntermediaire;
                //i+k;
            }
            else if(confCalValeurIntermediaire==0)
            {
                valeurInstantane=valeurInstantane+donnee[i];
            }
        }
        //la partie traitant la soustraction
        if(strcmp(operateur[i].chaine,"-")==0)
        {
            valeurIntermediaire=0;
            for(j=(i+1);j<TAILLE_M;j++)
            {
                if(strcmp(operateur[j].chaine,"+")==0||strcmp(operateur[j].chaine,"-")==0 || strcmp(operateur[j].chaine,"")==0)
                {
                    //m=j;
                    break;
                }
                else if(strcmp(operateur[j].chaine,"*")==0)
                {
                    if(confCalValeurIntermediaire!=0)
                    {
                        valeurIntermediaire=valeurIntermediaire*donnee[j];

                    }
                    else
                    {
                        valeurIntermediaire=donnee[j-1]*donnee[j];
                    }
                    confCalValeurIntermediaire++;
                }
                else if(strcmp(operateur[j].chaine,"/")==0)
                {
                    if(confCalValeurIntermediaire!=0)
                    {
                        valeurIntermediaire=valeurIntermediaire/donnee[j];

                    }
                    else
                    {
                        valeurIntermediaire=donnee[j-1]/donnee[j];
                    }
                    confCalValeurIntermediaire++;
                }
                k++;
            }
            if(confCalValeurIntermediaire!=0)
            {
                //il y a donc eu un calcul intermediaire
                valeurInstantane=valeurInstantane-valeurIntermediaire;

            }
            else if(confCalValeurIntermediaire==0)
            {
                valeurInstantane=valeurInstantane-donnee[i];
            }
        }
        else if(strcmp(operateur[i].chaine,"*")==0)
        {
            valeurInstantane=valeurInstantane*donnee[i];
        }
        else if(strcmp(operateur[i].chaine,"/")==0)
        {
            valeurInstantane=valeurInstantane/donnee[i];
        }
        i=i+k;
        //resultat=resultat+valeurInstantane;
    }
    resultat=valeurInstantane;
    return resultat;
}

-Le Calc.h
#ifndef CALC_H_INCLUDED
#define CALC_H_INCLUDED
#define TAILLE_M 40
#define TAILLE 20
typedef struct caractere chara;
struct caractere
{
    char chaine[TAILLE_M];
};
void En_tete();//mise en forme en quelque sorte de l'en-tete de mon programme;
int Calculatrice(chara *operateur, int *donnee);
void InitialiseStructure(chara *structure,int taille);
void PartageurOperation(char *chaine,chara *operation, int *nombre);
void InitailiseCaractere(char *chaine,int taille);
#endif // CALC_H_INCLUDED




Merci d'avance !