十六进制转八进制 C语言
 
问题描述
 　　给定n个十六进制正整数，输出它们对应的八进制数。
 
输入格式
 　　输入的第一行为一个正整数n （1<=n<=10）。
 　　接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
 
输出格式
 　　输出n行，每行为输入对应的八进制正整数。
 
【注意】
 　　输入的十六进制数不会有前导0，比如012A。
 　　输出的八进制数也不能有前导0。
 
样例输入
 　　2
 　　39
 　　123ABC
 
样例输出
 　　71
 　　4435274
 
【提示】
 　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。
 
这道题首先应该想到的是先将十六进制数转化成二进制数，然后再转化成八进制数。而且都得用字符类型，因为转化成二进制后肯定都超出int、long、long long 的数据范围，所以整型类型绝对是不能用的。
 
但笔者不得不说…实际操作出现的很多小问题我到现在确实都解决不了…T^T，我的头画都要离家出走了
 
于是，最后，笔者还是怂了，选择去看看其他大佬的代码，以下是链接：
 
https://blog.csdn.net/try_fei_ge/article/details/53239501
 
代码如下：
 
#include<stdio.h>

#include<string.h>
int main()
{
	int n,i,j,k,a,cur,ok,m,l;
	char s[10][100001],d16[16][5]={"0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"},out[140000]={},z[13]={};
	scanf("%d",&n);                      
	for(j=0;j<n;j++)
		scanf("%s",s[j]);
	for(j=0;j<n;j++)  
		{
			k=0;ok=1;m=0;                            /*初始化标记数据*/ 
			l=strlen(s[j]);                           /* 初始化标记数据*/ 
			a=3-l%3;                                   /*初始化标记数据*/   //求出要将这个十六进制数补足为3的倍数需要补上多少个0
			if(a==3)	ok=0;                    /*十六进制数长度刚好为3的倍数时转二进制不需补0，ok标记其是否为3的倍数0是1不是*/ 
			for(i=0;i<l;i++)                       /*逐位读取十六进制数进行转换*/ 
			{
				if(65<=s[j][i])                          
					s[j][i]-=7; //这里不理解请查阅ASCII代码表
				if(ok)                                     /*十六进制数位数不足转二进制时补0占位*/ 
					if(a==1){  //若需补一个十六进制的0，相当于补上四个二进制的0即0000，下面补两位也一样
						strcat(z,"0000");k=k+4;ok=0;
					}else if(a==2){
						strcat(z,"00000000");k=k+8;ok=0;
					}
				z[k++]=d16[s[j][i]-48][0];                  /*一位十六进制转四位二进制*/ 
				z[k++]=d16[s[j][i]-48][1];
				z[k++]=d16[s[j][i]-48][2];
				z[k++]=d16[s[j][i]-48][3];
				if(k==12)                                    /*每转三位十六进制数将其转为四位八进制数*/ 
				{
					for(cur=0;cur<12;m++)
						out[m]=((z[cur++]-48)*4+(z[cur++]-48)*2+(z[cur++]-48)*1)+48;
					z[0]='\0';k=0;                               /*z[0]='\0'初始化字符串结束符位置避免溢出*/ 
				}
			}                                      
			for(;k<3;k++)                                  /*输出时忽略前导0*/ 
				if(out[k]!=48)	break; //48是字符‘0’的ASCII值
			for(;k<m;k++)
				printf("%c",out[k]);
			putchar('\n');
		}
	return 0;
 } 
 
说实话，其实笔者看到现在，后面一小部分依然有一点蒙，虽然代码很短，但是需要的变量很多，所以笔者能理解这个代码的思路，但却写不出来…脑阔疼
 
另外，我看了其他博主的代码，比这个简单清晰一些，但笔者认为这段代码的思路可以借鉴学习一下。
 
代码中//是笔者添加的一些备注，希望对读者阅读代码能提供一些帮助。
 
同时，笔者在尝试时遇到一个问题，读者也可以注意一下：
 
笔者本来是用a[10][100000]来存放十六进制数，然后将它们转化成二进制就有申请了一个b[10][400000] (一个十六进制数等于四位二进制数) 来存放，然后系统就直接崩溃了！！ 为什么？因为申请的空间太多了，就这两个就要了整整5000000个空间！系统没有那么多空间给我这么挥霍呀！T^T
 
最后，这段时间刚好要春节了嘛，事情有点多，而且笔者也懈怠了几天，再加上这道题对单核大脑的我来说，实在是很困难，所以这几天才没有继续写博客。
 
总之，这道题笔者是放弃了，笔者的基础还是挺扎实的，但是做题的思路还有待改进加强，等回头有时间我再来怼怼它吧！

十六进制转十进制 C语言
 
问题描述
 　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
 　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
 
样例输入
 FFFF
 
样例输出
 65535
 
和上道题相反，这是一个十进制转十六进制的问题，笔者一开始觉得没什么难度，只要将上一题的思路反一下基本就出来了。
 
但现实又狠狠地打了我的脸！
 
先说我的错误代码吧。我的代码如下：
 
#include <stdio.h> 
#include <math.h>

int getnum(char a)
{
	switch(a) //进制转换
	{
		case '0':return 0;break;
		case '1':return 1;break;
		case '2':return 2;break;
		case '3':return 3;break;
		case '4':return 4;break;
		case '5':return 5;break;
		case '6':return 6;break;
		case '7':return 7;break;
		case '8':return 8;break;
		case '9':return 9;break;
		case 'A':return 10;break;
		case 'B':return 11;break;
		case 'C':return 12;break;
		case 'D':return 13;break;
		case 'E':return 14;break;
		case 'F':return 15;break;
	}
}

int main() {
	int i,count=0;
	int sum;
	char a[8]={'G','G','G','G','G','G','G','G'};//数组初始化
	for(i=0;a[i-1]!='\n'&&i<8;i++)//若上个数组空间不为回车，且i<8,则从键盘获取一个字符放进数组
	{
		a[i]=getchar();
	} 
	
	if(a[7]=='G'||a[7]=='\n')
	{
		i--;
	}
	
	for(i-=1;i>=0;i--) //对i-=1不太懂的可以自己画一个数组空间模拟一下，或者看我上一篇博客。
	{
		sum+=getnum(a[i])*pow(16,count++);
	}
	
	printf("%d",sum);
	return 0;
}
 
enmmm。笔者本来想将我的思路完完全全清晰的写出来，供读者参考，但修修改改了好久，发现自己怎么也将不清楚，所以，笔者决定只讲自己在思考的时候注意到的几个问题，读者根据这几个问题，应该就能比较容易的去理解笔者的代码。
 
1、申请的数组用于存放16进制数，其中就包括了“A~F”，所以笔者给数组赋初值‘G’，以方便后面的判断。 当然，赋初值的时候可以使用{}统一赋值，但是笔者用了{’G‘}却编译失败，具体原因不太清楚，可能是因为不需要符号’ '吧，但是笔者没有去尝试，所以就直接用了最笨的办法。
 
2、数组的长度是固定的（8个空间），而我们输入的十六进制数却可以是1~8位，这就表示部分空间可以是多余的，当长度不够8位时，getchar（）会将’\n’也放进数组，这就造成了当位数不满8位时，数组接收到的位数总是比实际位数多1，所以不断自增的i也就多1。，所以需要下面这段代码：
 
if(a[7]=='G'||a[7]=='\n')
	{
		i--;
	}
 
笔者以上这段代码是可以完成题目大半内容的，但还有一个问题，int的数据规模达不到要求，当输入“FFFFFFFF”时就会发生错误。
 
这就是笔者搞不懂的问题了，本来笔者认为只要把int改成long long类型，并把输出格式改成 %I64d 或 %lld 就可以了。
 
但实际操作之后，所有的输出都发生了错误，具体情况如下：
 
输入
改前输出
改后输出
实际输出的十六进制
0
0
64
40
F
15
79
4F
FF
255
319
13F
FFF
4095
4159
103F
FFFFFFFF
4294967347
10000003F
嗯，没错，我就改了一下数据类型，输出结果却天差地别，虽然最后这结果硬是被笔者找出了一些规律（如上图最后一列），但是笔者依然不知道问题在哪里，所以笔者纠结了一整晚后宣布投降，如果路过的大佬知道原因还望指点一二~~
 
最后，笔者只能看了一下其他博主的代码，代码如下（稍作改动后的）：
 
#include<stdio.h>
#include<string.h>
#include<math.h>
int main()
{
    char a[8];
    int i;
    
	scanf("%s",a);
    int l=strlen(a);//计算字符串长度
    long long ans=0;//注意是不超过8位的正的十六进制数字符串，因此数较大，应设为long long
    for(i=0; i<l; i++)
    {
        if(a[i]>='0'&&a[i]<='9')
            ans+=(a[i]-'0')*pow(16,l-1-i);//a[i]-'0'这个不懂的可以看一下ASCII代码表，保证茅塞顿开~~
        else
            ans+=(a[i]-'A'+10)*pow(16,l-1-i);
    }
    printf("%lld\n",ans);
    return 0;
}
 
附上该大佬的原文链接：https://blog.csdn.net/qq_30076791/article/details/50320793
 
同样的功能，这代码却很简洁，很精悍，笔者真的是佩服的五体投地，同时也发现：我输入的是字符，而题目要求的是字符串。
 
最后，如果有去运行一下上面这段代码的小伙伴就会发现，虽然笔者将数组空间改成8个，但在数据范围内，无论你输入多长的字符串，都能得到正确结果，看上去并没有出现溢出的情况，这是为什么呢？
 
其实当你放入超过数组空间的数据时，数组确实已经溢出了，但数据依然会被存入下一个内存空间，溢出的这部分内容依然可以被找到，比如下面这段代码：
 
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
	int a[8];
	int i;
	for(i=0;i<10;i++)
	{
		a[i]=i;
	 } 
	 printf("%d",a[9]);
	return 0;
}
 
运行之后结果一定是9，并不会出现编译错误。当然了，写代码是一个严肃的事情，虽然这样能通过编译，但如果是大型工程，这样写是肯定不行的，很容易导致程序崩溃，因为溢出的那部分空间并不是a数组的，也就是说这部分空间有可能会被改变。所以我们敲代码还是要严谨一些啦。

十六进制中有0x就代表是十六进制，没有0x就代表是十进制。

整型常量

1，八进制整常数

八进制整常数必须以0开头，即以0作为八进制数的前缀。数码取值为0～7。八进制数通常是无符号数。

以下各数是合法的八进制数：

015(十进制为13) 0101(十进制为65) 0177777(十进制为65535)

以下各数不是合法的八进制数：

256(无前缀0) 03A2(包含了非八进制数码) -0127(出现了负号)




2，十六进制整常数

十六进制整常数的前缀为0X或0x。其数码取值为0~9，A~F或a~f。

以下各数是合法的十六进制整常数：

0X2A(十进制为42) 0XA0 (十进制为160) 0XFFFF (十进制为65535)

以下各数不是合法的十六进制整常数：

5A (无前缀0X) 0X3H (含有非十六进制数码)



3，十进制整常数

十进制整常数没有前缀。其数码为0～9。

以下各数是合法的十进制整常数：

237 -568 65535 1627

以下各数不是合法的十进制整常数：

023 (不能有前导0) 23D (含有非十进制数码)
 
 

汇编语言：将ASCⅡ码表示的十进制数转换为二进制数/十六进制数
 
你们好！ 这是我的第一个汇编程序的博客，汇编是一个神奇的东西，你深入了解他之后会为他着迷的！！！
 
题目
 
将ASCⅡ表示的十进制数字转化为二进制数，例如，默认输入30H，30H，32H，35H，36H，那么程序的最后查看AX寄存器应该是0100。
 
分析
 
题目中的30h代表是的十进制0的ASCⅡ码，十进制的数字0-9对应的ASCⅡ码就是30h-39h。而30h，30h，32h，35h，36h，代表的正好是十进制的数字256，也就是28，对应着二进制的0000 0001 0000 0000 ，因为AX寄存器是十六位的，是用十六进制表示的，也就是0010。
 
转换原理
 
我们以五位十进制数字为例：
 1、首先是将五位ASCⅡ码转换为十进制的数字
 $$\sum _{i=0}^4{D}_i\ast 10=(((D_4\ast 10+D_3)\ast 10+D_2)\ast 10+D_1)\ast 10+D_0$$
 这就是ASCⅡ转换为十进制数字的公式,而计算机寄存器中的数字是用十六进制数字表示的，也就是这时候就已经转换为十六进制数字了。
 2、一定要注意，你要搞清楚什么时候使用ASCⅡ值，什么时候使用真值
 ASCⅡ：输入和输出时使用的均为ASCⅡ码值
 真值：计算的时候使用的为真值，真值就是用ASCⅡ值减去30
 
sub dl,30h;转换为真值
 
我们可以用这样的代码转换为真值，同样，使用add命令可以转化为ASCⅡ值。
 3、有的人想要把结果按二进制输出，这时候你可以选择循环来实现。我用的是逻辑循环左移，也就是每次都会将最高位循环移动到最低位，每次使用01h与结果与，将这一位输出就可以知道这一位是0还是1。输出的方法是使用21h号中断的02h，这个中断会输出dl寄存器中的ASCⅡ码对应的字符。
 
程序代码
 
csdn不支持汇编语言，无法高亮显示
 
	data segment;定义数据段
	org 3500h;数据段从3500h开始存储
	num	db 30h,30h,32h,35h,36h;num首地址为3500h
	data ends
	
	code segment;代码段
	assume cs:code,ds:data;声明代码段地址和数据段地址
	start:
		mov ax,data
		mov ds,ax;将数据存储到内存中
		
		mov cx,4h;循环4次
		mov bx,000ah
		
		mov ah,0;ah必须为0，对应mul指令
		mov si,3500h;可以使用offset num代替3500h
		mov al,[si];将si的数据交给al寄存器
		sub al,30h;获得asc码对应真值，使用真值运算
		mov dh,00h
		
	next1:
		mul bx;此处为ax*bx->dl_ax,所以ah必须为0，否则ah会影响
			  ;当需要转换的十进制数小于65536的时候，
			  ;数据全部存储于ax中
		inc si
		mov dl,[si];取下一位十进制数字
		sub dl,30h;转换为真值
		add ax,dx;dx+ax->ax，dh值已经置零
		loop next1;因为循环前已经处理过第一个数，所以cx为4
		
		mov cx,10h;此处是十六进制，cx循环10次
		mov bx,ax
		
	next2:
		rol bx,1;逻辑循环左移
		mov dl,bl
		and dl,01h;确定最低位为0还是1
		add dl,30h;将最低位转换为asc码输出
		mov ah,02h
		int 21h
		loop next2;共循环16次
		
		mov ah,4ch
		int 21h
	code ends
		end start
 
运行环境
 
使用的运行环境为DOSBOX0.74版本，这是我有史以来感觉最容易搞定的编译环境，编译环境的安装我就不在赘述了。
 
代码运行过程
 
1、首先建立**.asm文件
 2、汇编语言运行的代码过程需要masm进行汇编
 3、汇编无误之后要进行link链接
 4、链接无误会产生.exe文件，重点来了，你可以直接运行此可执行文件会输出0000 0001 0000 0000**，如果你想要查看ax寄存器，那么你需要在第二次循环之前查看。
 
查看ax值
 
-u指令进行反汇编，查看汇编代码对应的指令值
 
 -g27执行到第二次循环开始之前，可以查看此时的寄存器的值
 
 
代码运行细节
 
1、loop为直到型循环，所以需要循环几次，你的cx值就设为几。本代码第一次循环因为在进入循环之前已经处理过一次，所以只需要循环4次，即cx=4。第二次循环需要循环16次，因此cx=10h。
 2、有时候我们只需要使用低八位寄存器来获得数据，但是在运算过程中我们会涉及到高位的寄存器，很有可能会影响我们的运算结果。所以在某些细节上面需要把高位寄存器置0,就像本程序中某些情况下的ah和dh，细节很重要。