AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C语言数制互相转化

2011-07-13 602
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： #includestdio.h> #includestring.h> #includestdlib.h> void D_B(int); void D_O(int); void D_X(int); void B_D(int); void B_O(int); v...
  1. #includestdio.h>
  2. #includestring.h>
  3. #includestdlib.h>
  4. void D_B(int);
  5. void D_O(int);
  6. void D_X(int);
  7. void B_D(int);
  8. void B_O(int);
  9. void B_X(int);
  10. void O_B(int);
  11. void O_D(int);
  12. void O_X(int);
  13. void X_B(char r[],int k);
  14. void X_D(char r[],int k);
  15. void X_O(char r[],int k);
  16. void main()
  17. {
  18.  int i,j,k=0;
  19.  int q;
  20.  char r[10];
  21.  printf("+=============================================================+/n");
  22.  printf("| 欢 迎 使 用 进 制 转 换 程 序 |/n");
  23.  printf("+=============================================================+/n");
  24.  printf(" 注 ： 本 版 本 只 做 正 整 数 的 进 制 转 换 ！ ！");
  25.  do
  26.  {
  27.   q=0;
  28.   //fflush(stdin);
  29.   printf("/n请选择需要被转换的进制:/n0、退出/n1、二进制/n2、八进制/n3、十进制/n4、十六进制/n");
  30.   scanf("%d",&i);
  31.   switch (i)
  32.   {
  33.    case 1: printf("/n请选择转换后的进制:/n0、退出/n1、二进制/n2、八进制/n3、十进制/n4、十六进制/n");
  34.      scanf("%d",&j);
  35.      switch(j)
  36.      {
  37.      case 1: printf("/n同进制之间不用转化！/n");
  38.        q=1;
  39.        break;
  40.      case 2: printf("/n请输入您想要转化的数：");
  41.        scanf("%d",&k);
  42.        B_O(k);
  43.        q=1;
  44.        break;
  45.      case 3: printf("/n请输入您想要转化的数：");
  46.        scanf("%d",&k);
  47.        B_D(k);
  48.        q=1;
  49.        break;
  50.      case 4: printf("/n请输入您想要转化的数：");
  51.        scanf("%d",&k);
  52.        B_X(k);
  53.        q=1;
  54.        break;
  55.      case 0:
  56.       
  57.        printf("谢谢使用！！");
  58.        
  59.      }
  60.      break;
  61.    case 2: printf("/n请选择转换后的进制:/n0、退出/n1、二进制/n2、八进制/n3、十进制/n4、十六进制/n");
  62.      scanf("%d",&j);
  63.      switch(j)
  64.      {
  65.      case 2: printf("/n同进制之间不用转化！/n");
  66.         q=1;
  67.        break;
  68.      case 1: printf("/n请输入您想要转化的数：");
  69.        scanf("%d",&k);
  70.        O_B(k);
  71.        q=1;
  72.        break;
  73.      case 3: printf("/n请输入您想要转化的数：");
  74.        scanf("%d",&k);
  75.        O_D(k);
  76.        q=1;
  77.        break;
  78.      case 4: printf("/n请输入您想要转化的数：");
  79.        scanf("%d",&k);
  80.        O_X(k);
  81.        q=1;
  82.        break;
  83.      case 0:
  84.        printf("谢谢使用！！");
  85.      }
  86.      break;
  87.    case 3: printf("/n请选择转换后的进制:/n0、退出/n1、二进制/n2、八进制/n3、十进制/n4、十六进制/n");
  88.      scanf("%d",&j);
  89.      switch(j)
  90.      {
  91.      case 3: printf("/n同进制之间不用转化！/n");
  92.         q=1;
  93.       
  94.        break;
  95.      case 1: printf("/n请输入您想要转化的数：");
  96.        scanf("%d",&k);
  97.        D_B(k);
  98.        q=1;
  99.        break;
  100.      case 2: printf("/n请输入您想要转化的数：");
  101.        scanf("%d",&k);
  102.        D_O(k);
  103.        q=1;
  104.        break;
  105.      case 4: printf("/n请输入您想要转化的数：");
  106.        scanf("%d",&k);
  107.        D_X(k);
  108.        q=1;
  109.        break;
  110.      case 0:
  111.       
  112.        printf("谢谢使用！！");
  113.      }
  114.      break;
  115.    case 4: printf("/n请选择转换后的进制:/n0、退出/n1、二进制/n2、八进制/n3、十进制/n4、十六进制/n");
  116.      scanf("%d",&j);
  117.      switch(j)
  118.      {
  119.      case 4: printf("/n同进制之间不用转化！/n");
  120.         q=1;
  121.        break;
  122.      case 1: printf("/n请输入您想要转化的数:");
  123.         fflush(stdin);
  124.         gets(r);
  125.         for(k=0;;k++)
  126.         {
  127.          if(r[k]=='/0')
  128.          break;
  129.         }
  130.        
  131.        X_B(r,k);
  132.        q=1;
  133.        break;
  134.      case 2: printf("/n请输入您想要转化的数:");
  135.        fflush(stdin);
  136.         gets(r);
  137.         for(k=0;;k++)
  138.         {
  139.          if(r[k]=='/0')
  140.          break;
  141.         }
  142.        
  143.        X_O(r,k);
  144.        q=1;
  145.        break;
  146.      case 3: printf("/n请输入您想要转化的数:");
  147.        fflush(stdin);
  148.         gets(r);
  149.         for(k=0;;k++)
  150.         {
  151.          if(r[k]=='/0')
  152.          break;
  153.         }
  154.        X_D(r,k);
  155.        q=1;
  156.        break;
  157.      case 0:
  158.       printf("谢谢使用！！");
  159.        
  160.      }
  161.      break;
  162.    case 0: printf("/n谢谢使用！/n");
  163.     
  164.   }
  165.  }while(q==1);
  166. }
  167.  ///////以下为: 二进制转换为十进制,八进制,十六进制.
  168. void B_D(int a)
  169. {
  170.  int i,s=0;
  171.  int result=0;
  172.  for(i=1;a!=0;i*=2)
  173.  {
  174.   if(a%10>1)
  175.   {
  176.    s=1;
  177.    break;
  178.   }
  179.   else
  180.   {
  181.    result+=(a%10)*i;
  182.    a=a/10;
  183.   }
  184.  }
  185.  if(s==1)
  186.   printf("您的输入有误！请重新输入/n");
  187.  else
  188.  printf("/n转换后的数为：%d/n",result);
  189. }

  191. void B_O(int a)
  192. {
  193.  int i,j,k,s=0;
  194.  int p[30];
  195.  int result=0;
  196.  for(i=1;a!=0;i*=2)
  197.  {
  198.   if(a%10>1)
  199.   {
  200.    s=1;
  201.    break;
  202.   }
  203.   else
  204.   {
  205.    result+=(a%10)*i;
  206.    a=a/10;
  207.   }
  208.  }
  209.  for(j=0;result!=0;j++)
  210.  {
  211.   p[j]=result%8;
  212.   result=result/8;
  213.  }
  214.  if(s==1)
  215.   printf("您的输入有误！请重新输入/n");
  216.  else
  217.  {
  218.   printf("/n转换后的数为：");
  219.   for(k=j-1;k>=0;k--)
  220.   {
  221.    printf("%d",p[k]);
  222.   }
  223.   printf("/n");
  224.  }
  225. }


  228. void B_X(int a)
  229. {
  230.  int i,j,k,s=0;
  231.  char p[30];
  232.  int result=0;
  233.  for(i=1;a!=0;i*=2)
  234.  {
  235.   if(a%10>1)
  236.   {
  237.    s=1;
  238.    break;
  239.   }
  240.   else
  241.   {
  242.    result+=(a%10)*i;
  243.    a=a/10;
  244.   }
  245.  }
  246.  for(j=0;result!=0;j++)
  247.  {
  248.   p[j]=result%16;
  249.   result=result/16;
  250.   if (p[j]>10)
  251.   {
  252.    switch(p[j])
  253.    {
  254.    case 10: p[j]='A';
  255.       break;
  256.    case 11: p[j]='B';
  257.       break;
  258.    case 12: p[j]='C';
  259.       break;
  260.    case 13: p[j]='D';
  261.       break;
  262.    case 14: p[j]='E';
  263.       break;
  264.    case 15: p[j]='F';
  265.       break;
  266.    }
  267.   }
  268.   else p[j]+=48;
  269.  }
  270.  if(s==1)
  271.   printf("您的输入有误！请重新输入/n");
  272.  else
  273.  {
  274.   printf("/n转换后的数为：");
  275.   for(k=j-1;k>=0;k--)
  276.   {
  277.    printf("%c",p[k]);
  278.   }
  279.   printf("/n");
  280.  }
  281. }
  282.  ///////以下为: 八进制转换为二进制,十进制,十六进制.
  283. void O_B(int a)
  284. {
  285.  int i,j,k,s=0;
  286.  int result=0;
  287.  int p[30];
  288.  for(i=1;a!=0;i*=8)
  289.  {if(a%10>7)
  290.   {
  291.    s=1;
  292.    break;
  293.   }
  294.   else
  295.   {
  296.    result+=(a%10)*i;
  297.    a=a/10;
  298.   }
  299.  }
  300.  for(j=0;result!=0;j++)
  301.  {
  302.   p[j]=result%2;
  303.   result=result/2;
  304.  }
  305.  if(s==1)
  306.   printf("您的输入有误！请重新输入/n");
  307.  else
  308.  {
  309.   printf("/n转换后的数为：");
  310.   for(k=j-1;k>=0;k--)
  311.   {
  312.    printf("%d",p[k]);
  313.   }
  314.   printf("/n");
  315.  }
  316. }

  318. void O_D(int a)
  319. {
  320.  int i,s=0;
  321.  int result=0;
  322.  for(i=1;a!=0;i*=8)
  323.  {
  324.   if(a%10>7)
  325.   {
  326.    s=1;
  327.    break;
  328.   }
  329.   else
  330.   {
  331.    result+=(a%10)*i;
  332.    a=a/10;
  333.   }
  334.  }
  335.  if(s==1)
  336.   printf("您的输入有误！请重新输入/n");
  337.  else
  338.  {
  339.   printf("/n转换后的数为：%d/n",result);
  340.  }
  341. }

  343. void O_X(int a)
  344. {
  345.  int i,j,k,s=0;
  346.  char p[30];
  347.  int result=0;
  348.  for(i=1;a!=0;i*=8)
  349.  {
  350.   if(a%10>7)
  351.   {
  352.    s=1;
  353.    break;
  354.   }
  355.   else
  356.   {
  357.    result+=(a%10)*i;
  358.    a=a/10;
  359.   }
  360.  }
  361.  for(j=0;result!=0;j++)
  362.  {
  363.   p[j]=result%16;
  364.   result=result/16;
  365.   if(p[j]10)
  366.    p[j]+=48;
  367.   else
  368.   {
  369.    switch(p[j])
  370.    {
  371.    case 10: p[j]='A';
  372.       break;
  373.    case 11: p[j]='B';
  374.       break;
  375.    case 12: p[j]='C';
  376.       break;
  377.    case 13: p[j]='D';
  378.       break;
  379.    case 14: p[j]='E';
  380.       break;
  381.    case 15: p[j]='F';
  382.       break;
  383.    }
  384.   }
  385.  }
  386.  if(s==1)
  387.   printf("您的输入有误！请重新输入/n");
  388.  else
  389.  {
  390.   printf("/n转换后的数为：");
  391.   for(k=j-1;k>=0;k--)
  392.   {
  393.    printf("%c",p[k]);
  394.   }
  395.   printf("/n");
  396.  }
  397. }
  398.  ///////以下为: 十六进制转换为十进制,二进制,八进制.
  399. void X_D(char a[],int k)
  400. {
  401.  int i,j,s=0;
  402.  int result=0;
  403.  int b[50];
  404.  for(i=0;ik;i++)
  405.  {
  406.   if(a[i]='9'&&a[i]>='1')
  407.   { b[i]=a[i]-48;
  408.      
  409.   }
  410.   else
  411.   {
  412.    switch(a[i])
  413.    {
  414.    case 'A': b[i]=10;
  415.       break;
  416.    case 'B': b[i]=11;
  417.       break;
  418.    case 'C': b[i]=12;
  419.       break;
  420.    case 'D': b[i]=13;
  421.       break;
  422.    case 'E': b[i]=14;
  423.       break;
  424.    case 'F': b[i]=15;
  425.       break;
  426.    case 'a': b[i]=10;
  427.       break;
  428.    case 'b': b[i]=11;
  429.       break;
  430.    case 'c': b[i]=12;
  431.       break;
  432.    case 'd': b[i]=13;
  433.       break;
  434.    case 'e': b[i]=14;
  435.       break;
  436.    case 'f': b[i]=15;
  437.       break;
  438.    default: s=1;
  439.       
  440.    }
  441.    
  442.   }
  443.  }
  444.  for(i=1,j=k-1;j>=0;j--,i*=16)
  445.  {
  446.   result+=b[j]*i;
  447.  }
  448.  if(s==1)
  449.   printf("您的输入有误！请重新输入/n");
  450.  else
  451.  {
  452.   printf("/n转换后的数为：%d",result);
  453.  }
  454. }


  457. void X_B(char a[],int k)
  458. {
  459.  int i,j,s=0;
  460.  int result=0;
  461.  int b[50];
  462.  int p[30];
  463.  for(i=0;ik;i++)
  464.  {
  465.   if(a[i]='9'&&a[i]>='1')
  466.    b[i]=a[i]-48;
  467.   else
  468.   {
  469.    switch(a[i])
  470.    {
  471.    case 'A': b[i]=10;
  472.       break;
  473.    case 'B': b[i]=11;
  474.       break;
  475.    case 'C': b[i]=12;
  476.       break;
  477.    case 'D': b[i]=13;
  478.       break;
  479.    case 'E': b[i]=14;
  480.       break;
  481.    case 'F': b[i]=15;
  482.       break;
  483.    case 'a': b[i]=10;
  484.       break;
  485.    case 'b': b[i]=11;
  486.       break;
  487.    case 'c': b[i]=12;
  488.       break;
  489.    case 'd': b[i]=13;
  490.       break;
  491.    case 'e': b[i]=14;
  492.       break;
  493.    case 'f': b[i]=15;
  494.       break;
  495.    default: s=1;
  496.       
  497.    }
  498.   }
  499.  }
  500.  for(j=k-1,i=1;j>=0;j--,i*=16)
  501.  {
  502.   result+=b[j]*i;
  503.  }
  504.   for(j=0;result!=0;j++)
  505.  {
  506.   p[j]=result%2;
  507.   result=result/2;
  508.  }
  509.  if(s==1)
  510.   printf("您的输入有误！请重新输入/n");
  511.  else
  512.  {
  513.   printf("/n转换后的数为：");
  514.   for(k=j-1;k>=0;k--)
  515.   {
  516.    printf("%d",p[k]);
  517.   }
  518.   printf("/n");
  519.  }
  520. }

  522. void X_O(char a[],int k)
  523. {
  524.  int i,j,s=0;
  525.  int result=0;
  526.  int b[30];
  527.  int p[30];
  528.  for(i=0;ik;i++)
  529.  {
  530.   if(a[i]='9'&&a[i]>='1')
  531.    b[i]=a[i]-48;
  532.   else
  533.   {
  534.    switch(a[i])
  535.    {
  536.    case 'A': b[i]=10;
  537.       break;
  538.    case 'B': b[i]=11;
  539.       break;
  540.    case 'C': b[i]=12;
  541.       break;
  542.    case 'D': b[i]=13;
  543.       break;
  544.    case 'E': b[i]=14;
  545.       break;
  546.    case 'F': b[i]=15;
  547.       break;
  548.    case 'a': b[i]=10;
  549.       break;
  550.    case 'b': b[i]=11;
  551.       break;
  552.    case 'c': b[i]=12;
  553.       break;
  554.    case 'd': b[i]=13;
  555.       break;
  556.    case 'e': b[i]=14;
  557.       break;
  558.    case 'f': b[i]=15;
  559.       break;
  560.    default: s=1;
  561.    }
  562.   }
  563.  }
  564.  for(j=k-1,i=1;j>=0;j--,i*=16)
  565.  {
  566.   result+=b[j]*i;
  567.  }
  568.   for(j=0;result!=0;j++)
  569.  {
  570.   p[j]=result%8;
  571.   result=result/8;
  572.  }
  573.  if(s==1)
  574.   printf("您的输入有误！请重新输入/n");
  575.  else
  576.  {
  577.   printf("/n转换后的数为：");
  578.   for(k=j-1;k>=0;k--)
  579.   {
  580.    printf("%d",p[k]);
  581.   }
  582.   printf("/n");
  583.  }
  584. }
  585. ///////以下为: 十进制转换为二进制,八进制,十六进制.
  586. void D_B(int a)
  587. {
  588.  int j,k;
  589.  int p[30];
  590.  for(j=0;a!=0;j++)
  591.  {
  592.   p[j]=a%2;
  593.   a=a/2;
  594.  }
  595.  printf("/n转换后的数为：");
  596.  for(k=j-1;k>=0;k--)
  597.  {
  598.   printf("%d",p[k]);
  599.  }
  600.  printf("/n");
  601. }

  603. void D_O(int a)
  604. {
  605.  int j,k;
  606.  int p[30];
  607.  for(j=0;a!=0;j++)
  608.  {
  609.   p[j]=a%8;
  610.   a=a/8;
  611.  }
  612.  printf("/n转换后的数为：");
  613.  for(k=j-1;k>=0;k--)
  614.  {
  615.   printf("%d",p[k]);
  616.  }
  617.  printf("/n");
  618. }

  620. void D_X(int a)
  621. {
  622.  int j,k;
  623.  int p[30];
  624.  for(j=0;a!=0;j++)
  625.  {
  626.   p[j]=a%16;
  627.   a=a/16;
  628.   if(p[j]10)
  629.    p[j]+=48;
  630.   else
  631.   {
  632.    switch(p[j])
  633.    {
  634.    case 10: p[j]='A';
  635.       break;
  636.    case 11: p[j]='B';
  637.       break;
  638.    case 12: p[j]='C';
  639.       break;
  640.    case 13: p[j]='D';
  641.       break;
  642.    case 14: p[j]='E';
  643.       break;
  644.    case 15: p[j]='F';
  645.       break;
  646.    }
  647.   }
  648.  }
  649.  printf("/n转换后的数为：");
  650.  for(k=j-1;k>=0;k--)
  651.  {
  652.   printf("%c",p[k]);
  653.  }
  654.  printf("/n");
  655. }
文章标签：
BI
人工智能
C语言
JavaScript
关键词：
C语言数制
长空翱翔
目录
相关文章
小徐在进步
|
3月前
|
存储 算法 C语言
C语言程序设计核心详解 第一章:数制及转换与ASCII码
本专栏旨在夯实C语言基础，涵盖基础知识与进阶内容，助力解决自命题考试和考研问题，为数据结构与算法设计奠定坚实基础。内容包括数制及其转换、ASCII码、内存管理、机器码等，重点讲解二进制、八进制、十六进制的概念与转换方法，并介绍C语言的结构、数据类型和标识符规范。
小徐在进步
64 5
白子寰
|
2月前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
白子寰
38 3
LuckiBit
|
15天前
|
存储 C语言 开发者
【C语言】字符串操作函数详解
这些字符串操作函数在C语言中提供了强大的功能，帮助开发者有效地处理字符串数据。通过对每个函数的详细讲解、示例代码和表格说明，可以更好地理解如何使用这些函数进行各种字符串操作。如果在实际编程中遇到特定的字符串处理需求，可以参考这些函数和示例，灵活运用。
LuckiBit
37 10
LuckiBit
|
15天前
|
存储 程序员 C语言
【C语言】文件操作函数详解
C语言提供了一组标准库函数来处理文件操作，这些函数定义在 `<stdio.h>` 头文件中。文件操作包括文件的打开、读写、关闭以及文件属性的查询等。以下是常用文件操作函数的详细讲解，包括函数原型、参数说明、返回值说明、示例代码和表格汇总。
LuckiBit
37 9
LuckiBit
|
15天前
|
存储 Unix Serverless
【C语言】常用函数汇总表
本文总结了C语言中常用的函数，涵盖输入/输出、字符串操作、内存管理、数学运算、时间处理、文件操作及布尔类型等多个方面。每类函数均以表格形式列出其功能和使用示例，便于快速查阅和学习。通过综合示例代码，展示了这些函数的实际应用，帮助读者更好地理解和掌握C语言的基本功能和标准库函数的使用方法。感谢阅读，希望对你有所帮助！
LuckiBit
30 8
LuckiBit
|
15天前
|
C语言 开发者
【C语言】数学函数详解
在C语言中，数学函数是由标准库 `math.h` 提供的。使用这些函数时，需要包含 `#include <math.h>` 头文件。以下是一些常用的数学函数的详细讲解，包括函数原型、参数说明、返回值说明以及示例代码和表格汇总。
LuckiBit
39 6
LuckiBit
|
15天前
|
存储 C语言
【C语言】输入/输出函数详解
在C语言中，输入/输出操作是通过标准库函数来实现的。这些函数分为两类：标准输入输出函数和文件输入输出函数。
LuckiBit
91 6
LuckiBit
|
15天前
|
存储 缓存 算法
【C语言】内存管理函数详细讲解
在C语言编程中，内存管理是至关重要的。动态内存分配函数允许程序在运行时请求和释放内存，这对于处理不确定大小的数据结构至关重要。以下是C语言内存管理函数的详细讲解，包括每个函数的功能、标准格式、示例代码、代码解释及其输出。
LuckiBit
47 6
LuckiBit
|
15天前
|
C语言 开发者
【C语言】断言函数 -《深入解析C语言调试利器 ！》
断言（assert）是一种调试工具，用于在程序运行时检查某些条件是否成立。如果条件不成立，断言会触发错误，并通常会终止程序的执行。断言有助于在开发和测试阶段捕捉逻辑错误。
LuckiBit
24 5
XIAZHI
|
26天前
|
存储 人工智能 算法
数据结构实验之C 语言的函数数组指针结构体知识
本实验旨在复习C语言中的函数、数组、指针、结构体与共用体等核心概念，并通过具体编程任务加深理解。任务包括输出100以内所有素数、逆序排列一维数组、查找二维数组中的鞍点、利用指针输出二维数组元素，以及使用结构体和共用体处理教师与学生信息。每个任务不仅强化了基本语法的应用，还涉及到了算法逻辑的设计与优化。实验结果显示，学生能够有效掌握并运用这些知识完成指定任务。
XIAZHI
49 4