精华内容
下载资源
问答
  • C语言进制转换

    2021-04-14 15:16:57
    C语言进制转换各个进制转换C语言指数的使用 1.十进制整数转换为二进制整数 十进制整数转换为二进制整数采用"除2取余,逆序排列"法。具体做法是:用2去除十进制整数,可以得到一个商和余数;再用2去除商,又会得到一...

    1.十进制整数转换为二进制整数
    十进制整数转换为二进制整数采用"除2取余,逆序排列"法。具体做法是:用2去除十进制整数,可以得到一个商和余数;再用2去除商,又会得到一个商和余数,如此进行,直到商为零时为止,然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。

    例如把 (173)10 转换为二进制数。

    解:
    在这里插入图片描述

    2.十进制小数转换为二进制小数
    十进制小数转换成二进制小数采用"乘2取整,顺序排列"法。具体做法是:用2乘十进制小数,可以得到积,将积的整数部分取出,再用2乘余下的小数 部分,又得到一个积,再将积的整数部分取出,如此进行,直到积中的小数部分为零,或者达到所要求的精度为止。

    然后把取出的整数部分按顺序排列起来,先取的整数作为二进制小数的高位有效位,后取的整数作为低位有效位。

    例如把(0.8125)转换为二进制小数。

    解:
    在这里插入图片描述

    二进制小数转化成十进制
    二进制的小数转换为十进制主要是乘以2的负次方,从小数点后开始,依次乘以2的负一次方,2的负二次方,2的负三次方等
    (0.1101)2 = (0.8125)10
    1*1/2 + 1*1/4 + 0*1/8 + 1*1/16 = 0.8125

    各个进制转换

    在这里插入图片描述

    除数最后比被除数小,那个数就是第一位
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    C语言指数的使用

    #include <stdio.h>
    
    void main()
    
    {
    	double a=8.0e3,b=8.8e3;
    	double c=8.0e-3,d=8.8e-3;
    	printf("a=%lf,b=%lf\n",a,b);
    	printf("c=%lf,d=%lf\n",c,d);
    }
    

    在这里插入图片描述

    展开全文
  • 结构体 c语言 进制转换
  • c语言进制转换

    2013-03-09 10:59:52
    可以将十进制转换为任意进制,是一个非常实用的程序,可以作为开发辅助
  • C语言 进制转换

    2018-12-04 22:36:29
    因为我代码中二进制和十六进制可以通过十进制间接转换,所以实际上只要写 十进制 &amp;lt;-&amp;gt;二进制进制&amp;lt;-&amp;gt;十六进制进制 而十进制&amp;lt;-&amp;gt;十六...

    整个代码互转只有3个函数

    • ToHexNum

    • ToDecNum

    • ToBiNum
      因为我代码中二进制和十六进制可以通过十进制间接转换,所以实际上只要写

    • 十进制 <->二进制

    • 十进制<->十六进制进制
      而十进制<->十六进制,是由上面两个转换组合而来,即二进制<->十进制<->十六进制

    //如果你愿意的话,也可以用十进制<->二进制<->十六进制的顺序来编写

    先贴一下截图
    输入的时候,除了二进制外后缀都需要加上对应格式缩写
    十进制输入格式: xxxxd或者xxxxD
    十六进制格式: xxxxh或者xxxxH
    二进制格式: xxxxx (没有后缀)
    在这里插入图片描述

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<math.h>
    
    //the type of number
    #define HEX 1
    #define DEC 2
    #define BIN 3
    #define DEBUG 0
    typedef struct{
        void *base;
        void *top;
        int len;
    }stack;
    int num_dec=0;
    
    int ToHexNum(char *num,const int type,const int len)
    {
        if(type==2)//DEC to hex
        {
            stack *s=(stack *)malloc(sizeof(stack)); s->len=0;
            char *base_p=(char *)s->base;
            char *top_p=(char *)s->top;
    
            base_p=(char *)malloc(len*sizeof(char));
            top_p=base_p;  
            if(num_dec==0)
            {
                int i=0;
                int power=1;
                while(i<len)//char number to int number;
                {
                    num_dec+=power*(num[len-i-1]-48);
                    power*=10;
                    i++;
                }
            }
            while(num_dec!=0)
            {
                switch(num_dec%16)
                {
                    case 10:*top_p++='A';break;
                    case 11:*top_p++='B';break;
                    case 12:*top_p++='C';break;
                    case 13:*top_p++='D';break;
                    case 14:*top_p++='E';break;
                    case 15:*top_p++='F';break;
                    default:*top_p++=num_dec%16+'0';break;
                }
                num_dec/=16;
                s->len++;
            }
            printf("\tHex:[");
            --top_p;
            while(s->len>0)
            {
                printf("%c",*top_p--);
                s->len--;
            }
            printf("]\n");
            free(base_p);
            free(s);
    
    
        }
        if(type==3)//Bin to hex
        {
            num_dec=ToDecNum(num,type,len);
            ToHexNum(num,DEC,len);
        }
        return 1;
    }
    int ToDecNum(char *num,const int type,const int len)//done
    {
        int power=len;
        int result=0;
    
        #if DEBUG
        puts("\nTesting contents:");
        puts(num);
        printf("type=%d,len=%d",type,len);
        #endif
    
        if(type==1)//hex
        {
            power-=2;
            while(power>=0)
            {
                if(num[len-power-2]<=57)
                {
                    #if DEBUG
                    printf("\nnum[i]=%c,=%d,pow=%f,power=%d\n",num[len-power-2],num[len-power-2]-48,pow(16,power),power);
                    #endif
    
                    result+=(num[len-power-2]-48)*pow(16,power);
                }
                else if(num[len-power-2]<=90)
                {
                    #if DEBUG
                    printf("\nnum[i]=%c,=%d,pow=%f,power=%d\n",num[len-power-2],num[len-power-2]-55,pow(16,power),power);
                    #endif
    
                    result+=(num[len-power-2]-55)*pow(16,power);
                }
                else
                {
                    #if DEBUG
                    printf("\nnum[i]=%c,=%d,pow=%f,power=%d\n",num[len-power-2],num[len-power-2]-87,pow(16,power),power);
                    #endif
    
                    result+=(num[len-power-2]-87)*pow(16,power);
                }
                --power;
            }
        }
    
        if(type==3)//binary
        {
            power-=1;
            while(power>=0)
            {
                #if DEBUG
                printf("\nnum[i]=%c,=%d,pow=%f,power=%d\n",num[len-power-1],num[len-power-1]-47,pow(2,power),power);
                #endif
    
                result+=(num[len-power-1]-48)*pow(2,power);
                --power;
            }
        }
        printf("\tDec:[%d]\n",result);
        return result;
    }
    
    int ToBiNum(char *num,const int type,const int len)//working
    {
       
        if(type==1)//hex to bin
        {
            num_dec=ToDecNum(num,type,len);
            //printf("num_dec:%d\n",num_dec);
            ToBiNum(num,DEC,len);
        }
        if(type==2)//dec to bin
        {
            stack *s=(stack *)malloc(sizeof(stack)); s->len=0;
            int *base_p=(int *)s->base;
            int *top_p=(int *)s->top;
    
            base_p=(int *)malloc(4*len*sizeof(int));
            top_p=base_p;
    
            if(num_dec==0)
            {
                int i=0;
                int power=1;
                while(i<len)//char to int;
                {
                    if(num[len-i-1]<'0'||num[len-i-1]>'9')
                        continue;
    
                    num_dec+=power*(num[len-i-1]-48);
                    power*=10;
                    i++;
                }
            }
            while(num_dec!=0)
            {
                *top_p++=num_dec%2;
                num_dec/=2;
                s->len++;
            }
            printf("\tBin:[");
            --top_p;
            while(s->len>0)
            {
                printf("%d",*top_p--);
                s->len--;
            }
            printf("]\n");
            free(base_p);
            free(s);
        }
    
    
    
        return 1;
    }
    
    int NumConversion()
    {
        int len=1;
        char *num;
        while(len!=0)
        {
            num=(char *)malloc(20*sizeof(char));
            puts("[**Input]:");
            scanf("%s",num);
            len=strlen(num);
            if(num[len-1]=='D'||num[len-1]=='d')
            {//decimal input
                ToBiNum(num,DEC,len-1);
                ToHexNum(num,DEC,len-1);
            }
            else if(num[len-1]=='H'||num[len-1]=='h')
            {//hex input
                ToBiNum(num,HEX,len);
            }
            else
            {//binary input
                ToHexNum(num,BIN,len);
            }
            free(num);
            num=NULL;
        }
        if(num!=NULL)
        {
            free(num);
        }
    
        return 1;
    }
    int main()
    {
        NumConversion();
        return 1;
    }
    
    
    展开全文
  • C语言进制转换器源代码
  • C语言进制转换相关函数

    千次阅读 2019-06-12 21:28:16
    C语言进制转换相关函数 所需头文件 #include <stdio.h> #include <string> #include <string.h> #include <map> #include <iostream> using namespace std; 十进制转二进制 //十...

    C语言进制转换相关函数

    所需头文件

    #include <stdio.h>
    #include <string>
    #include <string.h>
    #include <map>
    #include <iostream>
    
    using namespace std;
    

    十进制转二进制

    //十进制转二进制 
    string Decimal_to_Binary(int decimal, int bits)// decimal为所要转换的十进制数,bits为输出位数 
    {
     char bin[bits+2];
     bin[0] = '0';
     bin[1] = 'b';
     
     
     int quotient = decimal; //商
     int remainder = 0; //余数
     
     int i;
     
     for(i=bits+2; i>2; i--)
     {
      remainder = quotient % 2;
      switch(remainder)
      {
       case 0:
        {
         bin[i-1] = '0';
         break;
        }
       case 1:
        {
         bin[i-1] = '1';
         break;
        }
       default:
        {
         break;
        }
      }
      quotient = quotient / 2;
     }
     return bin;
    }
    

    十进制转八进制

    //十进制转八进制 
    string Decimal_to_Octal(int decimal, int bits)// decimal为所要转换的十进制数,bits为输出位数
    {
     char octal[bits+1];
     octal[0] = '0';
     
     
     int quotient = decimal; //商
     int remainder = 0; //余数
     
     int i;
     
     for(i=bits+1; i>1; i--)
     {
      remainder = quotient % 8;
      switch(remainder)
      {
       case 0:
        {
         octal[i-1] = '0';
         break;
        }
       case 1:
        {
         octal[i-1] = '1';
         break;
        }
       case 2:
        {
         octal[i-1] = '2';
         break;
        }
       case 3:
        {
         octal[i-1] = '3';
         break;
        }
       case 4:
        {
         octal[i-1] = '4';
         break;
        }
       case 5:
        {
         octal[i-1] = '5';
         break;
        }
       case 6:
        {
         octal[i-1] = '6';
         break;
        }
       case 7:
        {
         octal[i-1] = '7';
         break;
        }
       default:
        {
         break;
        }
      }
      quotient = quotient / 8;
     }
     return octal;
    }
    

    十进制转十六进制

    //十进制转十六进制 
    string Decimal_to_Hexadecimal(int decimal, int bits)// decimal为所要转换的十进制数,bits为输出位数
    {
     char hexadecimal[bits+2];
     hexadecimal[0] = '0';
     hexadecimal[1] = 'x';
     
     
     int quotient = decimal; //商
     int remainder = 0; //余数
     
     int i;
     
     for(i=bits+2; i>2; i--)
     {
      remainder = quotient % 16;
      switch(remainder)
      {
       case 0:
        {
         hexadecimal[i-1] = '0';
         break;
        }
       case 1:
        {
         hexadecimal[i-1] = '1';
         break;
        }
       case 2:
        {
         hexadecimal[i-1] = '2';
         break;
        }
       case 3:
        {
         hexadecimal[i-1] = '3';
         break;
        }
       case 4:
        {
         hexadecimal[i-1] = '4';
         break;
        }
       case 5:
        {
         hexadecimal[i-1] = '5';
         break;
        }
       case 6:
        {
         hexadecimal[i-1] = '6';
         break;
        }
       case 7:
        {
         hexadecimal[i-1] = '7';
         break;
        }
       case 8:
        {
         hexadecimal[i-1] = '8';
         break;
        }
       case 9:
        {
         hexadecimal[i-1] = '9';
         break;
        }
       case 10:
        {
         hexadecimal[i-1] = 'a';
         break;
        }
       case 11:
        {
         hexadecimal[i-1] = 'b';
         break;
        }
       case 12:
        {
         hexadecimal[i-1] = 'c';
         break;
        }
       case 13:
        {
         hexadecimal[i-1] = 'd';
         break;
        }
       case 14:
        {
         hexadecimal[i-1] = 'e';
         break;
        }
       case 15:
        {
         hexadecimal[i-1] = 'f';
         break;
        }
       default:
        {
         break;
        }
      }
      quotient = quotient / 16;
     }
     return hexadecimal;
    }
    

    二进制转十进制

    //二进制转十进制 
    int Binary_to_Decimal(char Binary[])// decimal为所要转换的二进制数,输入时加上前缀“0b” 
    {
     int length = strlen(Binary);
     int i;
     int decimal = 0;
     for(int i=2; i<length; i++)
     {
      decimal = decimal * 2;
      switch(Binary[i])
      {
       case '0':
        {
         break;
        }
       case '1':
        {
         decimal = decimal + 1;
         break;
        }
       default:
        {
         break;
        }
      }
     }
     return decimal;
    }
    

    八进制转十进制

    //八进制转十进制 
    int Octal_to_Decimal(char Octal[])// decimal为所要转换的二进制数,输入时加上前缀“0” 
    {
     int length = strlen(Octal);
     int i;
     int decimal = 0;
     for(int i=1; i<length; i++)
     {
      decimal = decimal * 8;
      switch(Octal[i])
      {
       case '0':
        {
         break;
        }
       case '1':
        {
         decimal = decimal + 1;
         break;
        }
       case '2':
        {
         decimal = decimal + 2;
         break;
        }
       case '3':
        {
         decimal = decimal + 3;
         break;
        }
       case '4':
        {
         decimal = decimal + 4;
         break;
        }
       case '5':
        {
         decimal = decimal + 5;
         break;
        }
       case '6':
        {
         decimal = decimal + 6;
         break;
        }
       case '7':
        {
         decimal = decimal + 7;
         break;
        }
       default:
        {
         break;
        }
      }
     }
     return decimal;
    }
    

    十六进制转十进制

    //十六进制转十进制 
    int Hexadecimal_to_Decimal(char Hexadecimal[])// decimal为所要转换的二进制数,输入时加上前缀“0x” 
    {
     int length = strlen(Hexadecimal);
     int i;
     int decimal = 0;
     for(int i=2; i<length; i++)
     {
      decimal = decimal * 16;
      switch(Hexadecimal[i])
      {
       case '0':
        {
         break;
        }
       case '1':
        {
         decimal = decimal + 1;
         break;
        }
       case '2':
        {
         decimal = decimal + 2;
         break;
        }
       case '3':
        {
         decimal = decimal + 3;
         break;
        }
       case '4':
        {
         decimal = decimal + 4;
         break;
        }
       case '5':
        {
         decimal = decimal + 5;
         break;
        }
       case '6':
        {
         decimal = decimal + 6;
         break;
        }
       case '7':
        {
         decimal = decimal + 7;
         break;
        }
       case '8':
        {
         decimal = decimal + 8;
         break;
        }
       case '9':
        {
         decimal = decimal + 9;
         break;
        }
       case 'a':
        {
         decimal = decimal + 10;
         break;
        }
       case 'b':
        {
         decimal = decimal + 11;
         break;
        }
       case 'c':
        {
         decimal = decimal + 12;
         break;
        }
       case 'd':
        {
         decimal = decimal + 13;
         break;
        }
       case 'e':
        {
         decimal = decimal + 14;
         break;
        }
       case 'f':
        {
         decimal = decimal + 15;
         break;
        }
       default:
        {
         break;
        }
      }
     }
     return decimal;
    }
    
    展开全文
  • 本文给大家分享的是使用C语言实现进制转换的代码,十分的简单实用,有需要的小伙伴可以参考下。
  • C语言实现进制转换
  • 进制转换这一节的任务是讲解 计算机的进制转换 的知识。1. 前言1.1 进制的理解说到进制大家首先想到的肯定是十进制,因为十进制是我们从记事以来就慢慢接触的事物,那么大家有没有想过这样一个问题,十进制是怎么...

    ad88250a155fe21c9da2d4cbdafed886.png

    ​C语言零基础入门——5.进制转换

    这一节的任务是讲解 计算机的进制转换 的知识。

    1. 前言

    1.1 进制的理解

    • 说到进制大家首先想到的肯定是十进制,因为十进制是我们从记事以来就慢慢接触的事物,那么大家有没有想过这样一个问题,十进制是怎么产生的呢?十进制的原理是什么呢?为什么我们会把十进制理所当然的运用到世界中各个事物呢?
    • 说明白一点,十进制属于数学的定义。数学中定义了:从0到9的下一位就是10,也就是所谓的逢十进一
    • 十进制原理解释
      • 十进制定义的原始数据:0,1,2,3,4,5,6,7,8,9 (原始数据只有这十个,其他的数据都是根据这十个数进行演变出来的 ,比如:123 是由 1与2与3组成的)
      • 那么根据这是个原始数据 再加上 逢十进一 的特性就可以演变出我们所知道的任何数据了。

    2f04c9874087a9a16545a4fd0f295262.png
      • 当数据到9之后,由于在原始数据中并没有9之后的数据的定义了,因此使用逢十进一的特性就是:个位达到9之后再次从0开始,个位之前增加一位(即 十位),那么十位从几开始呢?当然是从1开始吖,因为个位给他进了一位啊。(我们可以假设刚开始的数据是 00,当个位到9的时候就是 09,个位达到了9因此向前进一位,并且自己从9循环回来到0,也就是10)
      • 至于什么成百上千,以致更多的数,都是这个原理了。

    是不是挺疑惑的,我讲十进制干嘛,自然是与其他进制进行联系啊,其实说白了,二进制,八进制,十六进制与十进制都有着相同的思想,只不过是 原始数据不同而已.


    1.2 二进制

    • 前边我们说了,在计算机中的存储使用的是二进制,既然有了二进制这一说,自然需要对二进制进行一系列的定了对吧。
    • 与十进制的十个原始数据对比之下,二进制只有两个原始数据 也就是我们之前总是提到的0 与1 两个数,自然也有与十进制的 逢十进一 相对应的 逢2进一
    • 具体的二进制进位如下图:

    5f60fad88fd9da4dbd755b860c112c55.png
    • 以此类推,这就是二进制。

    1.3 八进制

    • 不怎么用,但是稍微提一下,0-7是原始数据,逢八进一。

    1.4 十六进制

    • 这个进制比较有意思的是,它的原始数据有16个,但是如果我们用0-15作为原始数据的话,0-9之间只有一位数据,但是10-15之间占了两位,这样在占据的位数上就不统一,因此为了让他们统一,我们让10-15用英文单词A-F来替代。
    • 十六进制的原始数据:0,1,2,3,4,5,6,7,8,9,10,A,B,C,D,E,F十六个数,逢16进一
    • 具体的进位方式与十进制,二进制所说的类似。如下图:

    438830d2cc43623ea1c1593cd712817d.png

    1.5 进制收尾

    • 不要慌,只是进制的基础讲解先收尾,进制还有一个 进制之间的转换 我们在后边讲解。

    1.7 作业

    • 为了检验前边讲解的知识学的怎么样,我布置一个作业吧。
    • 小猿笔记 这四个字作为原始数据,用四进制的形式写出 12个 数据。

    关个注呗~

    小小猿笔记

    展开全文
  • 超级简单C语言进制转换代码 本人初学,不足,可指可点,有则改优则精进。 你好! 以下直接代码,仅供学习参考。 void to_base_n(int num1, int num2) { //定义一个数组储存转换后的没一位 int arr[100] = {0}; int ...
  • #include
  • C语言进制转换 十进制转换为任意进制

    千次阅读 多人点赞 2019-04-13 11:46:20
    C语言小白,上机题“将十进制整数转换为任意n进制整数(n<=16)并输出(用递归函数实现,16进制用大写A B C等代替)”的一种解法,欢迎讨论! #include<stdio.h> #include<string.h> int n,r,count; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,341
精华内容 1,736
关键字:

c语言进制转换

c语言 订阅