c++中二进制字符串转化为十六进制字符串的函数，比如“11111111”转为对应的“FF”.

Posted 2023-05-09

试试这个：

#include <stdio.h>
#include <string.h>
int main() 
 
 
int base=0,t,i,m;
char str[80],f;
printf("input the binary number\\n");
gets(str);
t=strlen(str);
int b2;

for(i=0;i<t;i++)

if(str[i]!='0' && str[i]!='1')//输入检查

printf("输入不是二进制整数！\\n");
break;

int b=str[i]-'0';//把当前位字符变为数字
base = (base<<1) + b;


sprintf(str,"%X",base);
printf("%s",str);

 return 0; 

参考技术A 1 #include<stdio.h>
2 int BIN2HEX(char * binary)
3
5 char hex[]='0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F';
6 if(NULL!=binary)
7 printf("Error input parameter!\n");
8 return 0;
9
10 int length=strlen(binary);
11 int num=0;
12 char tmpchar[5]=0;
15 while(length>0)
16 memset(tmpchar,'0',4);
17 if(length>=4)
18 strncpy(tmpchar,binary+length-4,4);
19 num=(tmpchar[0]-48)*8+(tmpchar[1]-48)*4+(tmpchar[2]-48)*2+(tmpchar[3]-48);
20 sprintf("%c",hex[num]);
21 length-=4;
22
23 else
24 strncpy(tmpchar+4-length,binary+length-3,length);
25 num=(tmpchar[0]-48)*8+(tmpchar[1]-48)*4+(tmpchar[2]-48)*2+(tmpchar[3]-48);
26 printf("%c\n",hex[num]);
27 length=0;
28
29
30
31
这个输出的顺序是颠倒的，你存在一个临时数组里面反向输出就可以了，我是为了照顾最高为不足补0，所以从后往前转换的，不过也可以先把字符串填充成4的整数倍再从头开始转换。那样可能看着简单点。就这吧本回答被提问者采纳

c++知识点

### 1、stoi（）函数
stoi（字符串，起始位置，n进制），将 n 进制的字符串转化为十进制 示例：stoi(str, 0, 2); //将字符串 str 从 0 位置开始到末尾的 2 进制转换为十进制。stoi()会做范围检查，默认范围是在int的范围内的，如果超出范围的话则会runtime error！
### 2、const
**（1）、const对象默认为文件局部变量**
非const变量默认为extern。要使const变量能够在其他文件中访问，必须在文件中显式地指定它为extern。
未被const修饰的变量在不同文件下的访问
```c++// file1.cppint ext// file2.cpp#include<iostream>/** * by 光城 * compile: g++ -o file file2.cpp file1.cpp * execute: ./file */extern int ext;int main(){ std::cout<<(ext+10)<<std::endl;}```
const常量在不同文件的访问
```c++//extern_file1.cppextern const int ext=12;//extern_file2.cpp#include<iostream>/** * by 光城 * compile: g++ -o file const_file2.cpp const_file1.cpp * execute: ./file */extern const int ext;int main(){ std::cout<<ext<<std::endl;}```
**（2）指针与const**
```const char * a; //指向const对象的指针或者说指向常量的指针。char const * a; //同上char * const a; //指向类型对象的const指针。或者说常指针、const指针。const char * const a; //指向const对象的const指针。```
如果*const*位于`*`的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于`*`的右侧，*const*就是修饰指针本身，即指针本身是常量。
**指向常量的指针常量的值不可以修改（指向常量的指针）**
```c++const int * a =10;*a=20; //错误，不能更改常量的值，但是指针的指向可以修改```
**常量指针指向不可以修改，且必须初始化（常指针）**
```c++i#include<iostream>using namespace std;int main(){
 int num=0; int * const ptr=&num; //const指针必须初始化！且const指针的值不能修改 int * t = &num; *t = 1; cout<<*ptr<<endl;}```
当把一个const常量的地址赋值给ptr时候，**由于ptr指向的是一个变量，而不是const常量**，所以会报错，出现：const int`*` -> int `*`错误！
```c++#include<iostream>using namespace std;int main(){ const int num=0; //const常量 int * const ptr=&num; //error! const int* -> int* cout<<*ptr<<endl;}```


除此之外，也不能使用void`*`指针保存const对象的地址，必须使用const void`*`类型的指针保存const对象的地址。
```c++const int p = 10;const void * vp = &p;void *vp = &p; //error```
**允许把非const对象的地址赋值给指向const对象的指针**
```c++const int *ptr;int val = 3;ptr = &val; //ok```
**指向常量的常指针**
```c++const int p = 3;const int * const ptr = &p; ```
**（3）const修饰函数的形参列表**
1、对于非内部数据类型的参数而言，象void func(A a) 这样声明的函数注定效率比较低。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。
2、对于内部数据类型来说，即常见的数据类型int，double、char等
内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。
总结：**对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void func(A a) 改为void func(const A &a)。对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void func(int x) 不应该改为void func(const int &x)。**
**（4）类中使用const**
在一个类中，任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。使用const关字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字明的成员函数不能用来操作常对象。
对于类中的const成员变量必须通过初始化列表进行初始化，如下所示：
```c++class Apple{private: int people[100];public: Apple(int i);  const int apple_number;};
Apple::Apple(int i):apple_number(i){
}```
const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
```c++//apple.cppclass Apple{private: int people[100];public: Apple(int i); //构造函数 const int apple_number;  void take(int num) const; //const成员函数 int add(int num); int add(int num) const; //const成员函数 int getCount() const; //const成员函数
};//main.cpp#include<iostream>#include"apple.cpp"using namespace std;
Apple::Apple(int i):apple_number(i) //初始化{
}int Apple::add(int num){ take(num);}int Apple::add(int num) const{ take(num);}void Apple::take(int num) const{ cout<<"take func "<<num<<endl;}int Apple::getCount() const{ take(1);// add(); //error return apple_number;}int main(){ Apple a(2); cout<<a.getCount()<<endl; a.add(10); const Apple b(3); b.add(100); return 0;}//编译：g++ -o main main.cpp apple.cpp//结果take func 12take func 10take func 100```

推荐一篇博文，坚持不住的时候就多看看别人

你的编程能力从什么时候开始突飞猛进？- 拓跋阿秀的回答 - 知乎 https://www.zhihu.com/question/356351510/answer/1869223245

阿里云的这群疯子 - 史中的文章 - 知乎 https://zhuanlan.zhihu.com/p/46884081