API tools faq
paste
Advertisement
Mateus_Costa

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

Mateus_Costa
May 19th, 2019
225
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 22.10 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!