Kalkulator RPN-problem z main

0

Witam,
napisalam kilka funkcje do kalkulatora RPN i o ile samo pisanie funkcji nie sprawilo mi wiekszych problemow tak juz sama funkcja main jest dla mnie niemozliwa. Bede ogromnie wdzieczna jesli komus bedzie sie chcialo na to spojrzec poniewac ja juz 2 dni siedze i nic. Funkcja main jest "rozgrzebana" bo co rusz probuje nowych pomyslow.


#include "main.h"

/**************************************************************************/
/*                                                                        */
/* W tym pliku znajduja sie funkcje odpowiadajace za konwersje z zapisu   */
/* infiksowego(normalnego) na postfiksowy (ONP). W tym celu uzywam stosu  */
/* znakow. Dla ulatwienia stosuje stos jako zmienna globalna. Nie jest to */ 
/* wskazane gdy zalezy nam na przenoscnosci ale w tym przypadku  nie ma   */
/* takiej potrzeby.                                                       */
/*                                                                        */
/**************************************************************************/

/* Funkcja porownujaca priorytety operatorow */
int P(char o)
{
    if(o=='(') return 0;
    if(o=='+' || o=='-' || o==')' ) return 1;
    if(o=='*' || o=='/') return 2;
    if(o=='^') return 3;
}

/*************************************************************************/
/* Funkcje i deklaracje odpowiadajace za stos operatorow                 */
/* Stos globalny gdyz latwiejszy w uzyciu                                */
/*************************************************************************/
typedef struct StackPointer
{
    char a;
    struct StackPointer *p;
} CharStack;

CharStack* stack=NULL;

void CharPush(char a)
{
    CharStack* s;
    s=(CharStack*)malloc(sizeof(CharStack));
    s->a=a;
    s->p=stack;
    stack=s;
}

int CharEmpty()
{
    if(stack==NULL) return 1; else return 0;
}

char CharPop()
{
    char a;
    CharStack* s;
    if (stack==NULL) return '\0';
    a=stack->a;
    s=stack->p;
    free(stack);
    stack=s;
    return a;
}

void CharClear()
{
    while(stack)
    {
        CharPop();
    }
}

int funkcja=0;

/**************************************************************************/
/*                                                                        */
/* Glówna funkcja konwersji rozklada pojedynczy ciag na sladowe(liczby,   */
/* operatory i funkcje). Wynik dzialania jest przekazywany w 2 wymiarowej */
/* tablicy out.                                                               */
/*                                                                        */
/**************************************************************************/
int ToONP(char* in,int* ile, char out[COUNT][SIZE])
{
    int i=0,j=0,pom=0;
    char s[SIZE]="";
    char a;
    CharClear();
    while(in[i]!='\0')                                           /* Dopuki nie jest koniec stringa            */
    {
        if((in[i]>='0' && in[i]<='9') || in[i]=='.')             /* Jesli natrafimy na cyfre                  */
        {
            pom=0;
            while((in[i]>='0' && in[i]<='9') || in[i]=='.')      /* Dopuki liczba                             */
            {
                s[pom++]=in[i];                                  /* Kopiujemy cyfra po cyfrze                 */ 
                i++;
            }
            s[pom]='\0';                                         /* Koniec liczby                             */
            strcpy(out[j],s);                                    /* Kopiujemy na wyjscie                      */
            j++;
        }
        else if(in[i]=='+' || in[i]=='-' || in[i]=='*' || in[i]=='/' || in[i]=='^') /* Jesli natrafimy na opwrator */
        {
      if(CharEmpty())
        CharPush(in[i]);
      else if((P(in[i])>P(CharPop())))               /* Sprawdzamy stos operatorów                 */                 
                    {CharPush(a); CharPush(in[i]); }             /* to odkladamy go na stos                    */ 
            else
            {
                out[j][0]=a; out[j][1]='\0'; j++;                /* Dopuki priorytet operatora ze stosu jest   */
                while(P(a=CharPop())>=P(in[i]))                  /* wiekszy niz priorytet nowego operatora     */
                {                                                /* zdejmujemy ze stosu i odkladamy na wyjscie */
                    out[j][0]=a; out[j][1]='\0'; j++;
                }
                CharPush(a); CharPush(in[i]); 
            }
            i++;
        }
        else if(in[i]=='(')                                      /* Nawias otwierajacy kladzeimy na stos       */
        {
            CharPush(in[i]);
            i++;
        }
        else if(in[i]==')')                                      /* Nawias zamykajacy                          */
        {
            char a;
            while((a=CharPop())!='(')                            /* Zdejmujemy ze stosu wszystko az do napotkania */
            {                                                    /* nawiasu otwierajacego. gdy go nie ma zglaszamy */
                if(a=='\0')                                      /* blad i konczymy program                       */
                {
                    printf("Syntax Error: blad z iloscia nawiasow\n");
                    exit(-1);
                }
                out[j][0]=a; out[j][1]='\0'; j++;
            }
            i++;
        }
        else if(in[i]<0)                                         /* Gdy napotkamy funkcje to ja kladziemy na stos */ 
        {
            CharPush(in[i]);
            i++;
        } 
        else if(in[i]==' ') {i++;}                               /* Pomijamy spacje                               */
        else
        {
            printf("Not allowed: %c\n",in[i]);
            exit(-1);
        }

    } 
    while((a=CharPop())!='\0')                                   /* Gdy skonczy sie wejscie zdejmujemy ze stosu   */
    {
        if(a=='(')
        {
            printf("Syntax Error: blad z iloscia nawiasow\n");
            exit(-1);
        }
        out[j][0]=a; out[j][1]='\0'; j++;                        /* i odkladamy na wyjscie                        */       
    }
    *ile=j;
    return funkcja;
}

/* funkcja dodawania znaku na koncu stringa. NIE SPRAWDZA CZY MIEJSCA WYSTARCZY! */
void addc(char* in, char a)
{
    int i=-1;
    while(in[++i]!='\0');
    in[i++]=a;
    in[i]='\0';
}

/**************************************************************************/
/*                                                                        */
/* Funkcja Normalizujaca wejscie. Usuwa spacje, kowertuje funkcje na      */
/* pojedyncze znaki, dodaje wartosci pi i e, rozpoznaje minusy negacji    */
/* i inne tym podobne. Przy okazji wylapuje wiekszosc bledów w skladni    */
/*                                                                        */
/**************************************************************************/
void Normal(char in[100], char out2[100])
{
    int i=0,last=0,pom;
    char s[10]="";
    char out[100]="";
    while(in[i]!='\0')
    {
        if((in[i]>='0' && in[i]<='9') || in[i]=='.')           /* Liczby zwyczajnie przepisujemy      */ 
        {
            last=LICZBA;                                       /* Zaznaczamy ze byla to liczba        */
            pom=0;
            while((in[i]>='0' && in[i]<='9') || in[i]=='.')
            {
                s[pom++]=in[i];
                i++;
            }
            s[pom]='\0';
            if(s[0]=='.' && s[1]=='\0') 
            {
                printf("Sama Kropka...");
                exit(-1);
            }
            strcat(out,s);
        }
        else if(in[i]=='+' || in[i]=='-' || in[i]=='*' || in[i]=='/' || in[i]=='^') /* gdy wykryjemy operator */
        {
            /* Jesli wykryjemy znak minus to moze sie okazac ze jest to negacja np. 8+-1 <=> 8+(-1) <=> 8+negacja(1) */
            /* -sin(pi) <=> negacja(sin(pi) itd.                                                                     */
            if((last==OPERATOR || last==OPEN || last==0) && in[i]=='-')  { addc(out,NEG); } 
            /* Operator + wystepujacy podobnie jak negacja nie ma wplywu na wynik wiec mozna go pominac na przyklad  */
            /* 8-+2 <=> 8-(+2) <=> 8-2 +sin(pi) <=> sin(pi)                                                          */
            else if((last==OPERATOR || last==OPEN || last==0) && in[i]=='+') {}
            /* Gdy ktos dal kolo siebie dwa operatory nie mogace razem wystapic                                      */
            else if(last==OPERATOR) { printf("Nie za duzo tych operatorow...? "); exit(-1); }
            else
            {
                s[0]=in[i]; s[1]='\0';                    /* W innym przypadku podajemy operator na wyjscie          */    
                strcat(out,s);
            }
            last=OPERATOR;                                /* Zapiamietujemy ze ostatnio                              */
            i++;
        }
        else if(in[i]=='(')
        {

            if(last==LICZBA) { strcat(out,"*(");}         /* Rozwijamy skroty myslowe: 3(2+1) <=> 3*(2+1)           */ 
            else {strcat(out,"(");}                       /* Kopiujemy nawias na wyjscie                            */
            i++; 
            last=OPEN;                                    /* Zapamietujemy ze byl nawias                            */
        }
        else if(in[i]==')')                               /* Nawias zamykajacy bez kontrowersji kopijemy na wyjscie */
        {
            last=CLOSE;
            strcat(out,")");
            i++;
        }
        else if(in[i]==' ') {i++;}                        /* Spacje pomijamy                                        */
        else if((in[i]>='a' && in[i]<='z') || (in[i]>='A' && in[i]<='Z'))/* Jesli trafimy na ciag liter             */
        {
            pom=0;
            while((in[i]>='a' && in[i]<='z') || (in[i]>='A' && in[i]<='Z'))/* Wczytujemy caly                       */
            {
                s[pom++]=in[i];
                i++;
            }
            s[pom]='\0';
            if(last==LICZBA || last==CLOSE) strcat(out,"*");/* Znowu skrot myslowy 3sin(pi) <=> 3*sin(pi)           */
            /* zaleznie od nazwy dodajemy na wyscie znak odpowiadajacy danej funkcji                                */
            if(strcmp(s,"cos")==0)      {addc(out,COS); last=FUNKCJA;} 
            else if(strcmp(s,"sin")==0) {addc(out,SIN); last=FUNKCJA;}
            else if(strcmp(s,"ctg")==0) {addc(out,CTG); last=FUNKCJA;}
            else if(strcmp(s,"log")==0) {addc(out,LOG); last=FUNKCJA;}
            else if(strcmp(s,"exp")==0) {addc(out,EXP); last=FUNKCJA;}
            else if(strcmp(s,"ln")==0)  {addc(out,LN);  last=FUNKCJA;}
            else if(strcmp(s,"x")==0)   {addc(out,VAR); last=LICZBA; funkcja=1; }
            else if(strcmp(s,"tg")==0 || strcmp(s,"tan")==0){addc(out,TAN); last=FUNKCJA;}
            else if(strcmp(s,"pi")==0) {strcat(out,"3.14159265"); last=LICZBA; } /* liczbe pi rozwijamy  */
            else if(strcmp(s,"e")==0) /* podobnie e z tym ze e moze robic za e w zapisie naukowym 3e2 <=> 3*10^2    */
            {if((in[i]>='0' && in[i]<='9')|| in[i]=='-') {strcat(out,"10^"); last=OPERATOR;} else { strcat(out,"2.71828182"); last=LICZBA;} }
            else {printf("Nie znam funkcji %s ",s); exit(-1); }

        }
        else
        {
            printf("Not allowed symbol: %c\n",in[i]);
            exit(-1);
        }
    }
    strcpy(out2,out);
}
 #include"main.h"
/**************************************************************************/
/*                                                                        */
/* W tym pliku znajduja sie funkcje odpowiadajace za policzenie RPN.      */
/*                                                                        */
/**************************************************************************/

/*************************************************************************/
/* Funkcje i deklaracje odpowiadajace za stos liczb                      */
/*************************************************************************/
typedef struct StackPointerF
{
    float a;
    struct StackPointerF *p;
} FStack;

void FPush(FStack** stos, float a)
{
    FStack* s;
    s=(FStack*)malloc(sizeof(FStack));
    s->a=a;
    s->p=*stos;
    *stos=s;
}

float FPop(FStack** stos)
{
    float a;
    FStack* s;
    if (stos==NULL) { printf("Syntax Error: za malo argumentow"); exit(-1); }
    a=(*stos)->a;
    s=(*stos)->p;
    free(*stos);
    *stos=s;
    return a;
}

void FClear(FStack** stos)
{
    while(*stos)
    {
        FPop(stos);
    }
}

/**************************************************************************/
/* Funkcja sluzaca do policzenia wartosci wyrazenia RPN                   */
/**************************************************************************/
float Count(char out[COUNT][SIZE], int ile, float x)
{
    FStack* stos=NULL;
    int i;
    float a=0,b=0;
    char s[SIZE];
    char k;
    FClear(&stos);
    for(i=0; i<ile; i++)
    {
        if((out[i][0]>='0' && out[i][0]<='9') || out[i][0]=='.') /* Dla cyfry wczytujemy ja i odkladamy na stos */
        {
            sscanf(out[i],"%f",&a);
            FPush(&stos,a);
        }
        else
        {
            k=out[i][0];
            switch(k)               /* sprawdzamy jaka funkcja i opdowiedniu reagujemy  */
            {
            case '+':
                a=FPop(&stos);
                b=FPop(&stos);
                FPush(&stos,b+a);
                break;
            case '-':
                a=FPop(&stos);
                b=FPop(&stos);
                FPush(&stos,b-a);
                break;
            case '*':
                a=FPop(&stos);
                b=FPop(&stos);
                FPush(&stos,b*a);
                break;
            case '/':
                a=FPop(&stos);
                b=FPop(&stos);
                FPush(&stos,b/a);
                break;
            case '^':
                a=FPop(&stos);
                b=FPop(&stos);
                FPush(&stos,pow(b,a));
                break;
            case NEG:
                a=FPop(&stos);
                FPush(&stos,-a);
                break;
            case COS:
                a=FPop(&stos);
                FPush(&stos,cos(a));
                break;
            case SIN:
                a=FPop(&stos);
                FPush(&stos,sin(a));
                break;
            case TAN:
                a=FPop(&stos);
                FPush(&stos,tan(a));
                break;
            case CTG:
                a=FPop(&stos);
                FPush(&stos,1/tan(a));
                break;
            case EXP:
                a=FPop(&stos);
                FPush(&stos,exp(a));
                break;
            case VAR:
                FPush(&stos,x);
                break;
            }
        }
    }
    return FPop(&stos);
}
#include"main.h"

/**************************************************************************/
/* W tym pliku znajduja sie funkcje odpowiadajace za dzialanie programu   */
/* zgodnie z zalozeniami zadania.                                        */
/**************************************************************************/

/*************************************************************************/
/* Funkcje i deklaracje odpowiadajace za stos liczb                      */
/*************************************************************************/
typedef struct elem
{
        int dana;
        struct elem* nast;
}T_elem;

void Init(T_elem** stos){}

int Empty(T_elem* stos)
{
    if(stos==NULL) return 1; else return 0;
}

void Push(T_elem** stos,int a)
{
    T_elem* pom=(T_elem*)malloc(sizeof(T_elem));
    pom->dana=a;
    pom->nast=*stos;
    *stos=pom;
}

int Pop(T_elem** stos)
{
    int a;
    T_elem* pom;
    if(Empty(*stos))
    {
        fprintf(stderr,"No to mamy problem: Stos jest pust!!\n");
        exit(-1);
    }
    a=(*stos)->dana;
    pom=(*stos)->nast;
    free(*stos);
    *stos=pom;
    return a;
}

void Print(T_elem* stos)
{
    while(stos!=NULL)
    {
        printf("%d ",(stos)->dana);
        stos=stos->nast;
    }
}

/*************************************************************************/
/* Funkcje i deklaracje odpowiadajace za stos liczb na tablicy           */
/* wystarczy odkomentowac ponizszej i zakomentowac powyzej               */
/* W stosie tym nie sprawdzany jest rozmiar!                             */
/*************************************************************************/

/*#define SIZE 100
typedef struct elem
{
        int w;
        int t[SIZE];
}T_elem;

void Init(T_elem** stos)
{
    (*stos)=(T_elem*)malloc(sizeof(T_elem));
    (*stos)->w=-1;
}
int Empty(T_elem* stos)
{
    if(stos->w==-1) return 1; else return 0;
}

void Push(T_elem** stos,int a)
{
    (*stos)->w++;
    (*stos)->t[(*stos)->w]=a;
}

int Pop(T_elem** stos)
{

    int a;
    if(Empty(*stos))
    {
        fprintf(stderr,"No to mamy problem: Stos jest pust!!\n");
        exit(-1);
    }
    a=(*stos)->t[(*stos)->w];
    (*stos)->w--;
    return a;
}

void Print(T_elem* stos)
{
    int a=stos->w;
    while(a>=0)
    {
        printf("%d ",(stos)->t[a]);
        a--;
    }
}

/**************************************************************************/
/*                                                                        */
/* Funkcja pobiera od uzytkownika polecenia i odpowiednio reaguje         */
/*                                                                        */
/**************************************************************************/
int TrybZadania()
{
    int a,b;
    char s[100];
    T_elem* stos=NULL;
    Init(&stos);

    while(1)
    {
        scanf("%s",s);
        if((s[0]<='9' && s[0]>='0') || (s[0]=='-' && s[1]<='9' && s[1]>='0')) /* Jesli byla liczba(moze zaczac sie minusem) */
        {
            sscanf(s,"%d",&a);
            Push(&stos,a);
        }else if(s[0]=='+')  /* jesli operator '+' */
        {
            a=Pop(&stos);
            b=Pop(&stos);
            Push(&stos,b+a);
        }else if(s[0]=='-') /* jesli operator '-' */
        {
            a=Pop(&stos);
            b=Pop(&stos);
            Push(&stos,b-a);
        }else if(s[0]=='*') /* jesli operator '*' */
        {
            a=Pop(&stos);
            b=Pop(&stos);
            Push(&stos,b*a);
        }else if(s[0]=='/') /* jesli operator '/' */
        {
            a=Pop(&stos);
            b=Pop(&stos);
            Push(&stos,b/a);
        }else if(s[0]=='#') /* jesli operator '#' sciagamy jeden element */
        {
            a=Pop(&stos);
        }else if(s[0]=='$') /* jesli operator '$' zamiana miejscami */
        {
            a=Pop(&stos);
            b=Pop(&stos);
            Push(&stos,a);
            Push(&stos,b);
        }else if(s[0]=='&') /* jesli operator '&' zdublowanie */
        {
            a=Pop(&stos);
            Push(&stos,a);
            Push(&stos,a);
        }else if(s[0]=='?') /* jesli operator '?' wypisujemy stos */
        {
            Print(stos);
        }else if(s[0]=='q') /* jesli operator 'q' konczymy */
        {
            break;
        }
    }
    return 0;
} 
 #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

#define SIZE 15
#define COUNT 30

#define LICZBA 1
#define OPERATOR 2
#define OPEN 3
#define CLOSE 4
#define FUNKCJA 6

enum F{SIN=-128,COS,TAN,CTG,LN,LOG,NEG,EXP,VAR};

int ToONP(char* in,int* ile, char out[COUNT][SIZE]);

float Count(char out[COUNT][SIZE], int ile, float x);

void Normal(char in[], char out[]);

int TrybZadania();
#include"main.h"

/**********************************************************************************************/
/*                              PROGRAM RPN LEKKO PODRASOWANY                                 */
/*  W swoim programie skupilam sie na troche innej czesci tematu zwiazanego z RPN       */
/* niz to bylo zadane w zadaniu. Miedzy innymi napisalam konwersje z "normalnego" stylu na RPN*/
/* dodalam tez wiekszesc uzytecznych funkcji takich jak sinusy czy cosinus oraz stale pi i e  */
/* 1.nie dziala main 2.problem z czytaniem nawiasow 3.sprawdz logarytm                                 */
/**********************************************************************************************/

int main()
{ 
    char out[COUNT][SIZE];
    int i,ile=0;
    float a;
    char s2[100];
    char s[100];
    printf("Kalkulator RPN \n");
    printf("Wpisz dzialanie:     \n");
    scanf("%s", s);
    while(i != 'q')
{
        Normal(s,s2);
    printf("%s\n",s2);
        ToONP(s2,&ile,out);
        a=Count(out,ile,0);
        printf("Wartosc1:      %f\n",a);
        }
return 0;

} 
4

Pierwsze co się nasuwa to "ała!". Po co tyle kodu?
Jeśli to zadanie na zaliczenie to program jest zdecydowanie za długi.
Zbyt dużo ambicji włożone w zbyt prosty problem.

Kilka uwag:

1) Napisz konkretnie co Ci nie działa. Jeśli nie wiesz - uruchamiaj po kolei części które wiesz do czego służą i sprawdzaj czy działają.

2) Ten kod poniżej jest przykładem na tezę że komentarze mogą być czymś w rodzaju "coding smell" - czyli smrodkiem:

/* Funkcja porownujaca priorytety operatorow */
int P(char o)

Tłumaczysz co robi funkcja zamiast ją porządnie nazwać.

3) Kod:

while(in[i]!='\0')                                           /* Dopuki nie jest koniec stringa            */

Masz tu dwa błędy:

  • ortograficzny
  • komentarz na końcu linii w formie /../ jest słaby do modyfikacji. lepiej albo zrobić go powyżej linii albo używać //

4) ToONP

  • nie powinnaś wychodzić z tej funkcji przez exit(-1); (zwracaj wynik wyżej)
  • funkcja jest za długa

5) funkcje typu CharAaa() powinny mieć przekazywany stos na którym operują

6) gdy pobierasz string przez scanf ogranicz liczbę znaków które może wprowadzić użytkownik:

scanf("%s", s);

Użyj:
a)

scanf("%99s", s);

lub
b) fgets
lub
c)

scanf_s("%99s", s, 100);
0

Dziękuje bardzo za odpowiedź, czasami człowiek się nauczy więcej na forum niż na zajęciach :) za literówki i błędy ortograficzne w komentarzach bardzo przepraszam. To że przekombinowałam w tym kodzie to wiem, ale mam pytanie: czy modyfikować ten kod czy napisać nowy, krótszy, prostszy?

0
monikaz napisał(a):

Dziękuje bardzo za odpowiedź, czasami człowiek się nauczy więcej na forum niż na zajęciach :) za literówki i błędy ortograficzne w komentarzach bardzo przepraszam. To że przekombinowałam w tym kodzie to wiem, ale mam pytanie: czy modyfikować ten kod czy napisać nowy, krótszy, prostszy?

Sama zdecyduj. Na początek zrób 4 działania i liczby całkowite.
Poza tym RPN to np:

12 3 * 4 + 8 -

Jak to się ma do nawiasów i priorytetów operatorów?

http://pl.wikipedia.org/wiki/Odwrotna_notacja_polska

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0