SHARE
TWEET

(Didático) Conversor de bases numéricas em C

Mateus_Costa May 19th, 2019 57 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4. #include <string.h>
  5.  
  6. int main(void)
  7. {
  8.     int menu1;
  9.  
  10.     do{
  11.         printf("--- CALCULADORA ---\n");
  12.         printf("Escolha a base que o valor SE ENCONTRA:\n");
  13.         printf("1. Binario\n");
  14.         printf("2. Octal\n");
  15.         printf("3. Decimal\n");
  16.         printf("4. Hexadecimal\n");
  17.         printf("0. Sair\n");
  18.         setbuf(stdin, NULL);
  19.         scanf("%d", &menu1);
  20.  
  21.         int submenu1;
  22.  
  23.         switch(menu1){
  24.         /* BIN */
  25.         case 1:
  26.             printf("Escolha a base que o valor SERA CONVERTIDO:\n");
  27.             printf("1. Octal\n");
  28.             printf("2. Decimal\n");
  29.             printf("3. Hexadecimal\n");
  30.             printf("0. Voltar\n");
  31.             setbuf(stdin, NULL);
  32.             scanf("%d", &submenu1);
  33.  
  34.             switch(submenu1){
  35.             /* OCT */
  36.             case 1:
  37.                 {
  38.                     printf("Digite o valor em BIN: ");
  39.  
  40.                     char valBase2[33]; /* precisão de 32 dígitos + EOS */
  41.                     setbuf(stdin, NULL);
  42.                     scanf("%s", valBase2);
  43.  
  44.                     /* convertendo para a base decimal */
  45.                     int valBase10 = 0;
  46.                     int expoent = 0;
  47.                     int i;
  48.                     for(i = strlen(valBase2) - 1; i >= 0; i--) {
  49.                         int digit = valBase2[i] - 48;
  50.                         int tmp = digit * pow(2, expoent);
  51.                         valBase10 = valBase10 + tmp;
  52.                         expoent = expoent + 1;
  53.                     }
  54.  
  55.                     /* convertendo de decimal para octal */
  56.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  57.                     int dividendo = valBase10;
  58.  
  59.                     int pos = 0;
  60.                     while(dividendo >= 8) {
  61.                         int r = dividendo % 8;
  62.                         buffer[pos] = r + 48; /* ajusta o int de acordo com a tabela ASCII */
  63.                         pos++;
  64.                         dividendo = dividendo / 8;
  65.                     }
  66.                     buffer[pos] = dividendo + 48;
  67.                     pos++;
  68.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  69.  
  70.                     /* inverte o vetor */
  71.                     char valBase8[33];
  72.                     int j;
  73.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  74.                         valBase8[j] = buffer[i];
  75.                     }
  76.                     valBase8[j] = '\0';
  77.                     printf("%s (OCT)\n", valBase8);
  78.                 }
  79.                 break;
  80.             /* DEC */
  81.             case 2:
  82.                 {
  83.                     printf("Digite o valor em BIN: ");
  84.  
  85.                     char valBase2[33]; /* precisão de 32 dígitos + EOS */
  86.                     setbuf(stdin, NULL);
  87.                     scanf("%s", valBase2);
  88.  
  89.                     /* convertendo para a base decimal */
  90.                     int valBase10 = 0;
  91.                     int expoent = 0;
  92.                     int i;
  93.                     for(i = strlen(valBase2) - 1; i >= 0; i--) {
  94.                         int digit = valBase2[i] - 48;
  95.                         int tmp = digit * pow(2, expoent);
  96.                         valBase10 = valBase10 + tmp;
  97.                         expoent = expoent + 1;
  98.                     }
  99.  
  100.                     printf("%d (DEC)\n", valBase10);
  101.                 }
  102.                 break;
  103.             /* HEX */
  104.             case 3:
  105.                 {
  106.                     printf("Digite o valor em BIN: ");
  107.  
  108.                     char valBase2[33]; /* precisão de 32 dígitos + EOS */
  109.                     setbuf(stdin, NULL);
  110.                     scanf("%s", valBase2);
  111.  
  112.                     /* convertendo para a base decimal */
  113.                     int valBase10 = 0;
  114.                     int expoent = 0;
  115.                     int i;
  116.                     for(i = strlen(valBase2) - 1; i >= 0; i--) {
  117.                         int digit = valBase2[i] - 48;
  118.                         int tmp = digit * pow(2, expoent);
  119.                         valBase10 = valBase10 + tmp;
  120.                         expoent = expoent + 1;
  121.                     }
  122.  
  123.                     /* convertendo de decimal para hexadecimal */
  124.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  125.                     int dividendo = valBase10;
  126.  
  127.                     int pos = 0;
  128.                     while(dividendo >= 16) {
  129.                         int r = dividendo % 16;
  130.                         if(r <= 9) {
  131.                             buffer[pos] = r + 48;
  132.                         }
  133.                         else if(r <= 15) {
  134.                             buffer[pos] = r + 55;
  135.                         }
  136.                         pos++;
  137.                         dividendo = dividendo / 16;
  138.                     }
  139.                     if(dividendo <= 9) {
  140.                         buffer[pos] = dividendo + 48;
  141.                     }
  142.                     else if(dividendo <= 15) {
  143.                         buffer[pos] = dividendo + 55;
  144.                     }
  145.                     pos++;
  146.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  147.  
  148.                     /* inverte o vetor */
  149.                     char valBase16[33];
  150.                     int j;
  151.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  152.                         valBase16[j] = buffer[i];
  153.                     }
  154.                     valBase16[j] = '\0';
  155.                     printf("%s (HEX)\n", valBase16);
  156.                 }
  157.                 break;
  158.             case 0:
  159.                 printf("Voltando...\n");
  160.                 break;
  161.             default:
  162.                 printf("Opcao invalida!\n");
  163.             }
  164.  
  165.             break;
  166.         /* OCT */
  167.         case 2:
  168.             printf("Escolha a base que o valor SERA CONVERTIDO:\n");
  169.             printf("1. Binario\n");
  170.             printf("2. Decimal\n");
  171.             printf("3. Hexadecimal\n");
  172.             printf("0. Voltar\n");
  173.             setbuf(stdin, NULL);
  174.             scanf("%d", &submenu1);
  175.  
  176.             switch(submenu1){
  177.             /* BIN */
  178.             case 1:
  179.                 {
  180.                     printf("Digite o valor em OCT: ");
  181.  
  182.                     char valBase8[33]; /* precisão de 32 dígitos + EOS */
  183.                     setbuf(stdin, NULL);
  184.                     scanf("%s", valBase8);
  185.  
  186.                     /* convertendo para a base decimal */
  187.                     int valBase10 = 0;
  188.                     int expoent = 0;
  189.                     int i;
  190.                     for(i = strlen(valBase8) - 1; i >= 0; i--) {
  191.                         int digit = valBase8[i] - 48;
  192.                         int tmp = digit * pow(8, expoent);
  193.                         valBase10 = valBase10 + tmp;
  194.                         expoent = expoent + 1;
  195.                     }
  196.  
  197.                     /* convertendo de decimal para binário */
  198.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  199.                     int dividendo = valBase10;
  200.  
  201.                     int pos = 0;
  202.                     while(dividendo >= 2) {
  203.                         int r = dividendo % 2;
  204.                         buffer[pos] = r + 48; /* ajusta o int de acordo com a tabela ASCII */
  205.                         pos++;
  206.                         dividendo = dividendo / 2;
  207.                     }
  208.                     buffer[pos] = dividendo + 48;
  209.                     pos++;
  210.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  211.  
  212.                     /* inverte o vetor */
  213.                     char valBase2[33];
  214.                     int j;
  215.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  216.                         valBase2[j] = buffer[i];
  217.                     }
  218.                     valBase2[j] = '\0';
  219.                     printf("%s (BIN)\n", valBase2);
  220.                 }
  221.                 break;
  222.             /* DEC */
  223.             case 2:
  224.                 {
  225.                     printf("Digite o valor em OCT: ");
  226.  
  227.                     char valBase8[33]; /* precisão de 32 dígitos + EOS */
  228.                     setbuf(stdin, NULL);
  229.                     scanf("%s", valBase8);
  230.  
  231.                     /* convertendo para a base decimal */
  232.                     int valBase10 = 0;
  233.                     int expoent = 0;
  234.                     int i;
  235.                     for(i = strlen(valBase8) - 1; i >= 0; i--) {
  236.                         int digit = valBase8[i] - 48;
  237.                         int tmp = digit * pow(8, expoent);
  238.                         valBase10 = valBase10 + tmp;
  239.                         expoent = expoent + 1;
  240.                     }
  241.  
  242.                     printf("%d (DEC)\n", valBase10);
  243.                 }
  244.                 break;
  245.             /* HEX */
  246.             case 3:
  247.                 {
  248.                     printf("Digite o valor em OCT: ");
  249.  
  250.                     char valBase8[33]; /* precisão de 32 dígitos + EOS */
  251.                     setbuf(stdin, NULL);
  252.                     scanf("%s", valBase8);
  253.  
  254.                     /* convertendo para a base decimal */
  255.                     int valBase10 = 0;
  256.                     int expoent = 0;
  257.                     int i;
  258.                     for(i = strlen(valBase8) - 1; i >= 0; i--) {
  259.                         int digit = valBase8[i] - 48;
  260.                         int tmp = digit * pow(8, expoent);
  261.                         valBase10 = valBase10 + tmp;
  262.                         expoent = expoent + 1;
  263.                     }
  264.  
  265.                     /* convertendo de decimal para hexadecimal */
  266.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  267.                     int dividendo = valBase10;
  268.  
  269.                     int pos = 0;
  270.                     while(dividendo >= 16) {
  271.                         int r = dividendo % 16;
  272.                         if(r <= 9) {
  273.                             buffer[pos] = r + 48;
  274.                         }
  275.                         else if(r <= 15) {
  276.                             buffer[pos] = r + 55;
  277.                         }
  278.                         pos++;
  279.                         dividendo = dividendo / 16;
  280.                     }
  281.                     if(dividendo <= 9) {
  282.                         buffer[pos] = dividendo + 48;
  283.                     }
  284.                     else if(dividendo <= 15) {
  285.                         buffer[pos] = dividendo + 55;
  286.                     }
  287.                     pos++;
  288.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  289.  
  290.                     /* inverte o vetor */
  291.                     char valBase16[33];
  292.                     int j;
  293.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  294.                         valBase16[j] = buffer[i];
  295.                     }
  296.                     valBase16[j] = '\0';
  297.                     printf("%s (HEX)\n", valBase16);
  298.                 }
  299.                 break;
  300.             case 0:
  301.                 printf("Voltando...\n");
  302.                 break;
  303.             default:
  304.                 printf("Opcao invalida!\n");
  305.             }
  306.  
  307.             break;
  308.         /* DEC */
  309.         case 3:
  310.             printf("Escolha a base que o valor SERA CONVERTIDO:\n");
  311.             printf("1. Binario\n");
  312.             printf("2. Octal\n");
  313.             printf("3. Hexadecimal\n");
  314.             printf("0. Voltar\n");
  315.             setbuf(stdin, NULL);
  316.             scanf("%d", &submenu1);
  317.  
  318.             switch(submenu1){
  319.             /* BIN */
  320.             case 1:
  321.                 {
  322.                     printf("Digite o valor em DEC: ");
  323.  
  324.                     int valBase10;
  325.  
  326.                     setbuf(stdin, NULL);
  327.                     scanf("%d", &valBase10);
  328.  
  329.                     /* convertendo de decimal para binário */
  330.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  331.                     int dividendo = valBase10;
  332.  
  333.                     int pos = 0;
  334.                     while(dividendo >= 2) {
  335.                         int r = dividendo % 2;
  336.                         buffer[pos] = r + 48; /* ajusta o int de acordo com a tabela ASCII */
  337.                         pos++;
  338.                         dividendo = dividendo / 2;
  339.                     }
  340.                     buffer[pos] = dividendo + 48;
  341.                     pos++;
  342.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  343.  
  344.                     /* inverte o vetor */
  345.                     char valBase2[33];
  346.                     int i, j;
  347.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  348.                         valBase2[j] = buffer[i];
  349.                     }
  350.                     valBase2[j] = '\0';
  351.                     printf("%s (BIN)\n", valBase2);
  352.                 }
  353.                 break;
  354.             /* OCT */
  355.             case 2:
  356.                 {
  357.                     printf("Digite o valor em DEC: ");
  358.  
  359.                     int valBase10;
  360.  
  361.                     setbuf(stdin, NULL);
  362.                     scanf("%d", &valBase10);
  363.  
  364.                     /* convertendo de decimal para octal */
  365.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  366.                     int dividendo = valBase10;
  367.  
  368.                     int pos = 0;
  369.                     while(dividendo >= 8) {
  370.                         int r = dividendo % 8;
  371.                         buffer[pos] = r + 48; /* ajusta o int de acordo com a tabela ASCII */
  372.                         pos++;
  373.                         dividendo = dividendo / 8;
  374.                     }
  375.                     buffer[pos] = dividendo + 48;
  376.                     pos++;
  377.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  378.  
  379.                     /* inverte o vetor */
  380.                     char valBase8[33];
  381.                     int i, j;
  382.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  383.                         valBase8[j] = buffer[i];
  384.                     }
  385.                     valBase8[j] = '\0';
  386.                     printf("%s (OCT)\n", valBase8);
  387.                 }
  388.                 break;
  389.             /* HEX */
  390.             case 3:
  391.                 {
  392.                     printf("Digite o valor em DEC: ");
  393.  
  394.                     int valBase10;
  395.  
  396.                     setbuf(stdin, NULL);
  397.                     scanf("%d", &valBase10);
  398.  
  399.                     /* convertendo de decimal para hexadecimal */
  400.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  401.                     int dividendo = valBase10;
  402.  
  403.                     int pos = 0;
  404.                     while(dividendo >= 16) {
  405.                         int r = dividendo % 16;
  406.                         if(r <= 9) {
  407.                             buffer[pos] = r + 48;
  408.                         }
  409.                         else if(r <= 15) {
  410.                             buffer[pos] = r + 55;
  411.                         }
  412.                         pos++;
  413.                         dividendo = dividendo / 16;
  414.                     }
  415.                     buffer[pos] = dividendo + 48;
  416.                     pos++;
  417.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  418.  
  419.                     /* inverte o vetor */
  420.                     char valBase16[33];
  421.                     int i, j;
  422.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  423.                         valBase16[j] = buffer[i];
  424.                     }
  425.                     valBase16[j] = '\0';
  426.                     printf("%s (HEX)\n", valBase16);
  427.                 }
  428.                 break;
  429.             case 0:
  430.                 printf("Voltando...\n");
  431.                 break;
  432.             default:
  433.                 printf("Opcao invalida!\n");
  434.             }
  435.  
  436.             break;
  437.         /* HEX */
  438.         case 4:
  439.             printf("Escolha a base que o valor SERA CONVERTIDO:\n");
  440.             printf("1. Binario\n");
  441.             printf("2. Octal\n");
  442.             printf("3. Decimal\n");
  443.             printf("0. Voltar\n");
  444.             setbuf(stdin, NULL);
  445.             scanf("%d", &submenu1);
  446.  
  447.             switch(submenu1){
  448.             /* BIN */
  449.             case 1:
  450.                 {
  451.                     printf("Digite o valor em HEX: ");
  452.  
  453.                     char valBase16[33]; /* precisão de 32 dígitos + EOS */
  454.                     setbuf(stdin, NULL);
  455.                     scanf("%s", valBase16);
  456.  
  457.                     /* convertendo para a base decimal */
  458.                     int valBase10 = 0;
  459.                     int expoent = 0;
  460.                     int i;
  461.                     for(i = strlen(valBase16) - 1; i >= 0; i--) {
  462.                         int digit;
  463.                         if(valBase16[i] <= '9') {
  464.                             digit = valBase16[i] - 48;
  465.                         }
  466.                         else if(valBase16[i] >= 'A' && valBase16[i] < 'a') {
  467.                             digit = valBase16[i] - 55;
  468.                         }
  469.                         else {
  470.                             digit = valBase16[i] - 87;
  471.                         }
  472.                         int tmp = digit * pow(16, expoent);
  473.                         valBase10 = valBase10 + tmp;
  474.                         expoent = expoent + 1;
  475.                     }
  476.  
  477.                     /* convertendo de decimal para binário */
  478.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  479.                     int dividendo = valBase10;
  480.  
  481.                     int pos = 0;
  482.                     while(dividendo >= 2) {
  483.                         int r = dividendo % 2;
  484.                         buffer[pos] = r + 48; /* ajusta o int de acordo com a tabela ASCII */
  485.                         pos++;
  486.                         dividendo = dividendo / 2;
  487.                     }
  488.                     buffer[pos] = dividendo + 48;
  489.                     pos++;
  490.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  491.  
  492.                     /* inverte o vetor */
  493.                     char valBase2[33];
  494.                     int j;
  495.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  496.                         valBase2[j] = buffer[i];
  497.                     }
  498.                     valBase2[j] = '\0';
  499.                     printf("%s (BIN)\n", valBase2);
  500.                 }
  501.                 break;
  502.             /* OCT */
  503.             case 2:
  504.                 {
  505.                     printf("Digite o valor em HEX: ");
  506.  
  507.                     char valBase16[33]; /* precisão de 32 dígitos + EOS */
  508.                     setbuf(stdin, NULL);
  509.                     scanf("%s", valBase16);
  510.  
  511.                     /* convertendo para a base decimal */
  512.                     int valBase10 = 0;
  513.                     int expoent = 0;
  514.                     int i;
  515.                     for(i = strlen(valBase16) - 1; i >= 0; i--) {
  516.                         int digit;
  517.                         if(valBase16[i] <= '9') {
  518.                             digit = valBase16[i] - 48;
  519.                         }
  520.                         else if(valBase16[i] >= 'A' && valBase16[i] < 'a') {
  521.                             digit = valBase16[i] - 55;
  522.                         }
  523.                         else {
  524.                             digit = valBase16[i] - 87;
  525.                         }
  526.                         int tmp = digit * pow(16, expoent);
  527.                         valBase10 = valBase10 + tmp;
  528.                         expoent = expoent + 1;
  529.                     }
  530.  
  531.                     /* convertendo de decimal para octal */
  532.                     char buffer[33]; /* precisão de 32 dígitos + EOS */
  533.                     int dividendo = valBase10;
  534.  
  535.                     int pos = 0;
  536.                     while(dividendo >= 8) {
  537.                         int r = dividendo % 8;
  538.                         buffer[pos] = r + 48;
  539.                         pos++;
  540.                         dividendo = dividendo / 8;
  541.                     }
  542.                     buffer[pos] = dividendo + 48;
  543.                     pos++;
  544.                     buffer[pos] = '\0'; /* finaliza a string com o EOS (caracter terminador) */
  545.  
  546.                     /* inverte o vetor */
  547.                     char valBase8[33];
  548.                     int j;
  549.                     for(i = strlen(buffer) - 1, j = 0; i >= 0; i--, j++) {
  550.                         valBase8[j] = buffer[i];
  551.                     }
  552.                     valBase8[j] = '\0';
  553.                     printf("%s (OCT)\n", valBase8);
  554.                 }
  555.                 break;
  556.             /* DEC */
  557.             case 3:
  558.                 {
  559.                     printf("Digite o valor em HEX: ");
  560.  
  561.                     char valBase16[33]; /* precisão de 32 dígitos + EOS */
  562.                     setbuf(stdin, NULL);
  563.                     scanf("%s", valBase16);
  564.  
  565.                     /* convertendo para a base decimal */
  566.                     int valBase10 = 0;
  567.                     int expoent = 0;
  568.                     int i;
  569.                     for(i = strlen(valBase16) - 1; i >= 0; i--) {
  570.                         int digit;
  571.                         if(valBase16[i] <= '9') {
  572.                             digit = valBase16[i] - 48;
  573.                         }
  574.                         else if(valBase16[i] >= 'A' && valBase16[i] < 'a') {
  575.                             digit = valBase16[i] - 55;
  576.                         }
  577.                         else {
  578.                             digit = valBase16[i] - 87;
  579.                         }
  580.                         int tmp = digit * pow(16, expoent);
  581.                         valBase10 = valBase10 + tmp;
  582.                         expoent = expoent + 1;
  583.                     }
  584.  
  585.                     printf("%d (DEC)\n", valBase10);
  586.                 }
  587.                 break;
  588.             case 0:
  589.                 printf("Voltando...\n");
  590.                 break;
  591.             default:
  592.                 printf("Opcao invalida!\n");
  593.             }
  594.  
  595.             break;
  596.         case 0:
  597.             printf("Saindo do menu...\n");
  598.             break;
  599.         default:
  600.             printf("Opcao invalida!\n");
  601.         }
  602.     }while(menu1 != 0);
  603.     printf("Sistema encerrado.\n");
  604.     return 0;
  605. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top