C calculadora multipla com base 2,8, 16

[João Vitor Sacramento Rocha 7]

code<'

#include <stdio.h>
#include <stdlib.h>
#include<math.h>
#include<locale.h>

#define SIZE 255
#define ALG 17
int number,opcao=6;

// Esta função converte um número decimal para a base 2, 8 ou 16.
// Recebe como parâmetro um número decimal (num_dec), e a base (base) cujo número será convertido.
void decToBase(int num_dec, int base)
{
    setlocale(LC_ALL,"Portuguese");
   char resto[ALG] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}, num_conv[SIZE];
   int indx = 0;

   // Este loop realiza as operações de divisão. Os restos são guardados no vetor 'num_conv'
   while(num_dec > 0)
    {
       num_conv[indx] = resto[num_dec % base];
       num_dec /= base;
       indx++;
    }

   // Exclui o caractere especial '\0' do final da string
   indx -= 1;

   // Utilizado para identificar a saída do programa
   switch(base)
   {
       case 2 : printf("BINARIO: "); break;
       case 8 : printf("OCTAL: "); break;
       case 16 : printf("HEXADECIMAL: "); break;
   }

   // Inverte a string contida no vetor num_conv
   for(indx; indx >= 0; indx--)
       printf("%c", num_conv[indx]);
   printf("\n");

}

// Esta função permite converter um número na base 2, 8 ou 16 para a base decimal.
// Recebe como parâmetro uma string (representação do número), e um número inteiro que
// determina em qual base está o número do primeiro parâmetro.
void baseToDec(char* num_base, int base) //parti para copiar para case
  {
      setlocale(LC_ALL, "Portuguese");
    int indx = 0, exp = 0, cont = 0, dec = 0, num = 0;

    // Este loop determina o tamanho da string
    while(num_base[cont] != '\0') {
        cont++;
    }

    // Neste loop, a string é percorrida de trás para frente. Cada caractere é convertido
    // em um número inteiro, multiplicado pela base elevada ao expoente (0..Comprimento da string)
    // e somado ao valor da variável 'dec', que recebe as somas sucessivas.
    for(exp, indx=(cont-1); exp < cont; exp++, indx--)
    {
        if(base == 16)
        {
            switch(num_base[indx]) {
                case 'A' : case 'a' : num = 10; break;
                case 'B' : case 'b' : num = 11; break;
                case 'C' : case 'c' : num = 12; break;
                case 'D' : case 'd' : num = 13; break;
                case 'E' : case 'e' : num = 14; break;
                case 'F' : case 'f' : num = 15; break;
                default : num = (int)num_base[indx] - (int)'0';
            }
        }
        else
            num = (int)num_base[indx] - (int)'0';

        // Aqui avalia se o usuário digitou um número válido ou não!
        if(num > (base-1) || num < 0) {
            printf("Você informou um número inválido!\n");
            exit(0);
        }
        dec += num * pow(base, exp);
    }

    // O número convertido para decimal é exibido
    printf("DECIMAL: %d\n", dec);
    number=dec;
}

// Função que imprime o menu da calculadora
void menu(void)
{
    setlocale(LC_ALL, "Portuguese");
    printf("\nBEM-VINDO AO CONVERSOR DE BASES NUMERICAS\n");
    printf("=========================================================\n\n");
    printf("*******     ********    *         *\n");
    printf("*           *            *       *\n");
    printf("******      ******        *     *\n");
    printf("*           *              *   *\n");
    printf("*******     *                *\n");
    printf("=========================================================\n\n");
    printf("[ 1 ] DECIMAL     ->  BINARIO, OCTAL e HEXADECIMAL\n");
    printf("[ 2 ] BINARIO     ->  DECIMAL, OCTAL e HEXADECIMAL\n");
    printf("[ 3 ] OCTAL       ->  DECIMAL, BINARIO e HEXADECIMAL\n");
    printf("[ 4 ] HEXADECIMAL ->  DECIMAL, BINARIO, OCTAL\n");
    printf("[ 0 ] SAIR\n");
    printf("*********************************************************\n\n");
}

// Função que chama as funções correspondentes à opção escolhida
void process_calc(int opt)
{
    setlocale(LC_ALL, "Portuguese");
    char str[SIZE];
    char calc[SIZE];
    char* num_base;
    int base;
    int indx = 0, exp = 0, cont = 0, dec = 0, num = 0;
    switch(opt)
    {
        case 0 :
            printf("CALCULADORA ENCERRADA!\n");
            exit(0);

        case 1 :
            printf("DECIMAL: ");
            scanf("%d", &number);
            decToBase(number, 2);
            decToBase(number, 8);
            decToBase(number, 16);
            break;
        case 2 :
            printf("BINARIO: ");
            scanf("%s", str);
            num_base= str;
            base=2;

        // Este loop determina o tamanho da string
        while(num_base[cont] != '\0')
        {
            cont++;
        }

        // Neste loop, a string é percorrida de trás para frente. Cada caractere é convertido
        // em um número inteiro, multiplicado pela base elevada ao expoente (0..Comprimento da string)
        // e somado ao valor da variável 'dec', que recebe as somas sucessivas.
        for(exp, indx=(cont-1); exp < cont; exp++, indx--)
        {
            num = (int)num_base[indx] - (int)'0';

            // Aqui avalia se o usuário digitou um número válido ou não!
            if(num > (base-1) || num < 0)
            {
                printf("Você informou um número inválido!\n");
                exit(0);
            }
            dec += num * pow(base, exp);
        }

        // O número convertido para decimal é exibido
        printf("DECIMAL: %d\n", dec);
        number=dec;

            decToBase(number, 8);
            decToBase(number, 16);
        break;
        case 3 :
            printf("OCTAL = ");
            scanf("%s", str);
            num_base= str;
            base=8;
            // Este loop determina o tamanho da string
            while(num_base[cont] != '\0')
            {
                cont++;
            }

            // Neste loop, a string é percorrida de trás para frente. Cada caractere é convertido
            // em um número inteiro, multiplicado pela base elevada ao expoente (0..Comprimento da string)
            // e somado ao valor da variável 'dec', que recebe as somas sucessivas.
            for(exp, indx=(cont-1); exp < cont; exp++, indx--)
            {
                num = (int)num_base[indx] - (int)'0';

                // Aqui avalia se o usuário digitou um número válido ou não!
                if(num > (base-1) || num < 0)
                {
                    printf("Você informou um número inválido!\n");
                    exit(0);
                }
                dec += num * pow(base, exp);
            }

            // O número convertido para decimal é exibido
            printf("DECIMAL: %d\n", dec);
            number=dec;
            decToBase(number, 2);
            decToBase(number, 16);
            break;
        case 4 :
            printf("HEXADECIMAL = ");
            scanf("%s", str);
            num_base= str;
            base=16;

            // Este loop determina o tamanho da string
            while(num_base[cont] != '\0')
            {
                cont++;
            }

            // Neste loop, a string é percorrida de trás para frente. Cada caractere é convertido
            // em um número inteiro, multiplicado pela base elevada ao expoente (0..Comprimento da string)
            // e somado ao valor da variável 'dec', que recebe as somas sucessivas.
            for(exp, indx=(cont-1); exp < cont; exp++, indx--)
            {
                if(base == 16)
            {
                switch(num_base[indx])
                {
                case 'A' : case 'a' : num = 10; break;
                case 'B' : case 'b' : num = 11; break;
                case 'C' : case 'c' : num = 12; break;
                case 'D' : case 'd' : num = 13; break;
                case 'E' : case 'e' : num = 14; break;
                case 'F' : case 'f' : num = 15; break;
                default : num = (int)num_base[indx] - (int)'0';
                }
            }
            else
            {
            num = (int)num_base[indx] - (int)'0';
            }
            // Aqui avalia se o usuário digitou um número válido ou não!
            if(num > (base-1) || num < 0)
            {
                printf("Você informou um número inválido!\n");
                exit(0);
            }
            dec += num * pow(base, exp);
            }
            // O número convertido para decimal é exibido
            printf("DECIMAL: %d\n", dec);
            number=dec;
            decToBase(number, 2);
            decToBase(number, 8);
            break;
        default :
            printf("OPÇÃO NÃO PERMITIDA!\nTENTE NOVAMENTE\n");
            break;
    }
}

int main(void)
{
    while(opcao!=0)
    {
    setlocale(LC_ALL, "Portuguese");
    menu();
    printf("QUAL OPERACAO DESEJA REALIZAR? ");
    scanf("%d", &opcao);
    process_calc(opcao);
    system("pause");
    system("cls");
    }
    return 0;

}
'>

[devair1010 1.798]

@João Vitor Sacramento Rocha     seu código ficou bom , funcionando bem ,  uma melhoria seria usar a função  toupper  para converter para maiúscula ,  nessa parte :

for(exp, indx=(cont-1); exp < cont; exp++, indx--)
    {
        if(base == 16)
        {
            switch(toupper(num_base[indx])) {
                case 'A' :num = 10; break;
                case 'B' :num = 11; break;
                case 'C' :num = 12; break;
                case 'D' :num = 13; break;
                case 'E' :num = 14; break;
                case 'F' :num = 15; break;
                default : num = (int)num_base[indx] - (int)'0';
            }
        }
        else
            num = (int)num_base[indx] - (int)'0';