C++中int,char,string,CString类型转换

合集下载

c 式转换规则

c 式转换规则
C语言中的数据类型转换规则可以分为自动转换和强制转换两类。

自动转换发生在不同数据类型的数据混合运算时，C语言会根据需要将数据类型转换统一，以保证运算的正确性。

具体转换规则如下：
1. 算术运算中，低类型能够转换为高类型。

例如，char类型和short类型会转换为int类型，float类型数据在运算时一律转换为double类型。

2. 在赋值表达式中，右边表达式的值会自动隐式转换为左边变量的类型，并赋值给左边变量。

如果右边变量的数据类型长度比左边长，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。

3. 在函数调用中，系统会隐式地将实参转换为形参的类型后，赋给形参。

4. 函数有返回值时，系统将隐式地将返回表达式类型转换为返回值类型，赋值给调用函数。

强制转换是通过类型转换运算来实现的，形式为在要转换的数值或者表达式前用小括号将要类型括起来。

例如：(int)x表示将x转换为整型。

如需获取更多C语言中数据类型的转换规则和相关解释，可以查阅相关的编程书籍或者咨询专业技术人员。

c语言大值int强转char规则

c语言大值int强转char规则【原创实用版】目录1.C 语言中的数据类型2.整型（int）和字符型（char）的转换规则3.int 强转 char 的方法4.实际应用中的注意点正文一、C 语言中的数据类型C 语言中，数据类型可以分为基本数据类型和复合数据类型两大类。

基本数据类型包括整型、浮点型、字符型等，而复合数据类型包括数组、结构体、联合体等。

其中，整型和字符型是最常用的数据类型之一。

二、整型（int）和字符型（char）的转换规则在 C 语言中，整型和字符型之间的转换可以通过类型强制转换来实现。

具体来说，可以将整型数据强制转换为字符型数据，也可以将字符型数据强制转换为整型数据。

int 转 char 的方法如下:```cint num = 100;char ch = (char)num;```ch 中存储的值为字符"D",因为整型数据 100 在 ASCII 码表中对应的字符是"D",其 ASCII 码值为 100。

char 转 int 的方法如下:```cchar ch = "A";int num = (int)ch;```um 中存储的值为字符"A"的 ASCII 码值，即 65。

三、int 强转 char 的方法int 强转 char 的方法与 int 转 char 的方法类似，也可以通过类型强制转换来实现。

不过，由于 int 类型的数据范围较大，而 char 类型的数据范围较小，因此在进行 int 强转 char 时，需要确保 int 类型的数据在 char 类型的数据范围内，否则会丢失数据。

例如:```cint num = 2147483648;char ch = (char)num; // ch 中存储的值为字符"?"```由于字符"?"的 ASCII 码值为 63，而 2147483648 大于 63，因此ch 中存储的值为字符"?",即 ASCII 码值为 63 的字符。

c语言int转char规则

在 C 语言中，将整数类型int转换为字符类型char通常需要注意一些规则，因为char类型是一个整数类型，但它通常被用于表示字符。

以下是将int转换为char 的一些规则和注意事项：1.显式类型转换：在 C 语言中，可以使用显式的类型转换将int转换为char。

这可以通过将整数值直接赋值给char变量，但需要使用括号将目标类型括起来。

int num =65;// 整数值char ch =(char) num;// 显式转换为 charprintf("%c\n", ch);// 输出：A2.注意值的范围：char类型通常被用来表示单个字符，它的取值范围是 -128 到 127 或 0 到255，具体取决于系统的字符编码。

如果整数值超出了char的取值范围，将会发生截断，只保留低位的字节。

int num =300;// 超出 char 的范围char ch =(char) num;printf("%d\n", ch);// 输出：44 （300 % 256 = 44）3.注意符号：如果整数值是负数，将会按照补码表示法进行转换。

负数的补码会变成相应正数的补码，然后再按位取反加一。

结果可能不是预期的字符。

int num =-65;// 负整数值char ch =(char) num;printf("%c\n", ch);// 输出：遗留值（取决于系统的字符编码）4.字符编码：char类型在 C 中通常用来表示 ASCII 码或其他字符编码的值。

例如，'A'对应的 ASCII 码是 65，因此将int值 65 转换为char会得到字符'A'。

int num =65;char ch =(char) num;printf("%c\n", ch);// 输出：A总之，将int转换为char需要考虑取值范围、符号以及字符编码等因素。

CString,char,const char ,LPCTSTR 的转换

CString,char*,const char *,LPCTSTR 的转换如何将CString类型的变量赋给char*类型的变量1、GetBuffer函数：使用CString::GetBuffer函数。

char *p;CString str="hello";p=str.GetBuffer(str.GetLength());str.ReleaseBuffer();将CString转换成char *时CString str("aaaaaaa");strcpy(str.GetBuffer(10),"aa");str.ReleaseBuffer();当我们需要字符数组时调用GetBuffer(int n),其中n为我们需要的字符数组的长度.使用完成后一定要马上调用ReleaseBuffer();还有很重要的一点就是,在能使用const char *的地方,就不要使用char *2、memcpy：CString mCS=_T("cxl");char mch[20];memcpy(mch,mCS,20);3、用LPCTSTR强制转换：尽量不使用char *ch;CString str;ch=(LPSTR)(LPCTSTR)str;CString str = "good";char *tmp;sprintf(tmp,"%s",(LPTSTR)(LPCTSTR)str);4、CString Msg;Msg=Msg+"abc";LPTSTR lpsz;lpsz = new TCHAR[Msg.GetLength()+1];_tcscpy(lpsz, Msg);char * psz;strcpy(psz,lpsz);CString类向const char *转换char a[100];CString str("aaaaaa");strncpy(a,(LPCTSTR)str,sizeof(a));或者如下:strncpy(a,str,sizeof(a));以上两种用法都是正确地.因为strncpy的第二个参数类型为const char *.所以编译器会自动将CString类转换成const char *.CString转LPCTSTR (const char *)CString cStr;const char *lpctStr=(LPCTSTR)cStr;LPCTSTR转CStringLPCTSTR lpctStr;CString cStr=lpctStr;将char*类型的变量赋给CString型的变量可以直接赋值，如：CString myString = "This is a test";也可以利用构造函数，如：CString s1("Tom");将CString类型的变量赋给char []类型(字符串)的变量1、sprintf()函数CString str = "good";char tmp[200] ;sprintf(tmp, "%s",(LPCSTR)str);(LPCSTR)str这种强制转换相当于(LPTSTR)(LPCTSTR)strCString类的变量需要转换为(char*)的时,使用(LPTSTR)(LPCTSTR)str然而，LPCTSTR是const char *,也就是说，得到的字符串是不可写的！将其强制转换成LPTSTR 去掉const，是极为危险的！一不留神就会完蛋！要得到char *,应该用GetBuffer()或GetBufferSetLength()，用完后再调用ReleaseBuffer()。

c语言连续类型转换两次转换

c语言连续类型转换两次转换c语言中的类型转换是指将一种数据类型的值转换为另一种数据类型的操作。

在c语言中，当我们需要将一个数据类型转换为另一个数据类型时，可以使用类型转换运算符将其转换为目标类型。

在一些情况下，我们可能需要进行连续两次类型转换，这种情况下需要注意一些问题。

首先，让我们来看一下在c语言中类型转换的基本概念。

c语言中的类型转换分为隐式类型转换和显式类型转换。

隐式类型转换是在不需要特别指定的情况下自动发生的类型转换，而显式类型转换则需要使用类型转换运算符来指定要进行的类型转换的方式。

例如，当我们将一个int类型的变量赋值给一个float类型的变量时，就会发生隐式类型转换。

在这种情况下，编译器会自动将int 类型的值转换为float类型的值，并将结果赋给目标变量。

当我们需要进行显式类型转换时，可以使用类型转换运算符来实现。

在c语言中，类型转换运算符包括`(type)`，其中type为目标类型。

通过使用这个运算符，我们可以将一个值转换为目标类型，并使用转换后的值。

在一些情况下，我们可能需要进行连续两次类型转换。

这种情况下，我们需要注意一些问题。

首先，需要确保两次转换能够得到正确的结果。

例如，如果要将一个int类型的值先转换为float类型，然后再转换为double类型，就需要确保中间结果能够准确地表示为float类型的值。

否则，在进行第二次转换时就可能会出现精度丢失的问题。

另外，还需要注意类型转换的顺序。

在进行连续两次类型转换时，要确保转换的顺序是正确的。

例如，如果要将一个int类型的值先转换为float类型，再转换为double类型，就需要先进行int到float的转换，然后再进行float到double的转换。

除了以上两点之外，还需要考虑类型转换的范围和精度。

在进行连续两次类型转换时，要确保转换的范围和精度能够满足目标类型的要求。

否则，就可能会出现数据丢失或错误的情况。

总的来说，在c语言中进行连续两次类型转换需要注意以上几点。

string、wstring、cstring、+char、+tchar、int、dword转换方法

int atoi(const char *nptr);
long atol(const char *nptr);
long long atoll(const char *nptr);
long long atoq(const char *nptr);
10》int转char*和string
CString strtest;
char * charpoint;
charpoint="give string a value";
strtest=charpoint; //直接付值
...................................................................
{
string result(cstr.GetLength(),'e');
for (int i=0;i<cstr.GetLength();i++)
{
result[i]=(char)cstr[i];
}
return result;
}
5》string转char *
a）char *p = string.c_str();
具体问题具体分析，浮云啊，一切皆是浮云.....
以下摘录自网络：
..............................................................
《C++标准函数库》中说的
有三个函数可以将字符串的内容转换为字符数组和C—string
1.data(),返回没有”/0“的字符串数组
string 转 CString

c中string转int的方法

c中string转int的方法在C语言中，将字符串转换为整数是一个常见的需求。

为了实现这个功能，我们可以使用一些C语言的库函数或者自己编写代码来完成。

在本篇文章中，我们将以中括号为主题，详细介绍几种不同的方法来将字符串转换为整数。

一、使用库函数atoi()库函数`atoi()`是C语言中最简单和最常用的字符串转换为整数的方法之一。

在使用这个函数之前，我们需要包含头文件`stdlib.h`，因为`atoi()`函数在这个头文件中声明。

`atoi()`函数的原型如下：cint atoi(const char* str);它的参数是一个指向字符串的指针，返回值是一个整数。

`atoi()`函数将会扫描字符串，跳过前导空格，然后将遇到的数字字符转换为整数直到遇到非法字符或者字符串结束。

下面是使用`atoi()`函数的一个示例：c#include <stdio.h>#include <stdlib.h>int main() {const char* str = "12345";int num = atoi(str);printf("The number is: %d\n", num);return 0;}输出结果：The number is: 12345`atoi()`函数的缺点是不能处理溢出的情况。

如果字符串表示的整数超出了`int`类型的范围，`atoi()`函数将返回一个未定义的值。

二、使用库函数sscanf()除了`atoi()`函数，C语言还提供了另一个库函数`sscanf()`用于格式化输入。

`sscanf()`函数可以将字符串中的数据根据指定的格式解析为不同的数据类型。

`sscanf()`函数的原型如下：cint sscanf(const char* str, const char* format, ...);这个函数的第一个参数是一个指向输入字符串的指针，第二个参数是一个包含格式字符串的指针。

Cstring转charstringint等数据类型的方法

Cstring转charstringint等数据类型的方法C++提供了许多方法来进行Cstring到其他数据类型的转换。

下面是一些常用的方法：1. Cstring转char数组：我们可以使用Cstring类的`c_str(`方法将Cstring转换为char数组。

该方法返回一个指向Cstring内部的字符数组的指针。

例如：```cpp#include <iostream>#include <cstring>using namespace std;int maiconst char* charArr = str.c_str(;cout << "char array: " << charArr << endl;return 0;```输出：```char array: Hello World```2. Cstring转string：可以使用string类的构造函数来将Cstring转换为string类型。

例如：```cpp#include <iostream>#include <cstring>using namespace std;int maistring strObj(str);cout << "string: " << strObj << endl;return 0;```输出：```string: Hello World```3. Cstring转int：将Cstring转换为int有几种方法，其中一种是使用标准库函数`atoi(`。

例如：```cpp#include <iostream>#include <cstring>#include <cstdlib>using namespace std;int maiint num = atoi(str.c_str();cout << "int: " << num << endl;return 0;```输出：``````这里我们首先使用了`c_str(`方法将Cstring转换为char数组，然后使用`atoi(`将char数组转换为int类型。

CString 类型转换大全

CString 类型转换大全首页>CString转int _ttoi() _tcstoul() Format ASSERT()作者: tags:Form for TC ORM String int CString assert str sse ing for inassert int _ttoi() _tcstoul() Format ASSERT()CString 型转化成 int 型把 CString 类型的数据转化成整数类型最简单的方法就是使用标准的字符串到整数转换例程。

虽然通常你怀疑使用_atoi()函数是一个好的选择，它也很少会是一个正确的选择。

假如你预备使用 Unicode 字符，你应该用_ttoi()，它在 ANSI 编码系统中被编译成_atoi()，而在 Unicode 编码系统中编译成_wtoi()。

你也可以考虑使用_tcstoul()或者_tcstol()，它们都能把字符串转化成任意进制的长整数（如二进制、八进制、十进制或十六进制），不同点在于前者转化后的数据是无符号的（unsigned），而后者相反。

看下面的例子：CString hex = _T("FAB");CString decimal = _T("4011");ASSERT(_tcstoul(hex, 0, 16) == _ttoi(decimal));在做DWORD与 CString 比较的时候，需要将CString 转换成 DWORD，有几种转换方法，但是明明转换结果是一样的，可就是提示不相等，后来 _tcstoul()转换后才相等，记录下CString str = lp->GetSubItem(nCol);// MessageBox(str,m_strItem,MB_OK);DWORD dwData = _tcstoul( str, NULL, 10 ); // 10进制if (dwItem ==dwData){//AfxMessageBox("找到找到找到找到找到找到找到找到找到找到找到找到找到");return pCur;}使用_tcstoul()或者_tcstol()，它们都能把字符串转化成任意进制的长整数（如二进制、八进制、十进制或十六进制），不同点在于前者转化后的数据是无符号的（unsigned），而后者相反。

常见的字符串转换方法有

常见的字符串转换方法有常见的字符串转换方法有：1. 字符串转为整数：使用int()函数，将字符串转为整数。

例如：int("123")返回整数123。

2. 字符串转为浮点数：使用float()函数，将字符串转为浮点数。

例如：float("3.14")返回浮点数3.14。

3. 整数或浮点数转为字符串：使用str()函数，将整数或浮点数转为字符串。

例如：str(123)返回字符串"123"。

4. 字符串转为布尔值：可以使用bool()函数，将字符串转为布尔值。

例如：bool("True")返回True。

5. 字符串转为列表：使用split()方法，将字符串按照指定的分隔符分割为列表。

例如："1,2,3".split(",")返回列表["1","2","3"]。

6. 列表转为字符串：使用join()方法，将列表中的元素连接为一个字符串。

例如：",".join(["1","2","3"])返回字符串"1,2,3"。

7. 字符串转为日期或时间：使用datetime模块中的strptime()函数，将字符串按照指定的格式转为日期或时间对象。

例如：datetime.datetime.strptime("2021-01-01","%Y-%m-%d")返回日期对象。

8. 日期或时间转为字符串：使用datetime模块中的strftime()函数，将日期或时间对象按照指定的格式转为字符串。

例如：datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")返回当前时间的字符串表示。

c语言中数组数据类型转化

c语言中数组数据类型转化在C语言中，数组是一种非常常见的数据类型，它可以存储一组相同的数据类型。

在有些情况下，我们可能需要将数组的数据类型进行转化，例如将整型数组转化为字符型数组或浮点型数组。

本文将介绍C语言中数组数据类型转化的方法。

1. 整型数组转化为字符型数组当我们需要将整型数组转化为字符型数组时，需要注意以下几点：（1）字符型数组中每个元素占据一个字节，而整型数组中每个元素占据4个字节（在32位系统中）或8个字节（在64位系统中）；（2）整型数组中的每个元素都是一个整数，其值的范围可能比字符型数组中每个元素的范围大；（3）字符型数组中的每个元素应该是字符，而不是ASCII码或整数。

因此，我们需要使用强制类型转换来将整型数组转化为字符型数组，代码示例如下：int int_arr[10] = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 }; char char_arr[10];for (int i = 0; i < 10; i++){char_arr[i] = (char)int_arr[i];}printf('%s', char_arr);输出结果为：ABCDEFGHIJ2. 整型数组转化为浮点型数组当我们需要将整型数组转化为浮点型数组时，需要注意以下几点：（1）浮点型数组中每个元素占据4个字节或8个字节，而整型数组中每个元素占据4个字节或8个字节；（2）整型数组中的每个元素都是一个整数，其值的范围可能比浮点型数组中每个元素的范围小；（3）浮点型数组中的每个元素应该是浮点数，而不是整数。

因此，我们需要使用强制类型转换来将整型数组转化为浮点型数组，代码示例如下：int int_arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };float float_arr[10];for (int i = 0; i < 10; i++){float_arr[i] = (float)int_arr[i];}for (int i = 0; i < 10; i++){printf('%f ', float_arr[i]);}输出结果为：1.0000002.0000003.0000004.0000005.0000006.0000007.0000008.0000009.000000 10.0000003. 浮点型数组转化为整型数组当我们需要将浮点型数组转化为整型数组时，需要注意以下几点：（1）浮点型数组中每个元素占据4个字节或8个字节，而整型数组中每个元素占据4个字节或8个字节；（2）浮点型数组中的每个元素都是一个浮点数，其值的范围可能比整型数组中每个元素的范围大或小；（3）整型数组中的每个元素应该是整数，而不是浮点数。

CString,string 与Char 的转换

CString,string 与Char 的转换2007-05-17 21:41//******************************************************************* **01.CString to char pointer//******************************************************************* ***CString mystring = "abcde";char *szmystring = (char *)(LPCTSTR)mystring ;char *pBuffer =new char[1024];CString strBuf = "test";pBuffer = strBuf.GetBuffer(sizeof(pBuffer));&pBuffer=strBuf.GetBuffer(strBuf.GetLength);//*************************************************************02.char pointer to CString//******************************************************************* char *mystring = "12345";CString string = mystring;string.Format("%s",mystring)//******************************************************************03.string CString以及char*//****************************************************************** string是方便的，可以从几乎所有的字符串构造而来，包括CString和char*；CString次之，可以从基本的一些字符串变量构造而来，包括char*等；char*没有构造函数，仅可以赋值；举例：char* psz = “joise”;string str( cstr );string是最方便的，几乎可以直接用所有的字符串赋值，包括CString和char*；CString次之，可以直接用些基本的字符串赋值，包括char*等；char*只能由指针赋值，并且是极危险的操作，建议使用strcpy或者memcpy，而且char*在声明的时候如未赋初值建议先设为NULL，以避免野指针，令你抓狂；举例：char *psz = NULL;psz = new char[10]; //当然，以上的直接写成char *psz = new char[10];也是一样memset( psz, 0, 10 );strcpy( psz, “joise” );CString cstr;cstr = psz;string str;str = psz;str = cstr;delete []psz;string与CString差不多，可以直接与char*进行加法，但不可以相互使用+运算符，即string str = str + cstr是非法的，须转换成char*；char*没有+运算，只能使用strcat把两个指针连在一起；举例：char* psz = “joise”;CString cstr = psz;string str = psz;str = str + str + psz;strcat( psz, psz );strcat( psz, cstr );//合法strcat( psz, str );//非法，由此可见，CString可自动转换为const char*，而string不行//****************************************************************** ************************************//不明白的继续：//****************************************************************** ***********************************CString与char*的转换CString与char*的转换参见如下代码：1 int i=m_edit1.GetLength();2 char* p;3 CString hex4="\0";4 CString hex5="\0";5 m_edit3.SetSel(0,-1);6 m_edit3.ReplaceSel("");7 p=m_edit1.GetBuffer(i);8 for(int j=0;j<i;j++) {9 hex5.Format("%x ",(unsigned char)*p++);10 hex4+=hex5;11 }12 m_edit3.ReplaceSel(hex4);其中m_edit3是一个CEdit类型的变量，SetSel，ReplaceSel都是其成员函数，可以参见MSDN。

C语言数据类型转换（自动类型转换强制类型转换）

C语言数据类型转换（自动类型转换强制类型转换）数据类型转换就是将数据（变量、数值、表达式的结果等）从一种类型转换为另一种类型。

自动类型转换自动类型转换就是编译器默默地、隐式地、偷偷地进行的数据类型转换，这种转换不需要程序员干预，会自动发生。

1) 将一种类型的数据赋值给另外一种类型的变量时就会发生自动类型转换，例如：float f = 100;100 是 int 类型的数据，需要先转换为 float 类型才能赋值给变量f。

再如：int n = f;f 是 float 类型的数据，需要先转换为 int 类型才能赋值给变量 n。

在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型转换为左边变量的类型，这可能会导致数据失真，或者精度降低；所以说，自动类型转换并不一定是安全的。

对于不安全的类型转换，编译器一般会给出警告。

2) 在不同类型的混合运算中，编译器也会自动地转换数据类型，将参与运算的所有数据先转换为同一种类型，然后再进行计算。

转换的规则如下：•转换按数据长度增加的方向进行，以保证数值不失真，或者精度不降低。

例如，int 和long 参与运算时，先把int 类型的数据转成long 类型后再进行运算。

•所有的浮点运算都是以双精度进行的，即使运算中只有 float 类型，也要先转换为 double 类型，才能进行运算。

•char 和 short 参与运算时，必须先转换成 int 类型。

下图对这种转换规则进行了更加形象地描述：unsigned 也即 unsigned int，此时可以省略 int，只写 unsigned。

自动类型转换示例：复制纯文本复制1.#include<stdio.h>2.int main(){3.float PI = 3.14159;4.int s1, r = 5;5.double s2;6.s1 = r * r * PI;7.s2 = r * r * PI;8.printf('s1=%d, s2=%f\n', s1, s2);9.10.return 0;11.}#include<stdio.h> int main(){ float PI = 3.14159; int s1, r = 5; double s2; s1 = r * r * PI; s2 = r * r * PI; printf('s1=%d, s2=%f\n', s1, s2); return 0; }运行结果：s1=78, s2=78.539749在计算表达式r*r*PI时，r 和 PI 都被转换成 double 类型，表达式的结果也是 double 类型。

c中char与string之间的相互转换问题

c中char与string之间的相互转换问题第⼀部分：将 char * 或者 char [] 转换为 string可以直接赋值，转换。

第⼆部分：将 string 转换为 char * 或者 char []string 是c++标准库⾥⾯其中⼀个，封装了对字符串的操作把string转换为char* 有 3种⽅法：1. 调⽤ string 的 data 函数如：string str='abc';char *p=str.data();2.调⽤ string 的 c_str 函数如：string str='gdfd';char *p=str.c_str();3 调⽤ string 的 copy 函数⽐如string str='hello';char p[40];str.copy(p,5,0); //这⾥5，代表复制⼏个字符，0代表复制的位置*(p+5)='/0'; //要⼿动加上结束符cout < <p;语法: const char *c_str();c_str()函数返回⼀个指向正规C字符串的指针, 内容与本string串相同. 这是为了与c语⾔兼容，在c语⾔中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。

注意：⼀定要使⽤strcpy()函数等来操作⽅法c_str()返回的指针⽐如：最好不要这样: char* c; string s='1234'; c = s.c_str(); //c最后指向的内容是垃圾，因为s对象被析构，其内容被处理应该这样⽤：char c[20]; string s='1234'; strcpy(c,s.c_str()); 这样才不会出错，c_str()返回的是⼀个临时指针，不能对其进⾏操作再举个例⼦c_str() 以 char*形式传回 string 内含字符串如果⼀个函数要求char*参数，可以使⽤c_str()⽅法： string s = 'Hello World!';printf('%s', s.c_str()); //输出 'Hello World!'1、如果要将string转换为char*，可以使⽤string提供的函数c_str() ，或是函数data()，data除了返回字符串内容外，不附加结束符'\0'，⽽c_str()返回⼀个以‘\0’结尾的字符数组。

CString.Format的详细用法(转)

double num=1.46;
//str="1.46"
str.Format(_T("%lf"),num);
//str="1.5"(.1表示小数点后留1位，小数点后超过1位则四舍五入)
str.Format(_T("%.1lf"),num);
//str="1.4600"
先看看Format用于转换的格式字符：
%c 单个字符
%d 十进制整数(int)
%ld 十进制整数(long)
%f 十进制浮点数(float)
CString str;
int num=255;
//str="377"
str.Format(_T("%o"),num);
//str="00000377"
str.Format(_T("%.8o"),num);
Format是一个很常用，却又似乎很烦的方法，以下是它的完整概貌，以供大家查询之用：
格式化字符串forma("%d",12)意思是将一个整形的格式化的字符(我认为是保持其形状不变)
1).格式说明总是以%字符开始,以下是不同类型数据的格式方式%号后的说明:
d输出带符号十进制数
o输出无符号八进制数
x输出无符号十六进制数
u输出无符号数
c输出单个字符
s输出01234]
对于字符型，刚好和整型值相反，如果prec比字符串型的长度大
则没有效果，反之比字符串型的长度小，则会截断尾部的字符
Format('this is %.2s',['1234']);

VC++中数据类型转换大全

vc数据类型转换大全(转载)int i = 100;long l = 2001;float f=300.2;double d=12345.119;char username[]=”程佩君”;char temp[200];char *buf;CString str;_variant_t v1;_bstr_t v2;一、其它数据类型转换为字符串短整型(int)itoa(i,temp,10);///将i转换为字符串放入temp中,最后一个数字表示十进制itoa(i,temp,2); ///按二进制方式转换长整型(long)ltoa(l,temp,10);浮点数(float,double)用fcvt可以完成转换,这是MSDN中的例子:int decimal, sign;char *buffer;double source = 3.1415926535;buffer = _fcvt( source, 7, &decimal, &sign );运行结果:source: 3.1415926535 buffer: ‘31415927′ decimal: 1 sign: 0decimal表示小数点的位置,sign表示符号:0为正数，1为负数CString变量str = “2008北京奥运”;buf = (LPSTR)(LPCTSTR)str; //这个因为buf是个char*变量先把CString 变量转换为const char*类型的再变为char*类型的上面的CString转换为char*型号的必须经过两次反之的直接赋值就可以BSTR变量BSTR bstrValue = ::SysAllocStri ng(L”程序员”);char * buf = _com_util::ConvertBSTRToString(bstrValue); SysFreeString(bstrValue);一定注意凡是定义的指针变量一定要用delete显示删除AfxMessageBox(buf);delete(buf);CComBSTR变量CComBSTR bstrVar(”test”);char *buf = _com_util::ConvertBSTRToString(bstrVar.m_str); AfxMessageBox(buf);delete(buf);_bstr_t变量_bstr_t类型是对BSTR的封装，因为已经重载了=操作符，所以很容易使用_bstr_t bstrVar(”test”);const char *buf = bstrVar;///不要修改buf中的内容_bstr_t实际上是个字符指针型的AfxMessageBox(buf);通用方法(针对非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);二、字符串转换为其它数据类型strcpy(temp,”123″);短整型(int)i = atoi(temp);长整型(long)l = atol(temp);浮点(double)d = atof(temp);CString变量CString name = temp;BSTR变量BSTR bstrValue = ::SysAllocString(L”程序员”);…///完成对bstrValue的使用SysFreeString(bstrValue);CComBSTR变量CComBSTR类型变量可以直接赋值CComBSTR bstrVar1(”test”);CComBSTR bstrVar2(temp);_bstr_t变量_bstr_t类型的变量可以直接赋值_bstr_t bstrVar1(”test”);_bstr_t bstrVar2(temp);三、其它数据类型转换到CString使用CString的成员函数Format来转换,例如:整数(int)str.Format(”%d”,i);浮点数(float)str.Format(”%f”,i);字符串指针(char*)等已经被CString构造函数支持的数据类型可以直接赋值str = username;对于Format所不支持的数据类型，可以通过上面所说的关于其它数据类型转化到char*的方法先转到char *，然后赋值给CString变量。

C语言数据类型转换

C语言数据类型转换C语言数据类型转换数据类型转换就是将数据(变量、表达式的结果)从一种类型转换到另一种类型。

那么大家知道C语言数据类型转换是怎样的呢?下面一起来看看!例如，为了保存小数你可以将int类型的变量转换为double类型。

数据类型转换的一般格式为：(type_name) expressiontype_name为要转换到的数据类型，expression为表达式。

例如：(float) a; //把a转换为实型(int)(x+y); //把x+y的结果转换为整型(float) 100; //将一个常量转换为实型【示例】将整数转换为浮点数：#include int main(){ int sum = 17, count = 5; double mean; mean = (double) sum / count; printf("Value of mean : %f ", mean); return 0;}运行结果：Value of mean : 3.400000需要注意的是，类型转换运算符( )的优先级高于/，(double) sum / count会先将 sum 转换为 double 类型，然后再进行除法运算。

如果写作(double) (sum / count)，那么运行结果就是 3.000000。

这种由程序员显式进行的转换称为强制类型转换。

除了强制类型转换，在不同数据类型的混合运算中编译器也会隐式地进行数据类型转换，称为自动类型转换。

自动类型转换遵循下面的规则：若参与运算的数据类型不同，则先转换成同一类型，然后进行运算。

转换按数据长度增加的方向进行，以保证精度不降低。

例如int型和long型运算时，先把int量转成long型后再进行运算。

所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。

char型和short型参与运算时，必须先转换成int型。

c语言数据类型转换规则

c语言数据类型转换规则C语言中的数据类型转换主要有两种：隐式转换和显式转换。

1. 隐式转换：隐式转换也称为自动类型转换，是指在运算过程中由编译器自动进行的数据类型转换。

隐式转换的规则如下：- 当两个操作数中一个为浮点型，另一个为整型，将整型转换为浮点型。

- 当两个操作数类型不同时，将较小类型转换为较大类型，例如将int类型转换为float类型。

- 当一个操作数为有符号类型，另一个操作数为无符号类型时，将有符号类型转换为无符号类型。

- 当两个操作数为不同的有符号类型，并且其中一个为有符号整型类型，另一个为无符号整型类型，将有符号整型类型转换为无符号整型类型。

例如，下面是一些隐式转换的例子：```cint a = 10;float b = 2.5;float c = a + b; // 将整型a转换为浮点型int d = a + b; // 将浮点型b转换为整型unsigned int e = -5; // 将有符号整型转换为无符号整型```2. 显式转换：显式转换也称为强制类型转换，是通过强制改变数据的类型进行的转换。

在需要进行显式转换时，可以使用类型转换运算符进行转换。

类型转换运算符有以下几种形式：- (type) expression：将表达式expression转换为type类型。

- type (expression)：将表达式expression转换为type类型。

类型转换运算符的规则如下：- 当将浮点型转换为整型时，进行截断操作，即舍去小数部分。

- 当将整型转换为浮点型时，进行扩展，添加0作为小数部分。

- 当将整型或浮点型转换为字符型时，只保留最低字节的内容。

例如，下面是一些显式转换的例子：```cint a = 10;float b = 2.5;int c = (int)b; // 将浮点型b转换为整型float d = (float)a; // 将整型a转换为浮点型char e = (char)a; // 将整型a转换为字符型```需要注意的是，在进行显式转换时，可能会导致数据精度的丢失或溢出，因此在进行类型转换时要慎重，确保转换的结果符合预期。