em linguagem C pura .. e não precisa de comando .. suporta expressões com operadores 1+1-1*1/1%1&1
(+ = soma)
(- = subtração)
(* = multiplicação)
(/ = divisão)
(% = resto da divisão)
(& = operador binário .. checa os bits (provalvemente ninguém vai usar isso na sua calc.. mais é bom ter um xP) )
e tem um bug .. não faz multiplicação e divisão primeiro \=
ta aí o code
(ps: dá pra usar o codeblocks q é bem melhor q devcpp xP)
by DarkxKakashi
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
const int bsize = 256;
const char* types = "+-*/%&";
int search(char* p, const char* delimters)
{
int string = strlen(p);
int delimt = strlen(delimters);
int it = 0;
int dt = 0;
for (it = 0;it < string;it++)
{
for (dt = 0;dt < delimt;dt++)
{
if (p[it] == delimters[dt])
return it;
}
}
return -1;
}
char* erase(char* p, int to = -1)
{
if (to == -1)
{
memset(p, 0, strlen(p));
return p;
}
memset(p, 0, to);
p = &p[to];
return p;
}
long long calculate(long long left, char op, long long right)
{
switch (op)
{
case '+':
return left + right;
case '-':
return left - right;
case '*':
return left * right;
case '/':
return left / right;
case '%':
return left % right;
case '&':
return left & right;
}
return left;
}
long long runParser(char* pt)
{
long long left = 0;
long long rigt = 0;
long long res = 0;
char alloc[bsize] = {0};
char* op = alloc;
char lp[bsize] = {0};
char rp[bsize] = {0};
char at = 0;
strcpy(op, pt);
int p = 0;
p = search(op, types);
if (p == -1)
{
res = atoll(op);
op = erase(op);
}
else
{
strncpy(lp, op, p);
left = atoll(lp);
op = erase(op, p);
}
while (p != -1 || strlen(op) != 0)
{
p = search(op, types);
if (p == -1)
{
rigt = atoll(op);
left = calculate(left, at, rigt);
res = left;
op = erase(op);
break;
}
else
{
at = op[p];
op = erase(op, p + 1);
p = search(op, types);
if (p == -1)
{
rigt = atoll(op);
left = calculate(left, at, rigt);
res = left;
op = erase(op);
break;
}
else
{
strncpy(rp, op, p);
rigt = atoll(rp);
left = calculate(left, at, rigt);
res = left;
op = erase(op, p);
continue;
}
}
}
return res;
}
void runConsole()
{
char Operation[bsize] = {0};
while (tolower(Operation[0]) != 's')
{
printf("Digite a operacao:\n");
printf("> ");
scanf("%s", Operation);
if (tolower(Operation[0]) != 's')
{
long long result = runParser(Operation);
printf("\nResultado: %ld\n\n\n", result);
}
}
}
int main(int, char**)
{
runConsole();
return 0;
}
flw
t+
aah .. sobre a calc .. eu acho q ficou mais ou menos
vc não seguiu o q disse .. vc diz q é feita em C++ e está toda em C
para o menu .. vc poderia ter feitos teclas de atalhos tipo:
F1 - sobre
F2 - soma
F3 - subtrai
etc
já os caracteres do console vc podeira CharToOem da #include <windows.h>
e então .. seu código ficaria mais legível ao invés de tentar descobrir q caractere usar no MS-DOS
já q vc não usa os parâmetros da int main .. não precisa declará-los apenas use .. int main() { ... return 0; }
while (1) não seria um bom loop =\
no caso eu usaria for(; ou um
asm("loop:")
//seu code
asm("jmp loop");
já q vc tá tratando de divisões .. seria importante ter um verificador para saber se tem '0' na expressão
pois dará 'crash' em seu app se o usuário digitar '0' na divisão..
(ps: eu não coloquei no meu code pq é apenas pra testes xP)
outra coisa q poderia melhorar .. seria separar seu código em + funções ao invés de ficar tudo numa grande main
e outra.. seu código não parece ser de autoria própria .. parece q foi baseado de um tutorial pela net xP
flw
t+