Calculatrice avec fichier de log

Soyez le premier à donner votre avis sur cette source.

Vue 12 080 fois - Téléchargée 949 fois

Description

C'est une calculatrice crée avec borland C++ builder 6. Elle peut aditionner, soustraire, elever à une puissance, et diviser mais entière...
Vous pouvez ensuite créer un fichier de log avec tout les calcul effectuer. Il s'enregistre dans le meme repertoire que le *.exe
Son contenu est aussi visible lors de l'utilisation.

Source / Exemple :


//---------------------------------------------------------------------------

#include <vcl.h>
#include <stdio.h>
#pragma hdrstop

#include "ufmMain.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TFmMain *FmMain;
//=========================================
//Projet calculatrice Follonier 10.06.2006
//=========================================

   char affichage[25];
   char affichageClear[25];
   char memo[100];
   int nombre1;
   int nombre2;
   int nombreIni;
   int resultat;
   int operation = 0;
   int i;
   int numerocalc = 0;

//---------------------------------------------------------------------------
__fastcall TFmMain::TFmMain(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button0Click(TObject *Sender)
{
strcat(affichage,"0");//concaténation du nombre a la fin de la chaîne
                EdAffichage->Text = affichage;//affichage de la chaîne
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button1Click(TObject *Sender)
{
 strcat(affichage,"1");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button2Click(TObject *Sender)
{
 strcat(affichage,"2");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button3Click(TObject *Sender)
{
 strcat(affichage,"3");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button4Click(TObject *Sender)
{
 strcat(affichage,"4");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button5Click(TObject *Sender)
{
 strcat(affichage,"5");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button6Click(TObject *Sender)
{
 strcat(affichage,"6");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button7Click(TObject *Sender)
{
 strcat(affichage,"7");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button8Click(TObject *Sender)
{
 strcat(affichage,"8");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::Button9Click(TObject *Sender)
{
 strcat(affichage,"9");
                EdAffichage->Text = affichage;
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonClearClick(TObject *Sender)
{
        stpcpy(affichage,affichageClear);//copie d'une chaîne vide sur affichage
                EdAffichage->Text = affichage;//affichae affichage
        sprintf(memo,"   CLEAR");
        Memo1->Lines->Insert(0,memo);
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonBackClick(TObject *Sender)
{
int position = StrLen(affichage);//detection du dernier caractère
        affichage[position-1] = 0;//effacement du dernier caractère visible
                EdAffichage->Text = affichage;//affichage de la chaîne
                sprintf(memo,"   BACK");
        Memo1->Lines->Insert(0,memo);
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonPowerClick(TObject *Sender)
{       AnsiString testnb;
        testnb = affichage;
        if(testnb ==""){
                sprintf(memo,"ERREUR ENTRER UN NOMBRE ENTIER");
                Memo1->Lines->Insert(0,memo);
                EdAffichage->Text = memo;
        }
        else{
operation = 1;//indicateur pour l'action du bouton égal
        nombre1 = StrToInt(affichage);//enregistrement du 1er nombre
        nombreIni = nombre1;//copie du 1er nombre dans une 2em variable pour le calcul
        stpcpy(affichage,affichageClear);
        EdAffichage->Text = affichage;
        }
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonPlusClick(TObject *Sender)
{       AnsiString testnb;
        testnb = affichage;
        if(testnb ==""){
                sprintf(memo,"ERREUR ENTRER UN NOMBRE ENTIER");
                Memo1->Lines->Insert(0,memo);
                EdAffichage->Text = memo;
        }
        else{
operation = 2;//indicateur pour l'action du bouton égal
        nombre1 = StrToInt(affichage);//enregistrement du 1er nombre
        stpcpy(affichage,affichageClear);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonProduitClick(TObject *Sender)
{       AnsiString testnb;
        testnb = affichage;
        if(testnb ==""){
                sprintf(memo,"ERREUR ENTRER UN NOMBRE ENTIER");
                Memo1->Lines->Insert(0,memo);
                EdAffichage->Text = memo;
        }
        else{
operation = 3;
        nombre1 = StrToInt(affichage);
        stpcpy(affichage,affichageClear);
         }
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonDiviserClick(TObject *Sender)
{       AnsiString testnb;
        testnb = affichage;
        if(testnb ==""){
                sprintf(memo,"ERREUR ENTRER UN NOMBRE ENTIER");
                Memo1->Lines->Insert(0,memo);
                EdAffichage->Text = memo;
        }
        else{

operation = 4;
        nombre1 = StrToInt(affichage);
        stpcpy(affichage,affichageClear);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonMoinClick(TObject *Sender)
{       AnsiString testnb;
        testnb = affichage;
        if(testnb ==""){
                sprintf(memo,"ERREUR ENTRER UN NOMBRE ENTIER");
                Memo1->Lines->Insert(0,memo);
                EdAffichage->Text = memo;
        }
        else{
operation = 5;
       nombre1 = StrToInt(affichage);
       stpcpy(affichage,affichageClear);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::ButtonEgalClick(TObject *Sender)
{       AnsiString testnb;
        testnb = affichage;
        if(testnb ==""){
                sprintf(memo,"ERREUR ENTRER UN NOMBRE ENTIER");
                Memo1->Lines->Insert(0,memo);
                EdAffichage->Text = memo;
        }
        else{
        numerocalc = numerocalc +1;
        resultat = 0;
         i = 1;
         nombre2 = StrToInt(affichage);//enregistrement du 2em nombre

//   Tri de l'opération effectuée en fonction de l'opération selectionnée   //

                if(operation == 1){
                        for(i ; nombre2 > i ; i++){             //boucle pour
                                nombre1 = nombre1 * nombreIni;  //élever nombre1
                                resultat = nombre1;             //à l'exposant
                        }                                        //nombre2
                        sprintf(memo,"%d->    %d p %d = %d",numerocalc,nombreIni,nombre2,resultat);
                }
                if(operation == 2){
                        resultat = nombre1 + nombre2;//addition de nombre1 a nombre2
                        sprintf(memo,"%d->    %d + %d = %d",numerocalc,nombre1,nombre2,resultat);
                }

                if(operation == 3){
                        resultat = nombre1 * nombre2;//produit de nombre1 et nombre2
                        sprintf(memo,"%d->    %d * %d = %d",numerocalc,nombre1,nombre2,resultat);
                }
                if(operation == 4){
                        resultat = nombre1 / nombre2;
                        sprintf(memo,"%d->    %d / %d = %d",numerocalc,nombre1,nombre2,resultat);
                }
                if(operation == 5){
                        resultat = nombre1 - nombre2;
                        sprintf(memo,"%d->    %d - %d = %d",numerocalc,nombre1,nombre2,resultat);
                }

stpcpy(affichage,affichageClear);
EdAffichage->Text = resultat;
Memo1->Lines->Insert(0,memo);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFmMain::FormCreate(TObject *Sender)
{
        Memo1->Clear();
        Memo1->ReadOnly = true;

        sprintf(memo,"Nb les opérations sont effectuées avec des entiers, la division ne donne que des résultat avec reste.");
                Memo1->Lines->Insert(0,memo);
}
//---------------------------------------------------------------------------

void __fastcall TFmMain::BuSaveMemoClick(TObject *Sender)
{
        AnsiString Save1;
        AnsiString Save2;
        AnsiString Save3;

        int nbLign = Memo1->Lines->Count;

        Save1 = "UN DOCUMENT LOG A ETE SAUVE DANS LE MEME REPERTOIRE QUE LE *.EXE";
        Save2 = "IL CONTIENT TOUT LES CALCULS EFFECTUER PAR LE PROGRAMME:";
        Save3 = "(-: Il A ETE ECRIS PAR MICHAEL FOLLONIER :-)";

        Memo1->Lines->Insert(0,Save1);
        Memo1->Lines->Insert(1,Save2);
        Memo1->Lines->Insert(nbLign+2,Save3);

        AnsiString logfileName;
        logfileName = "CalculLog.log";
        Memo1->Lines->SaveToFile(logfileName);
}
//---------------------------------------------------------------------------

void __fastcall TFmMain::BuShowClick(TObject *Sender)
{
       Memo1->Visible = true;
}
//---------------------------------------------------------------------------

void __fastcall TFmMain::ColorBox1Select(TObject *Sender)
{
        Panel1->Color = ColorBox1->Selected;
}
//---------------------------------------------------------------------------

Conclusion :


...

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
1
Date d'inscription
lundi 17 décembre 2012
Statut
Membre
Dernière intervention
17 décembre 2012

merci por les information
Messages postés
2
Date d'inscription
jeudi 5 janvier 2006
Statut
Membre
Dernière intervention
27 janvier 2006

Merci pour tes conseil.
C'est justement pour sa que j'ai mis mon "code" ici...
car cela fais juste 3 mois que j'ai comencer.
Messages postés
21041
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
30
Pour chaque bouton, il y a un strcat inconditionnel sans controle de longueur de la chaine, ne m'étonnerait pas que ça finisse par planter.

De plus, un strcat pour mettre 1 octet me semble une vaste plaisanterie:
strcat se décompose en strlen + strcpy, le strcpy est de trop:
char *c = affichage + strlen(affichage);
*c '1'; *(c+1) 0; ces 2 instructions seront autrement plus performantes en cycles et taille de code qu'un boucle strcpy et on n'encombre pas le registre .data avec des chaines inutiles.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.