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+