目录
C++11中int、char和string常用类型的相互转换方法
string与数值的转换
C++11
头文件：#include <string>
数值转string
to_string(val)：可以将其他类型转换为string。
string转数值
s：表示整数内容的字符串；
b：表示转换所用的基数，默认为10(表示十进制)；
p：是size_t的指针，用来保存s中第一个非数值字符的下标，p默认为0，即函数不返回下标。
stoi(s, p, b)：string转int
stol(s, p, b)：string转long
stod(s, p, b)：string转double
stof(s, p, b)：string转float
stold(s, p, b)：string转long dluble
stoul(s, p, b), stoll(s, p, b), stoull(s, p, b)等。
void testTypeConvert()
{
//int --> string
int i = 5;
string s = to_string(i);
cout << s << endl;
//double --> string
double d = 3.14;
cout << to_string(d) << endl;
//long --> string
long l = 123234567;
cout << to_string(l) << endl;
//char --> string
char c = 'a';
cout << to_string(c) << endl; //自动转换成int类型的参数
//char --> string
string cStr; cStr += c;
cout << cStr << endl;
s = "123.257";
//string --> int;
cout << stoi(s) << endl;
//string --> long
cout << stol(s) << endl;
//string --> float
cout << stof(s) << endl;
//string --> doubel
cout << stod(s) << endl;
}C++11之前
atoi(将字符串转换成整型数)
相关函数
atof，atol，atrtod，strtol，strtoul
表头文件
#include&lt;stdlib.h&gt;
定义函数
int atoi(const char *nptr);
附加说明
atoi()与使用strtol(nptr，(char**)NULL，10);结果相同。
范例
#include&lt;stdlib.h&gt;
mian()
{
char a[]=”-100”;
char b[]=”456”;
int c;
c=atoi(a)+atoi(b);
printf(c=%d ”,c);
}
执行
c=356
atol(将字符串转换成长整型数)
相关函数
atof，atoi，strtod，strtol，strtoul
表头文件
#include&lt;stdlib.h&gt;
定义函数
long atol(const char *nptr);
函数说明
atol()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('')才结束转换，并将结果返回。
返回值
返回转换后的长整型数。
附加说明
atol()与使用strtol(nptr,(char**)NULL,10);结果相同。
范例
#include&lt;stdlib.h&gt;
main()
{
char a[]=”1000000000”;
char b[]=” 234567890”;
long c;
c=atol(a)+atol(b);
printf(“c=%d ”,c);
}
执行
c=1234567890
gcvt(将浮点型数转换为字符串，取四舍五入)
相关函数
ecvt，fcvt，sprintf
表头文件
#include&lt;stdlib.h&gt;
定义函数
char *gcvt(double number，size_t ndigits，char *buf);
函数说明
gcvt()用来将参数number转换成ASCII码字符串，参数ndigits表示显示的位数。gcvt()与ecvt()和fcvt()不同的地方在于，gcvt()所转换后的字符串包含小数点或正负符号。若转换成功，转换后的字符串会放在参数buf指针所指的空间。
返回值
返回一字符串指针，此地址即为buf指针。
附加说明
范例
#include&lt;stdlib.h&gt;
main()
{
double a=123.45;
double b=-1234.56;
char *ptr;
int decpt,sign;
gcvt(a,5,ptr);
printf(“a value=%s ”,ptr);
ptr=gcvt(b,6,ptr);
printf(“b value=%s ”,ptr);
}
执行
a value=123.45
b value=-1234.56自己写转换方法了，代码如下：
从其它类型转换为string，定义一个模板类的方法。
从string转换为其它类型，定义多个重载函数。
#include <strstream>
template<class T>
string convertToString(const T val)
{
string s;
std::strstream ss;
ss << val;
ss >> s;
return s;
}
int convertStringToInt(const string &s)
{
int val;
std::strstream ss;
ss << s;
ss >> val;
return val;
}
double convertStringToDouble(const string &s)
{
double val;
std::strstream ss;
ss << s;
ss >> val;
return val;
}
long convertStringToLong(const string &s)
{
long val;
std::strstream ss;
ss << s;
ss >> val;
return val;
}
void testConvert()
{
//convert other type to string
cout << "convert other type to string:" << endl;
string s = convertToString(44.5);
cout << s << endl;
int ii = 125;
cout << convertToString(ii) << endl;
double dd = 3.1415926;
cout << convertToString(dd) << endl;
//convert from string to other type
cout << "convert from string to other type:" << endl;
int i = convertStringToInt("12.5");
cout << i << endl;
double d = convertStringToDouble("12.5");
cout << d << endl;
long l = convertStringToLong("1234567");
cout << l << endl;
}格式化数字字符串
sprintf 最常见的应用之一莫过于把整数打印到字符串中，所以，spritnf 在大多数场合可以替代 itoa。
如： //把整数123 打印成一个字符串保存在s 中。
sprintf(s, "%d", 123); //产生"123"
然后我就想了想怎么把数值型数据转化成字符型
法一、
根据ASC码：
(1)对于个位数，可以将其值加48然后赋给一个字符型变量；
(2)对于两位数及以上的数，可以将其各位上的数码分解出来然后同(1)，这是需要一个数组来放这一系列数据；
法二、
由各类数值型数据之间的转换想到的：
将数值型数据 + '0'即可
如
int a = 9;
char b;
b = a + '0';
其他步骤同法一，单个分解，对于两位数及以上的数同样需要一个数组；
不过以上这两种方法计算量相当大！！
法三、
偶然发现存在这样一个现成的函数itoa，可以非常方便的实现这个功能
函数原型 char *itoa(int value,char *string,int radix)
参数说明 value是要转化的数值，string是转化后的字符串，radix是转换的进制，
函数返回一个指向string的指针，
调用这个函数需要包含 stdlib.h 这个头文件
通用方法(针对非COM数据类型)
用sprintf完成转换
char buffer[200];
char c = '1 ';
int i = 35;
long j = 1000;
float f = 1.7320534f;
sprintf( buffer, "%c ",c);
sprintf( buffer, "%d ",i);
sprintf( buffer, "%d ",j);
sprintf( buffer, "%f ",f);
string 和 char * 之间互相转换
char * 可以转string，直接赋值即可。不能单独赋int和c字符类型值。
string s1("demo1");
string s1 = "demo";
char *p = "demo";
s1 = p;
string转char*有三种方式：c_str(),data(),copy()
c_str()返回一个c风格的字符数组，带有'\0'结束
data()返回一个数组，不自动增加‘\0’
copy()拷贝一块字符到新的内存，需要新分配一块内存用于存放。
前两个函数，原有内容发生变化，地址指的内容也会变化，使用copy不会发生这种问题。(见例子3)
const char *p = s.data();
const char * p = s.c_str();
char *p = new char[s.length() + 1];
s.copy(p, string::npos);
p[s.length()] = 0;
用好，释放 p
例子3：
std::string s1 = "demo 123456\n \0";
const char *p1 = s1.c_str();
const char *p2 = s1.data();
s1 = "345";
s1 内容发生变化后，p1和p2指针内容的地址也发生变化。
原文链接：https://blog.csdn.net/cpongo4/article/details/93856634
C++11中int、char和string常用类型的相互转换方法
常用类型之间的转换经常用到，特地总结一下，只记录常用的一些方法
所有用法已在VS2019中运行通过，并使用编译器推荐的函数，如有错误，请指正！
int类型转float类型
int类型转float类型，直接赋值就行，主要是注意计算过程中的赋值，例如：
int a = 2, b = 3;
//float c = (a + b) / 2; 此时c为2，因为是先计算再赋值
float c = (a + b) / 2.0;
float类型转int类型
float类型转int类型，直接赋值就行，小数点之后直接省略。例如：
float a = 3.99;
int b = a;//b为3；
int类型转char类型，加上‘0’；
char类型转int类型，减去‘0’，其实就是ASCII码的加减，暂不讨论越界的问题，例如：int a = 4; char b = a + '0';
char c = '4'; int d = c - '0'
int类型转char[]数组类型
int类型转char[]数组类型，使用_itoa_s()函数，输入三个参数。依次是int数值，char型数组，进制。例如：
int a = 123;
char str[10];
_itoa_s(a, str, 10);//此时str数组内前三个元素依次为‘1’，‘2’，‘3’
string类型转char[]数组类型
string类型转char[]数组类型，使用strcpy_s()函数，输入两个参数，依次是数组名，字符串。例如：
string a = 123;
char b[10];
strcpy_s(b,a.c_str());//此时b数组内前三个元素依次为‘1’，‘2’，‘3’
char[]数组类型转string类型
char[]数组类型转string类型，直接赋值就行，例如：
char a[] = {'1', '2', '3'};
string b = a;
string类型转char*类型
string类型转char*类型，使用c_str()函数，c_str()函数返回的是一个const char*指针。例如：
string a = "123";
char* b = (char*)a.c_str();
char*类型转string类型，直接赋值就行。例如：
char* a = "123";
string b = a;
————————————————
原文链接：https://blog.csdn.net/qq_43217697/article/details/115523257
char []与char *之间转换
char []转char *：直接进行赋值即可
// char[] 转char *
char str[] = "lala";
char *str1 = str;
cout << str1 << endl;
char *转char[]：字符拷贝实现，不能进行赋值操作
// char *转换为char []
const char *st = "hehe";
char st1[] = "lalalala";
strncpy(st1, st, strlen(st) + 1); // 注意加1操作
// tp = temp; //错误，不能实现
cout << st1 << endl;
char 与const char 之间转换
const char 转char ：拷贝实现，不能进行赋值
// const char *转char *
const char *st = "lala";
// 直接赋值不可以
//char *st1 = st; // (不可以编译器报错)
//cout << st1 << endl;
// 另外开辟空间，将字符一个一个复制过去
char *ncstr = new char[strlen(st) + 1];
strcpy(ncstr, st);
cout << ncstr << endl;
char 转const char ：直接进行赋值
// char *转const char *
char *st = "hehe"; // (编译提示警告)
const char *st1 = st;
cout << st1 << endl;
char *与string之间转换
char *转string：1)直接赋值；2)构造转换实现
// char*转换为string
// (注意，定义char *变量，并直接赋值，最好定义为const变量，否则编译器警告)
const char *st = "hello";
// 赋值转换
string st1 = st;
cout << st1 << endl;
// 构造转换
string s1(st, st + strlen(st));
cout << s1 << endl;
// 改变const char *变量值
st = "lalala";
cout << st << endl;
string转char *：赋值操作(注意类型转换)
// string转char *
string st = "My test";
//char *st1 = st; // 错误类型不同
//char *st1 = st.c_str(); // 错误类型不同
char *st1 = const_cast<char *>(st.c_str()) ;
cout << st1 << endl;
char[]与string之间转换
char []转string：1)直接赋值；2)构造转换实现
// char[]转换为string
char st[] = "hello";
// 直接赋值实现
string st1 = st;
cout << st1 << endl;
// 构造实现
string st2(st, st + strlen(st));
cout << st2 << endl;
string转char[]：拷贝实现，不能直接赋值
// string转char []
string ts = "My test1";
//char ts1[] = ts; // 错误
//char ts1[] = const_cast<char *>(ts.c_str()); // 错误
char ts1[] = "lalallalalaaaa";
strncpy(ts1, ts.c_str(), ts.length() + 1); // 注意，一定要加1，否则没有赋值'\0'
cout << ts1 << endl;
return 0;
总结
涉及到char []字符数组与其它类型转换，一般需要进行拷贝，不能直接赋值实现。char []和char *都可以通过构造新的string完成其对string的转换。涉及到到char *转换，需要注意类型一致，同时注意const的使用。
原文：https://blog.csdn.net/yzhang6_10/article/details/51164300
进制转换
十进制数值转成十六进制字符数组
以2字节的字符数组存放一个16进制数(存放高八位和低八位)
float value0
char value3_char[2]；
Dec_To_Hex(value3_char,value0);//风速
void Dec_To_Hex(char *p,float value)
{
int TempValue;
TempValue=(int)(value);
*p=((TempValue>>8)&0xFF);/
int Negative_To_Bin(int Negative)
{
Negative=-Negative;//取绝对值
Negative=~Negative;//按位取反
Negative=Negative+1;
return Negative;
}
浮点数转16进制
【浮点数转16进制】小数(单精度浮点数)转16进制字节
#include <stdio.h>
float Hex_To_Decimal(unsigned char *Byte,int num)//十六进制到浮点数
{
// char cByte[4];//方法一
// for (int i=0;i<num;i++)
// {
// cByte[i] = Byte[i];
// }
//
// float pfValue=*(float*)&cByte;
//return pfValue;
return *((float*)Byte);//方法二
}
long FloatTohex(float HEX)//浮点数到十六进制转换1
{
return *( long *)&HEX;
}
void FloatToByte(float floatNum,unsigned char* byteArry)浮点数到十六进制转换2
{
char* pchar=(char*)&floatNum;
for(int i=0;i<sizeof(float);i++)
{
*byteArry=*pchar;
pchar++;
byteArry++;
}
}
void main()
{
unsigned char floatToHex[4];
unsigned char hexbyte[4]={0xcd,0xCC,0xCC,0x3D};//传输数据为3d cc cc cd
float Hdecimal=0.0;
float flh=0.4;
// int num=sizeof(hexbyte);
// printf("num= %d\n",num);
Hdecimal=Hex_To_Decimal(hexbyte,sizeof(hexbyte));//十六进制转换为浮点数
printf("\n 浮点数为：\n %f\n",Hdecimal);
long hX=FloatTohex(Hdecimal);//浮点数转换为十六进制一
printf("\n正序十六进制值：\n %f=%X \n",Hdecimal,hX);//正序显示
FloatToByte(Hdecimal,floatToHex);//浮点数转为十六进制二
printf("\n倒序十六进制：\n%f=%x %x %x %x\n",Hdecimal,floatToHex[0],floatToHex[1],floatToHex[2],floatToHex[3] );//倒序显示
FloatToByte(flh,floatToHex);//浮点数转为十六进制二
printf("\n倒序十六进制：\n%f=%x %x %x %x\n",flh,floatToHex[0],floatToHex[1],floatToHex[2],floatToHex[3] );//低位在前
FloatToByte(flh,floatToHex);//浮点数转为十六进制二
printf("\n正序十六进制：\n%f=%x %x %x %x\n",flh,floatToHex[3],floatToHex[2],floatToHex[1],floatToHex[0] );//高位在前
}
原文：单精度浮点数与十六进制转换 C语言程序 单片机也可用 - 百度文库
float存储格式及FPU：
float存储格式及FPU
浮点数用科学计数法的形式存储, 即分成符号位, 底数位和指数位
如 10.0 的二进制表示为 1010.0, 科学表示法表示为: 1.01exp110, 即 (1+0*1/2+1*1/4)*2^3. 小数点每左移一位指数要加1, 每右移一位指数要减1.
其存储格式符合IEEE标准, 即
数据格式 符号位 底数位 指数位
单精度 float 1 23 8
双精度 double 1 52 11
扩展精度 1 64 15
存储顺序为: 符号位 指数位 底数位, 由于底数的个位必为1, 因此个位和小数点就不存储. 指数位的高位也是符号位, 不过为1表示正, 0表示负.
float 因有 8 bits, 所以能表示的有 2 的 256 次方,
但因為指數應可正可負,
所以 IEEE 規定, 此處算出的次方須減去 127 才是真的指數,
所以 float 的指數可從-126 到 128.
double 型態有 11 bits, 算出的值須減去 1023,
所以double 的指數可從 -1022 到 1024.
底数 (mantissa):
〈特例〉0 不能以 2 的次方表示
float : 00 00 00 00
double: 00 00 00 00 00 00 00 00
由此可推断浮点数的精度. 单精度的底数只存储23位, 即最小一位为 1/2^23, 故精度为 1/2^23 = 1.19209e-7, 可精确到小数点后6位; 双精度的底数存储52位, 最小位为 1/2^52, 精度为 1/2^52 = 2.22045e-16, 能精确到小数点后15位.
双精度的最大值约为 2*2^(2^10-1), 约为1.79e308
1094
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
