十进制转换十六进制c语言递归（求c语言将十进制数转换为16进制的函数）

本文目录

• 求c语言将十进制数转换为16进制的函数
• c语言编程 把十进制转换为十六进制
• c语言 十进制转换为十六进制
• c语言十进制转化为十六进制
• c 十进制转十六进制 数据
• 在c语言中用最简单的方法把十进制转化为十六进制
• 用c++编写递归将十进制转换为十六进制
• 怎么写一个c++程序，要求用递归函数将十进制数转化成十六进制数
• C++ 用递归函数 将 十进制数n转换为十六进制数，要能正确输出

求c语言将十进制数转换为16进制的函数

c语言将十进制数转换为16进制的函数：

#include《stdio.h》
main()
{
int u10;
char u16;
int w=0,a,b,i;
printf("请输入一个数字--》");
scanf("%d",&u10);
if(u10==0)
{
u16=’0’;
w++;
}
else
{
a=u10;
while(a)
{
b=a%16;
if(b《10)
{
u16=’0’+b;
}
else
{
u16=’A’+b-10;
}
a=a/16;
w++;
}
}
printf("\n");
printf("%d(10)转换为16进制数字为：",u10);
for(i=w-1;i》=0;i--)
{
printf("%c",u16);
}
printf("\n");
}

扩展资料：

十进制数转换为二进制数方法

十进制数转换为二进制数时，由于整数和小数的转换方法不同，所以先将十进制数的整数部分和小数部分分别转换后，再加以合并。

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

2．十进制小数转换为二进制小数

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

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

百度百科-十进制

c语言编程 把十进制转换为十六进制

方法一：
#include《iostream》
#include 《string》
using namespace std;

string DecIntToHexStr(long long num)
{string str;long long Temp = num / 16;int left = num % 16;if (Temp 》 0)str += 

DecIntToHexStr(Temp);if (left 《 10)str += (left + ’0’);elsestr += (’A’ + left - 10);return str;}
string DecStrToHexStr(string str){long long Dec = 0;for (int i = 0; i 《 str.size(); ++i)Dec = 

Dec * 10 + str - ’0’;return DecIntToHexStr(Dec);}int main()
{string DecStr;while (cin 》》 DecStr){cout 《《 "0x" + DecStrToHexStr(DecStr);}return 0;}

方法二：

#include《iostream》
#include 《string》
#include《vector》

#include 《sstream》
#include 《math.h》
using namespace std;int main()

{string decStr;cin 》》 decStr;int num = stoi(decStr);vector《int》v;while (num){int bit = num % 2;v.push_back(bit);num = num / 2;}

reverse(v.begin(), v.end());string hexStr;if (v.size() % 4 == 0){for (int i = 0; i 《 v.size() / 4; ++i){int temp = 0, k = 3;for (int j = i * 4; j 《 (i + 

1) * 4; ++j){if (v == 1)temp += pow(2, k);--k;}   if (temp 《= 9)hexStr += temp;elsehexStr += (’A’ + temp - 10);}}

else{int zeroNum = 4 - v.size() % 4;for (int i = 0; i 《 zeroNum; ++i)v.insert(v.begin(), 0);for (int i = 0; i 《 v.size() / 4; ++i){int temp = 0, k = 3;for 

(int j = i * 4; j 《 (i + 1) * 4; ++j){if (v == 1)temp += pow(2, k);--k;}
if (temp 《= 9){stringstream ss;string strTemp;

ss 《《 temp;ss 》》 strTemp;hexStr += strTemp;}elsehexStr += (’A’ + temp - 10);}}cout 《《 hexStr 《《 endl;return 0;}

扩展资料：

还有3种方式可以实现，其中两种是使用系统函数，另一种是直接自己编写。

下面的代码就是3种方式的实现，包括2位的整数和任意整数（2的31次方以内）都可以。可自己选择需要的实现方式。

利用系统函数有

1. char *  itoa ( int value, char * str, int base );value是要转化的数字，str是转化后的字符串存储的位置，base是进制数（但是这个函数不是标准C函数，有些编译器是不支持的！）。所以代码可以为：

char buffer ; //用于存放转换好的十六进制字符串，可根据需要定义长度 char * inttohex(int aa){    itoa (aa, buffer, 16);    return (buffer);} 

2. sprintf(str,"%x",value);str是转化存储的位置，%x表示十六进制格式，value是要转化的数字。所以代码可以为：

char buffer ; //用于存放转换好的十六进制字符串，可根据需要定义长度 char * inttohex(int aa){    sprintf(buffer, "%x", aa);    return (buffer);}

3. 自己编写

如果参数只要两位数的整数，那么很简单。

代码如下：

#include 《stdio.h》#include 《stdlib.h》 char buffer ; //用于存放转换好的十六进制字符串，可根据需要定义长度 char * inttohex(int aa)

{    sprintf(buffer, "%x", aa);    return (buffer);} int main ()                

{  int num;  char * hex_str;  printf ("Enter a number: ");  scanf ("%d",&num);  hex_str = inttohex (num);  printf ("Hexadecimal number: %sH\n", hex_str);  return 0;}

c语言 十进制转换为十六进制

在C语言中，可以使用`printf()`函数的格式控制符将十进制数转换为十六进制。具体来说，可以使用 `%x` 格式控制符。例如：
```c
int decimal_number = 255;
printf("%x", decimal_number);
```
上述代码将十进制数255转换为十六进制形式，并输出结果ff。
需要注意的是，在使用 `%x` 格式控制符时，输出的十六进制数字母会自动转换为小写形式。如果需要输出大写形式的字母，可以使用 `%X` 格式控制符。

c语言十进制转化为十六进制

十进制转化为十六进制代码：

#include "stdio.h" int main() 

{ 

int num=0;

int a; 

int i=0; 

int m=0;

int yushu; 

char hex={’0’,’1’,’2’,’3’,’4’,’5’,’6’,’7’,’8’,’9’,’A’,’B’,’C’,’D’,’E’,’F’};

printf("请输入一个十进制数：");

scanf("%d",&num); while(num》0) { yushu=num%16;

a=yushu; 

num=num/16;

} printf("转化为十六进制的数为：0x"); for(i=i-1;i》=0;i--)//倒序输出 {m=a;

printf("%c",hex); } printf("\n"); 

}

程序运行结果：

扩展资料：

进制转换由一组数码符号和两个基本因素“基数”与“位权”构成。基数是指，进位计数制中所采用的数码（数制中用来表示“量”的符号）的个数。位权是指，进位制中每一固定位置对应的单位值。

举例：二进制数转换为十进制数

二进制数第0位的权值是2的0次方，第1位的权值是2的1次方……

所以，设有一个二进制数：0110 0100，转换为10进制为：

下面是竖式：

0110 0100 换算成十进制

第0位 0 * 20 = 0

第1位 0 * 21 = 0

第2位 1 * 22 = 4

第3位 0 * 23 = 0

第4位 0 * 24 = 0

第5位 1 * 25 = 32

第6位 1 * 26 = 64

第7位 0 * 27 = 0

公式：第N位2(N)

---------------------------

100

用横式计算为：

0 * 20 + 0 * 21 + 1 * 22 + 0 * 23 + 0 * 24 + 1 * 25 + 1* 26 + 0 * 27 = 100

0乘以多少都是0，所以我们也可以直接跳过值为0的位：

1 * 22 + 1 * 25 +1*26 = 100

参考资料：

百度百科-进制转换

c 十进制转十六进制 数据

有3种方式实现，其中两种是使用系统函数，另一种是直接自己编写。
使用系统函数实现要加入#include 《stdlib.h》，自己编写则不需要这个头文件。
下面的代码就是3种方式的实现，包括2位的整数和任意整数（2的31次方以内）都可以。可自己选择需要的实现方式。
利用系统函数有
1. char * itoa ( int value, char * str, int base );value是要转化的数字，str是转化后的字符串存储的位置，base是进制数（但是这个函数不是标准C函数，有些编译器是不支持的！）。所以代码可以为：
1
2
3
4
5
6
7

char buffer ; //用于存放转换好的十六进制字符串，可根据需要定义长度

char * inttohex(int aa)
{
itoa (aa, buffer, 16);
return (buffer);
}
2. sprintf(str,"%x",value);str是转化存储的位置，%x表示十六进制格式，value是要转化的数字。所以代码可以为：
1
2
3
4
5
6
7

char buffer ; //用于存放转换好的十六进制字符串，可根据需要定义长度

char * inttohex(int aa)
{
sprintf(buffer, "%x", aa);
return (buffer);
}
3. 自己编写
如果参数只要两位数的整数，那么很简单。代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

char buffer ; //用于存放转换好的十六进制字符串。由于只要支持2位整数，所以长度3即可

char * inttohex(int aa)
{
if (aa / 16 《 10) //计算十位，并转换成字符
buffer = aa / 16 + ’0’;
else
buffer = aa / 16 - 10 + ’A’;
if (aa % 16 《 10) //计算个位，并转换成字符
buffer = aa % 16 + ’0’;
else
buffer = aa % 16 - 10 + ’A’;
buffer = ’\0’; //字符串结束标志
return (buffer);
}
如果参数是任意整数，由于计算方法是每次都除以16和对16取余数，余数以倒序的顺序排列就是结果，所以最佳方法是用递归函数（当然循环也可以，但需要最后再进行倒序）。递归代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

char buffer ; //用于存放转换好的十六进制字符串，可根据需要定义长度

char * inttohex(int aa)
{
static int i = 0;
if (aa 《 16) //递归结束条件
{
if (aa 《 10) //当前数转换成字符放入字符串
buffer = aa + ’0’;
else
buffer = aa - 10 + ’A’;
buffer = ’\0’; //字符串结束标志
}
else
{
inttohex(aa / 16); //递归调用
i++; //字符串索引+1
aa %= 16; //计算当前值
if (aa 《 10) //当前数转换成字符放入字符串
buffer = aa + ’0’;
else
buffer = aa - 10 + ’A’;
}
return (buffer);
}
最后测试代码如下（以sprintf为例，其余只要替换inttohex函数中的代码内容即可）：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include 《stdio.h》
#include 《stdlib.h》

char buffer ; //用于存放转换好的十六进制字符串，可根据需要定义长度

char * inttohex(int aa)
{
sprintf(buffer, "%x", aa);
return (buffer);
}

int main ()
{
int num;
char * hex_str;
printf ("Enter a number: ");
scanf ("%d",#);
hex_str = inttohex (num);
printf ("Hexadecimal number: %sH\n", hex_str);
return 0;

在c语言中用最简单的方法把十进制转化为十六进制

代码如下：

#include "stdio.h" 
int main() 
{ 
int num=0;
int a; 
int i=0; 
int m=0;
int yushu; 
char hex={’0’,’1’,’2’,’3’,’4’,’5’,’6’,’7’,’8’,’9’,’A’,’B’,’C’,’D’,’E’,’F’};
printf("请输入一个十进制整数："); 
scanf("%d",&num); 
while(num》0) 
{ 
yushu=num%16; 
a=yushu; 
num=num/16; 
} 
printf("转化为十六进制的数为：0x"); 
for(i=i-1;i》=0;i--)//倒序输出 {
m=a;
printf("%c",hex); 
} 
printf("\n"); 
}

程序运行结果：

扩展资料

C语言中，十进制转换十六进制，可以先输入十进制整数，然后去拼十六进制，十六进制由数字 0~9、字母 A~F 或 a~f（不区分大小写）组成，使用时必须以0x或0X（不区分大小写）开头，只需把二进制除以16得到余数去上面定义的hex数组进行取值接可以得到转换的数字。

用c++编写递归将十进制转换为十六进制

这个和十进制转成二进制很像

假设这个十进制数为n

就是不断取模，除以十六。。。一直到n==0

下面的是递归求解

#include 《stdio.h》
#include 《iostream》
using namespace std;
int n,cnt=0;
char num;
void dfs(int x){
    if(x/16!=0) dfs(x/16);
    if((x%16)《10) num=x%16+’0’;
    else num=x%16-10+’A’;
}
int main(){
    cin》》n;
    dfs(n);
    for(int i=1;i《=cnt;i++)
      cout《《num;
    return 0;
}

这是循环的

#include 《stdio.h》
#include 《iostream》
using namespace std;
int n,cnt=0;
char num;
int main(){
cin》》n;
while(n/16!=0){
  int tmp=n%16;
  if(tmp《10) num=tmp+’0’;
  else num=tmp-10+’A’;
  n/=16;
}
if(n!=0)
  if(n《10) num=n+’0’;
  else num=n-10+’A’; 
for(int i=cnt;i》=1;i--)
  cout《《num;
return 0;
}

怎么写一个c++程序，要求用递归函数将十进制数转化成十六进制数

#include《stdio.h》
Transcoding10_16(int i)
{
int m;
char n;
if(i》15)
{
Transcoding10_16(i/16);
m=i%16;
if(m》0&&m《10)print("%d",m);
else {n=’A’+(char)(m-10);print("%lf",n);}
}
else return i;
}
main()
{
int m;
m=123;//提供你修改的转换数据。也可以scanf录入；
Transcoding10_2(m);
}

C++ 用递归函数 将 十进制数n转换为十六进制数，要能正确输出

#include《stdio.h》
#include 《stdlib.h》
void trans( int n, char *buf)
{
char *p = buf, *q, c;
int d;
while(n》0) {
d = n %16;
if( d 《10) {
*p = d + ’0’;
} else {
*p = d - 10 + ’A’;
}
p ++;
n /=16;
}
*p = ’\0’;
for(p--, q=buf; q《p; q++, p--) {
c = *q;
*q = *p;
*p = c;
}
}
main()
{
int n=156;
char res;
trans(n, res);
printf("%s\n", res);
}
如果只是想输出的形式变化的话，那就很简单了，直接有%x就可以输出16进制的形式：
int n = 78;
printf("%x\n", n);
最会的输出是： 4e