【C/C++】数值转换成字符串|字符串转换成数值|进制转换

目录

string与数值的转换

string与数值的转换

C++11

C++11之前

格式化数字字符串

string 和 char * 之间互相转换 

C++11中int、char和string常用类型的相互转换方法

int类型转float类型

float类型转int类型

int类型转char[]数组类型

string类型转char[]数组类型

char[]数组类型转string类型

string类型转char*类型

char []与char *之间转换

char 与const char 之间转换

char *与string之间转换

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&amp;lt;stdlib.h&amp;gt;

定义函数
  int atoi(const char *nptr);

附加说明
  atoi()与使用strtol(nptr,(char**)NULL,10);结果相同。

范例
#include&amp;lt;stdlib.h&amp;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&amp;lt;stdlib.h&amp;gt;

定义函数
  long atol(const char *nptr);

函数说明
  atol()会扫描参数nptr字符串,跳过前面的空格字符,直到遇上数字或正负符号才开始做转换,而再遇到非数字或字符串结束时(&#39;&#39;)才结束转换,并将结果返回。

返回值
  返回转换后的长整型数。

附加说明
  atol()与使用strtol(nptr,(char**)NULL,10);结果相同。

范例

#include&amp;lt;stdlib.h&amp;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&amp;lt;stdlib.h&amp;gt;

定义函数
  char *gcvt(double number,size_t ndigits,char *buf);

函数说明
  gcvt()用来将参数number转换成ASCII码字符串,参数ndigits表示显示的位数。gcvt()与ecvt()和fcvt()不同的地方在于,gcvt()所转换后的字符串包含小数点或正负符号。若转换成功,转换后的字符串会放在参数buf指针所指的空间。

返回值
  返回一字符串指针,此地址即为buf指针。

附加说明

范例

  #include&amp;lt;stdlib.h&amp;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"

(原文: sprintf_百度百科
 IAR 类似问题:
   已经添加了<stdlib.h>,但TORNADO下编译出现 undefined   reference   to   `itoa'错误。
解决方法:TORNADO不支持itoa方法,在Tornado 2.0 Online Manuals : Routines中找不到itoa方法。用sprintf代替itoa吧。
关键词:Tornado; undefined   reference   to   `itoa'; VXWORKS;sprintf
KeyWords:Tornado; undefined   reference   to   `itoa'; VXWORKS;sprintf
不涉及编译器时:
一、数值型数据转化成字符型数据
 
杨涛说数据库还是什么东西在读入数据的时候只能识别字符型数据
然后我就想了想怎么把数值型数据转化成字符型

法一、

根据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);
  %% 印出百分比符号,不转换。
  %c 整数转成对应的 ASCII 字元。
  %d 整数转成十进位。
  %f 倍精确度数字转成浮点数。
  %o 整数转成八进位。
  %s 整数转成字符串。
  %x 整数转成小写十六进位。
  %X 整数转成大写十六进位。 ]

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

​

posted on 2022-10-04 01:31  bdy  阅读(476)  评论(0编辑  收藏  举报

导航