vc数据类型详解
C语言-基本数据类型、常量和变量
（2）八进制整数 以数字0打头，后跟0～7组成的数字串。例如： 0123表示八进制常数123，相当于十进制数83。 八进制整数可以加上后缀u(U)，l(L)或ul(UL)分别构成八进制 的无符号数、长整数或无符号长整数。例如： 012345u、02765543102l、0345675026ul等。 （3）十六进制整数 以数字0和小写字母x（或大写字母X）打头，后跟0～9及A～ F（或a～f）组成的数字字母串。其中，A～F（或a～f）分别表示 十进制的10～15。例如： 0x2f是一个十六进制，相当于十进制的47。 若在十六进制数后面加上后缀u（U）、l（L）或ul（UL）， 则分别构成十六进制的无符号数、长整数或无符号长整数。如： 0x89ad476bu, 0x9043fecd2l, 0x98bfd5ca7ul
三个属性： ① 变量分为不同的数据类型，数据类型决定了该变量存储
的数据的含义。
② 变量分为不同的存储类型，存储类型决定了变量在计算 机中的存储位置及其寿命(生命期)。
③ 变量在程序中的定义位置决定了该变量的作用域，即起
作用的范围。
1. 变量的定义
C语言规定，变量必须先定义后使用，变量的数据类型与变 量名本身无关。 变量定义一是定义变量的数据类型，二是定义变量的名称， 三是说明变量的存储类型，其一般格式为： [存储类型] 数据类型 变量清单; char ch1; static int i, j, k; short int si; float f1, f2; double balance, profit, loss; 变量的数据类型可以是字符型、整型、浮点型、双精度型等。
signed int
signed long
unsigned int
unsigned long
VC++中BYTE类型
VC++中BYTE类型byte是0～255直接的一个数字。
一般都是用byte数组。
byte 类型是一个字节的数据，这个类型有以下几个应用场合：1、最常用的一个场景，就是处理二进制数据流，比如说从某个文件读取一段，我们在读取的时候并不关心这个文件到底是什么格式，只需要关心我需要从哪里开始的多长的一段。
然后我们可以一个字节一个字节去分析这个文件的某部分。
或者我们用来获取网络上传递的信息，或者用来承载串行口传过来的数据等等。
2、最简单的一个场景，就是处理一个字节的数据。
对于来说，一个Char的长度不是一个字节，也不是两个字节，而仅仅是用来表示一个字符得很抽象的类——其实是两个字节，我这么说有我的理由的：比如说字符'A '，如果我们用AscII方式去理解，或者说转换成用AscII编码储存的二进制数据，那就是一个字节；如果用Unicode方式，那么就是两个字节。
也就是说现在不能像VB6那样，用Char来存储一个字节的数据（首先某些二进制值是非法字符，存不进去，其次就算存进去了，也很可能会浪费50%的空间，就算做得很好也不太可能有100%的利用率），你也不要企望一个Char他就一定是代表一个字节的内容。
所以现在我们用Byte来处理一个字节大小的数据。
3、如果你有很多很多的标志位，就是那种只要表示“是或否”的数据，如果你用Boolean就非常不合算，因为Boolean占用4个字节，而Byte只占用一个。
比如你有1百万个这样的标志，那么用Boolean要花费4MB，而用Byte只要1MB。
当然，为建议你最好不要用Byte 来作为标志使用，原因你自己慢慢体会。
现在的内存够大，没必要为了省这么3MB的空间而作出另外一些牺牲。
c语言 数据类型缩写及含义 表格
标题：深度解析C语言数据类型缩写及含义在计算机编程的世界中，数据类型是非常重要的概念。
在C语言中，数据类型的缩写及含义更是程序员们必须熟练掌握的知识点之一。
本文将深度解析C语言中常见的数据类型缩写及其含义，帮助读者更深入地理解这一重要主题。
1. 数据类型的概念在C语言中，数据类型用来声明变量的类型，指定变量可以存储的数据类型及所占用的内存大小。
C语言中的数据类型包括基本数据类型和派生数据类型。
基本数据类型包括整型、浮点型、字符型和空类型，而派生数据类型包括数组、指针、结构体和共用体等。
2. 基本数据类型2.1 int：整型在C语言中，int代表整型数据类型，通常用于声明整数变量。
int类型在不同的系统中所占用的内存大小可能会有所不同，但通常情况下，int类型占用4个字节的内存空间。
2.2 float：单精度浮点型float代表单精度浮点型数据类型，用于声明具有小数部分的变量。
float类型通常占用4个字节的内存空间，用于存储小数，精度约为6位有效数字。
2.3 double：双精度浮点型double代表双精度浮点型数据类型，用于声明双精度小数变量。
double类型通常占用8个字节的内存空间，精度约为15位有效数字。
2.4 char：字符类型char代表字符数据类型，用于存储单个字符的变量。
char类型通常占用1个字节的内存空间。
2.5 void：空类型void代表空类型，用于表示没有类型。
通常用于函数的返回值或指针的类型。
以上是C语言中常见的基本数据类型的缩写及含义。
掌握这些基本数据类型对于程序员来说非常重要，它们是构建任何C语言程序的基础。
3. 派生数据类型3.1 数组：一组相同数据类型的集合数组是C语言中一组相同数据类型的集合，可以存储固定大小的元素。
3.2 指针：存储变量位置区域的变量指针是C语言中非常重要的概念，它用来存储变量的内存位置区域。
指针可以指向任何数据类型的变量，它可以极大地提高程序的灵活性和效率。
VC 文件类型
.OBJ：由编译器或汇编工具生成的目标文件，是模块的二进制中间文件。
.ODL：用对象描述语言编写的源代码文件，VC用它来生成TLB文件。
.OLB：带有类型库资源的一种特殊的动态链接库，也叫对象库文件。
.OPT：VC开发环境自动生成的用来存放WorkSpace中各种选项的文件。工程关于开发环境的参数文件。如工具条位置信息等。
.EXP：由LIB工具从DEF文件生成的输出文件，其中包含了函数和数据项目的输出信息，LINK工具将使用EXP文件来创建动态链接库。只有在编译DLL时才会生成，记录了DLL文件中的一些信息。
.H、.HPP或.HXX：用C/C++语言编写的头文件，通常用来定义数据类型，声明变量、函数、结构和类。
.PLG：编译信息文件，编译时的error和warning信息文件。
.RC：资源定义文件。
.RC2：资源定义文件，供一些特殊情况下使用。
.REG：注册表信息文件。
.RES：二进制资源文件，资源编译器编译资源定义文件后即生成RES文件。
.RTF：Rich Text Format（丰富文本格式）文档，可由Word或写字板来创建，常被用来生成Help文件。
.INI：配置文件。
.LIB：库文件，LINK工具将使用它来连接各种输入库，以便最终生成EXE文件。
.LIC：用户许可证书文件，使用某些ActiveX控件时需要该文件。
.MAK：即MAKE文件，VC4及以前版本使用的工程文件，用来指定如何建立一个工程，VC6把MAK文件转换成DSP文件来处理。
.HLP：Windows帮助文件。
.HM：在Help工程中，该文件定义了帮助文件与对话框、菜单或其它资源之间ID值的对应关系。
vc常用数据及其转换
一、常用数据类型列表VC常用数据类型列表（1）VC常用数据类型列表（2）VC常用数据类型列表（3）同时，为了统一变量的命名，在Windows中，不同类型的变量拥有各自的标准前缀，一般情况如表所示。
不同数据类型的前缀前缀数据类型c 字符(char)s 短整数(short)cb 用于定义对象(一般为一个结构)尺寸的整数n 整数(integer)sz 以'\0'结尾的字符串b 字节f BOOLw 字(WORD，无符号短整数)l 长整数(LONG)h HANDLE(无符号整数)m_ 类成员变量fn 函数(function)dw 双字(DWORD,无符号长整数)二、数据类型转换：刚接触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）;二、从其它包含字符串的变量中获取指向该字符串的指针CString变量str = ＂2008北京奥运＂;buf = （LPSTR）（LPCTSTR）str;BSTR类型的_variant_t变量v1 = （_bstr_t）＂程序员＂;buf = _com_util::ConvertBSTRToString（（_bstr_t）v1）;三、字符串转换为其它数据类型strcpy（temp,＂123＂）;短整型（int）i = atoi（temp）;长整型（long）l = atol（temp）;浮点（double）d = atof（temp）;四、其它数据类型转换到CString使用CString的成员函数Format来转换,例如:整数（int）str.Format（＂%d＂,i）;浮点数（float）str.Format（＂%f＂,i）;字符串指针（char *）等已经被CString构造函数支持的数据类型可以直接赋值str = username;五、BSTR、_bstr_t与CComBSTRCComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。
C数据类型及其长度总结
C数据类型及其长度总结C语言中的数据类型及其长度如下：1.基本数据类型：- char类型：用于表示字符，长度为1字节（8位）。
- short类型：用于表示短整型数据，长度为2字节（16位）。
- int类型：用于表示整型数据，长度为4字节（32位）。
- long类型：用于表示长整型数据，长度为4字节（32位）或8字节（64位）。
- float类型：用于表示单精度浮点数，长度为4字节（32位）。
- double类型：用于表示双精度浮点数，长度为8字节（64位）。
2.修饰类型：- signed修饰符：用于将基本整数类型定义为有符号类型，不改变长度。
- unsigned修饰符：用于将基本整数类型定义为无符号类型，不改变长度。
- short修饰符：用于将int类型定义为short类型，长度为2字节（16位）。
- long修饰符：用于将int类型定义为long类型，长度为4字节（32位）或8字节（64位）。
3.变长数据类型（C99标准引入）：- bool类型：用于表示布尔值，长度为1字节（8位）。
- imaginary类型：用于表示虚数，长度与对应的复数类型相同。
4.其他数据类型：- enum类型：用于定义枚举类型，长度与int类型相同。
- void类型：用于表示无类型，长度为1字节（8位）。
- size_t类型：用于表示内存块的大小，长度根据处理器架构而定。
- ptrdiff_t类型：用于表示两个指针之间的差值，长度根据处理器架构而定。
需要注意的是，C语言中的数据类型的长度是根据机器架构和编译器的不同而有所变化的。
上述长度是一般情况下的长度，具体情况应根据实际环境而定。
总结起来，C语言中的数据类型及其长度包括基本数据类型、修饰类型、变长数据类型以及其他数据类型。
程序员在编写C语言程序时，需要根据需求选择合适的数据类型来保存和处理数据。
VC常用数据类型总结
VC常用数据类型总结VC（Visual C++）常用数据类型指的是在C++编程中经常使用的数据类型。
根据数据类型的特性和用途不同，VC常用数据类型可以分为以下几类：1. 基本数据类型（Primitive Data Types）：- 整型（Integer Type）：用于表示整数，包括有符号整数（signed）和无符号整数（unsigned），例如int、short、long、char等。
- 浮点型（Floating-Point Type）：用于表示带小数点的数值，包括单精度浮点型（float）和双精度浮点型（double）。
- 字符型（Character Type）：用于表示单个字符，例如char类型。
- 布尔型（Boolean Type）：用于表示真（true）或假（false），例如bool类型。
2. 高级数据类型（Advanced Data Types）：- 数组（Array）：用于存储多个相同类型的元素，例如int数组、char数组等。
- 结构体（Structure）：用于封装多个不同类型的变量，例如定义一个包含姓名、年龄等信息的Student结构体。
- 枚举（Enumeration）：用于定义一组相关的常量，例如定义星期几的枚举类型。
3. 指针（Pointer）：- 指针（Pointer）：保存变量的内存地址，可以通过指针间接访问变量的值，例如int*指针。
- 空指针（Null Pointer）：指向无效内存地址的指针，通常表示指针未初始化或指向不存在的对象。
- 空指针常量（Null Pointer Constant）：表示空指针的特殊值，通常用NULL或nullptr表示。
4. 自定义数据类型（User-Defined Data Types）：- 类（Class）：用于创建自定义的数据类型，包含数据成员和成员函数。
- 模板（Template）：用于创建通用的数据类型，支持不特定的数据类型参数，例如STL容器类（vector、list等）的模板类型。
VC++中BYTE类型
VC++中BYTE类型byte是0～255直接的一个数字。
一般都是用byte数组。
byte 类型是一个字节的数据，这个类型有以下几个应用场合：1、最常用的一个场景，就是处理二进制数据流，比如说从某个文件读取一段，我们在读取的时候并不关心这个文件到底是什么格式，只需要关心我需要从哪里开始的多长的一段。
然后我们可以一个字节一个字节去分析这个文件的某部分。
或者我们用来获取网络上传递的信息，或者用来承载串行口传过来的数据等等。
2、最简单的一个场景，就是处理一个字节的数据。
对于来说，一个Char的长度不是一个字节，也不是两个字节，而仅仅是用来表示一个字符得很抽象的类——其实是两个字节，我这么说有我的理由的：比如说字符'A '，如果我们用AscII方式去理解，或者说转换成用AscII编码储存的二进制数据，那就是一个字节；如果用Unicode方式，那么就是两个字节。
也就是说现在不能像VB6那样，用Char来存储一个字节的数据（首先某些二进制值是非法字符，存不进去，其次就算存进去了，也很可能会浪费50%的空间，就算做得很好也不太可能有100%的利用率），你也不要企望一个Char他就一定是代表一个字节的内容。
所以现在我们用Byte来处理一个字节大小的数据。
3、如果你有很多很多的标志位，就是那种只要表示“是或否”的数据，如果你用Boolean就非常不合算，因为Boolean占用4个字节，而Byte只占用一个。
比如你有1百万个这样的标志，那么用Boolean要花费4MB，而用Byte只要1MB。
当然，为建议你最好不要用Byte 来作为标志使用，原因你自己慢慢体会。
现在的内存够大，没必要为了省这么3MB的空间而作出另外一些牺牲。
VC和VB数据类型比较
APIPlatform SDK: COMTranslating to Visual Basic from C++Using the C++ programming language, developers can directly access the memory that stor es a particular variable. Memory pointers provide this direct access. In Visual Basic, pointers are handled for you. For example, a parameter declared as a pointer to an int in C++ is equivalent to a parameter declared in Visual Basic as a ByRef Integer.A parameter that is declared As String in Visual Basic is declared as a pointer to a BSTR i n C++. Setting a string pointer to NULL in C++ is equivalent to setting the string to the vb NullString constant in Visual Basic. Passing in a zero-length string ("") to a function design ed to receive NULL does not work, as this passes a pointer to a zero-length string instead o f a zero pointer.C++ supports data containers, namely structures and unions, that have no equivalent in Vis ual Basic. For this reason, COM objects typically wrap information that usually is stored in st ructures and unions in object classes. Some COM objects, however, may contain structures, causing portions of the object's methods or functionality to be inaccessible to Visual Basic.NoteFuture versions of Visual Basic, version 6.0 and beyond, will support structures.Some C++ data types are not supported in Visual Basic, for example unsigned types and HWND types. Methods that accept or return these data types are not available in Visual Ba sic.Visual Basic uses Automation-compatible data types as its internal data types. Thus, C++ da ta types that are Automation-compatible are also compatible with Visual Basic. Data types t hat are not Automation-compatible may not be able to be converted to Visual Basic. For mo re information about Automation data types, see the Automation documentation in the Platfo rm SDK.The following table lists the data types are supported by Visual Basic and their VARTYPE e quivalents. VARTYPE is an enumeration that lists the Automation variant types.Visual Basic data type VARTYPE equivalentInteger16 bit, signed, VT_I2Long32 bit, signed, VT_I4Date VT_DATECurrency VT_CYObject*VT_DISPATCHString VT_BSTRBoolean VT_BOOLCurrency VT_DECIMALSingle VT_R4Double VT_R8Decimal VT_DECIMALByte VT_DECIMALVariant VT_VARIANTAll parameters in Visual Basic, unless labeled with the keyword ByVal, are passed by refere nce (as pointers) instead of by value.C++ and Visual Basic differ slightly in how they represent properties. In C++, properties ar e represented as a set of accessor functions, one that sets the property value and one that retrieves the property value. In Visual Basic, properties are represented as a single item tha t can be used to retrieve or set the property value.VC与VB数据类型对应关系VB调用C DLL时的参数传递函数在C中的原型，参数类型和传递方式对应关系C DLL 原型VB声明VB调用USHORT a ByVal a as long Call func(…,a,…)int a ByVal a as long Call func(…,a,…)long a ByRef a as long Call func(…,byval a,…)int *pa ByRef pa as lon g Call func(…,pa,…)long *pa ByVal pa as long Call func(…,varptr(pa),…) <---------(1)LPSTR lpStr ByVal lpStr as string Call func(…,lpStr,…)char *pstr ByVal pstr as string Call func(…,pstr,…) <---------(2)wchar *pstr ByRef pstr as string Call func(…,byval pstr,…)struct tagX *p ByRef p as tagX Call func(…,ptag,…) <---------(3)HANDLE h ByVal h as long Call func(…,h,…) <---------(4)备注1)不推荐使用此方式2)如果DLL要求一个字符串缓冲区，一定要在调用前初始化字串，即dim t as string * 503)用户定义子类型必须用ByRef方式传递，4)任何内核对象的句柄(process, thread, module, file, filemapping, semaphore等)和大多数GDI对象的句柄都能用此方式传递。
C语言数据类型及表示范围
C语言各种数据类型在系统中占的字节和取值范围基本类型包括字节型（char）、整型（int）和浮点型（float/double）。
定义基本类型变量时，可以使用符号属性signed、unsigned（对于char、int），和长度属性short、long（对于int、double）对变量的取值区间和精度进行说明。
下面列举了Dev-C++下基本类型所占位数和取值范围：符号属性长度属性基本型所占位数取值范围输入符举例输出符举例-- -- char 8 -2^7 ~ 2^7-1 %c %c、%d、%u signed -- char 8 -2^7 ~ 2^7-1 %c %c、%d、%u unsigned -- char 8 0 ~ 2^8-1 %c %c、%d、%u [signed] short [int] 16 -2^15 ~ 2^15-1 %hdunsigned short [int] 16 0 ~ 2^16-1 %hu、%ho、%hx [signed] -- int 32 -2^31 ~ 2^31-1 %dunsigned -- [int] 32 0 ~ 2^32-1 %u、%o、%x[signed] long [int] 32 -2^31 ~ 2^31-1 %ldunsigned long [int] 32 0 ~ 2^32-1 %lu、%lo、%lx [signed] long long [int] 64 -2^63 ~ 2^63-1 %I64dunsigned long long [int] 64 0 ~ 2^64-1 %I64u、%I64o、%I64x -- -- float 32 +/- 3.40282e+038 %f、%e、%g-- -- double 64 +/- 1.79769e+308 %lf、%le、%lg %f、%e、%g -- long double 96 +/- 1.79769e+308 %Lf、%Le、%Lg几点说明：1. 注意! 表中的每一行，代表一种基本类型。
c语言基本数据类型的取值范围
c语言基本数据类型的取值范围C语言是一种广泛应用于系统编程和应用程序开发的高级编程语言，其基本数据类型包括整型、浮点型和字符型等。
这些数据类型在程序设计和数据处理中起着至关重要的作用，而它们的取值范围则是我们在编程过程中必须要了解的基础知识。
在C语言中，整型数据类型包括int、short、long和long long等，它们分别占用不同长度的内存空间，因此其取值范围也存在差异。
接下来，我们将逐一介绍这些基本数据类型的取值范围，并探讨其在程序设计中的应用。
1. int类型int类型通常占用4个字节的内存空间，其取值范围为-2147483648至2147483647。
在实际编程中，int类型通常用于表示整数型数据，如计数器、数组下标等。
2. short类型short类型通常占用2个字节的内存空间，其取值范围为-32768至32767。
在某些情况下，我们可能会选择short类型来节省内存空间，尤其是在处理大规模数据时。
3. long类型long类型通常占用4个字节或8个字节的内存空间，其取值范围为-2147483648至2147483647（4个字节）或-9223372036854775808至9223372036854775807（8个字节）。
在处理较大数值时，我们通常会选择long类型来确保数据精度和范围的要求。
4. long long类型long long类型通常占用8个字节的内存空间，其取值范围为-9223372036854775808至9223372036854775807。
在需要处理超出int或long范围的极大数值时，我们可以选择long long类型来满足程序的需求。
除了整型数据类型外，C语言还提供了浮点型数据类型，包括float、double和long double等。
这些数据类型用于表示实数型数据，其取值范围和精度也是我们需要了解的重要知识。
1. float类型float类型通常占用4个字节的内存空间，其取值范围为1.2E-38至3.4E38，精度为6位小数。
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语言各种数据类型的大小和范围，以便读者能够更加深入地了解这些数据类型的特性。
让我们从最基本的数据类型开始，即整型。
在 C 语言中，整型数据类型有 char、short、int 和 long 这几种。
其中，char 类型通常占用 1 个字节，其范围是 -128 到 127 或者 0 到 255，取决于是否使用有符号符号。
short 类型一般占用2 个字节，其范围是 -32768 到 32767。
int 类型的大小是由具体的编译器决定的，但通常情况下占用 4 个字节，范围是 -2147483648 到 2147483647。
而 long 类型通常占用 4 个字节或者 8 个字节，其范围是 -2147483648 到 2147483647 或者 -9223372036854775808 到 9223372036854775807。
接下来，让我们来看看浮点型数据类型。
在 C 语言中，浮点型数据类型有 float、double 和 long double 这几种。
其中，float 类型通常占用 4 个字节，范围是±3.4E-38 到±3.4E38，精度为 6 位小数。
double 类型通常占用 8 个字节，范围是±1.7E-308 到±1.7E308，精度为 15 位小数。
而 long double 类型的大小是由具体的编译器决定的，其范围和精度也会相应地改变。
C 语言还包含了一些特殊的数据类型，比如枚举类型和 void 类型。
枚举类型是通过 enum 关键字定义的，它可以为一系列常量赋予有意义的名字，而不是简单的整数值。
而 void 类型是一种特殊的类型，它表示没有值。
通常情况下，void 类型仅用于函数的返回类型或者指针类型。
VC C 的类举例详解
bool isLeapYear(Date d) {
return (d.year % 4==0 && d.year % 100!=0)||(d.year % 400==0)； }
结构类型的定义还是存在局限性，它只定义了一组不同类型数据 的集合，而没有定义相关操作，如赋值、输出等。特别是在一个程序 员接手另一个程序员工作的时候，这种对结构的理解和编写相关操作 的负担加重了。
class Date {
int year，month，day； public：
void set（int y，int m，int d） {
year=y；month=m；day=d； }//；赋值操作，默认内联 bool isLeapYear（）； void print（）； };
// 判断闰年 // 输出日期
4、给结构变量的赋值就是给各成员赋值。可用输入语句或赋值
语句来完成。
例题：日期结构
#include<iostream> #include<iomanip> using namespace std；
struct Date {
int year； int month； int day； }；
void print(Date)； bool isLeapYear(Date d)；
2）在定义结构类型的同时说明结构变量。例如： struct Stu {
char name[20]； char sex； int age； float score； }boy1，boy2；
c语言常用数据类型以及运算符
c语言常用数据类型以及运算符C语言是一种广泛应用于系统开发、嵌入式系统和科学计算等领域的编程语言。
在C语言中，常用的数据类型有整型、浮点型、字符型和指针类型等，而运算符则包括算术运算符、关系运算符、逻辑运算符和位运算符等。
一、常用数据类型1. 整型：整型数据类型用于表示整数，包括int、short和long等。
其中，int类型通常占用4个字节，short类型占用2个字节，long 类型占用4或8个字节，具体取决于编译器和操作系统。
2. 浮点型：浮点型数据类型用于表示带有小数部分的数值，包括float和double等。
其中，float类型占用4个字节，double类型占用8个字节，double类型的精度更高。
3. 字符型：字符型数据类型用于表示单个字符，包括char类型。
char类型占用1个字节，可以表示ASCII码中的字符。
4. 指针型：指针型数据类型用于表示内存地址，包括int*、float*和char*等。
指针类型的大小通常是4个字节或8个字节，具体取决于操作系统和编译器。
二、运算符1. 算术运算符：算术运算符用于进行基本的数学运算，包括加法（+）、减法（-）、乘法（*）、除法（/）和取余（%）等。
这些运算符可以用于整型和浮点型数据。
2. 关系运算符：关系运算符用于比较两个操作数的大小关系，包括大于（>）、小于（<）、等于（==）、不等于（!=）、大于等于（>=）和小于等于（<=）等。
这些运算符的结果为真（非零）或假（零）。
3. 逻辑运算符：逻辑运算符用于对多个条件进行组合判断，包括与（&&）、或（||）和非（!）等。
这些运算符的结果为真（非零）或假（零）。
4. 位运算符：位运算符用于对二进制数进行位操作，包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）和右移（>>）等。
这些运算符可以用于整型数据。
c语言不同数据类型间的混合运算转换规则+常见数据类型
c语言不同数据类型间的混合运算转换规则+常见数据类型【C语言中不同数据类型间的混合运算转换规则+常见数据类型】在C语言中，数据类型是一种非常重要的概念。
在编写程序时，我们经常会涉及到不同类型数据的运算和转换。
本文将探讨C语言中不同数据类型间的混合运算转换规则，以及介绍常见的数据类型。
一、常见的数据类型1. 整型在C语言中，整型数据类型用于存储整数。
常见的整型数据类型包括int、short、long和long long。
这些数据类型在内存中占据的空间大小有所不同。
2. 浮点型浮点型数据类型用于存储带有小数点的数值。
常见的浮点型数据类型包括float、double和long double。
这些数据类型可以用来表示不同精度的浮点数。
3. 字符型字符型数据类型用于存储单个字符。
在C语言中，字符型数据类型用char表示。
4. 其他类型除了上述三种常见的数据类型之外，C语言还有一些其他类型，比如指针类型、数组类型、结构体类型等。
二、混合运算转换规则在C语言中，当不同类型的数据进行混合运算时，会涉及到数据类型的转换规则。
一般来说，C语言中的数据类型转换可以分为隐式转换和显式转换两种方式。
1. 隐式转换在C语言中，当不同类型的数据进行运算时，编译器会自动进行类型转换。
这种转换方式称为隐式转换。
隐式转换一般遵循以下规则：a. 如果参与运算的两个数据类型不同，系统会自动将宽度小的数据类型转换为宽度大的数据类型。
b. 如果参与运算的数据类型包括有符号数据类型和无符号数据类型，系统会自动将有符号数据类型转换为无符号数据类型。
c. 如果参与运算的数据类型包括整型和浮点型，系统会自动将整型转换为浮点型。
2. 显式转换除了隐式转换之外，C语言还支持显式转换。
在显式转换中，程序员可以通过强制类型转换的方式来改变数据类型。
在C语言中，使用强制类型转换可以通过类型名将需要转换的数据括在括号中，例如（int）x。
三、个人观点和理解在实际编程中，了解不同数据类型的转换规则是非常重要的。
vc数据类型转换（Vcdatatypeconversion）
vc++数据类型转换（Vc++ data type conversion）It (2009-07-23 15:59:46) tags used in VC++: Category: ProgrammingString conversion1.CString transforms into plastic IntCString str=_T ("12345");ATOI ((LPCSTR) STR); / / LPCSTR const char* can be transformed intoCString str= "1"";Int n=atoi (str.GetBuffer (0));2. transfer a CString to an array of char (char*)Char buffer[128]CString str;A.//strcpy methodStrcpy (buffer, str.GetBuffer ());Str.ReleaseBuffer ();B.// forced conversion methodBuffer= (LPTSTR) (LPCTSTR) str;C.//sprintf methodSprintf (buffer,%s, STR);D.CString str;Int, nLength=str.GetLength ();Char * sz=new char[nLength];Sz=str.GetBuffer (0);(LPCSTR) CStringE. can be converted to char* by type forcing, such as CString: CString cStr = "Hello, world"!";Char* zStr = (char*) (LPCTSTR) cStr;3.int turn CStringCString string;Int iValue=100;String.Format (_T ("%d"), iValue);MessageBox (string);The value of "string" is "100""4.char * turn CStringA.Char sz[128];CString str;Str.Format ("%s", SZ);B.CString.format ("%s", char*);CString strtest;Char * charpoint;Charpoint= "give string a value"";Strtest=charpoint; / / direct payment valueC.The char* type can be given directly to the CString and complete automatic conversion, for example:Char* zStr = "Hello, world"!";CString cStr = zStr;5.Float turn CStringFloat f=0.0;CString str;Str.Format ("%f", f);6.CString turn FloatCString str= "0"";Float f=atof (str.GetBuffer (0));7.string turn CStringCString.format ("%s", string.c_str ()); Using c_str () is really better than data () 8.char* turn int#include <stdlib.h>Int ATOI (const, char, *nptr);Long Atol (const, char, *nptr);Long, long, Atoll (const, char, *nptr);Long, long, atoq (const, char, *nptr);9.CString turn stringString s (CString.GetBuffer ());GetBuffer () must be ReleaseBuffer (), otherwise there is no space for the buffer to be released10.int turn char *There is a function Itoa () in stdlib.hThe use of itoa:Itoa (I, num, 10);I needs to convert characters into numbersSave character variables after num conversion10 conversion of the number of base (hexadecimal) 10, that is, in accordance with the 10 hexadecimal conversion numbers. Can also be 2, 8, 16, etc., you like the hexadecimal typeChar *itoa (int, value, char*, string, int, Radix);Example：#include "stdlib.h""#include "stdio.h"" (main){Int i=1234;Char s[5];Itoa (I, s, 10);Printf ("%s", s);Getchar ();}11.string turn char * Char *p = string.c_str (); String AA ("AAA");Char, *c=aa.c_str (); String mngName;Char t[200];Memset (T, 0200);Strcpy (T, mngName.)c _ str ());12、cstring to lpcstr将cstring转换成lpcstr, 需要获得cstring的长度, 例如: cstring cstr _ t = ("hello, world!") ;int nlen = cstr.getlength ();lpcstr lpszbuf = cstr.getbuffer (nlen);13、cstring to lpstr这个和第3个技巧是一样的, 例如:cstring cstr _ t = ("hello, world!") ;int nlen = str.getlength ();lpstr lpszbuf = str.getbuffer (nlen);14、char [] to int将字符串类型转换成整数型, 可以使用atoi函数, 例如:char c [10].int n;n = atoi (c);15、char [] to float和第5个技巧一样, 使用atof () 函数可以转换成float型, 例如: char c [10].float f;f = atof (c);16、char * to intchar * str = "100".int i;the = atoi (str).一、其它数据类型转换为字符串短整型 (int)itoa (s, s, 0); / / / 将i转换为字符串放入temp中, 最后一个数字表示十进制itoa (s, s, 2); / / / 按二进制方式转换长整型 (long)ltoa (l, s, 10);二、从其它包含字符串的变量中获取指向该字符串的指针cstring变量str = "2008北京奥运";buf = (lpstr) (lpctstr) str;bstr类型的 _ alternate _ t变量v1 = (_ bstr _ t) "程序员";buf = _ com _ util: convertbstrtostring (_ bstr _ t) v1.三、字符串转换为其它数据类型strcpy (temp, "123");短整型 (int)the = atoi (temp).长整型 (long)l = atol (temp).浮点 (double)d = atof (temp).四、其它数据类型转换到cstring使用cstring的成员函数format来转换, 例如:整数 (int)str.format ("% d").浮点数 (float)str.format ("% f").字符串指针 (char *) 等已经被cstring构造函数支持的数据类型可以直接赋值str = username.五、bstr、 _ bstr _ t与ccombstrccombstr、 _ bstr _ t是对bstr的封装, bstr是指向字符串的32位指针.char * 转换到bstr可以这样: bstr b = _ com _ util: convertstringtobstr ("数据"); / / / 使用前需要加上头文件comutil.h反之可以使用char * p = _ com _ util: convertbstrtostring (b);六、variant 、 _ alternate _ t 与 colevariantvariant的结构可以参考头文件vc98 \ include \ oaidl.h中关于结构体tagvariant的定义.对于variant变量的赋值: 首先给vt成员赋值, 指明数据类型, 再对联合结构中相同数据类型的变量赋值, 举个例子:alternate work.int a = 2001;va.vt = vt _ 14; / / / 指明整型数据va.lval = a; / / / 赋值对于不马上赋值的variant, 最好先用void variantinit (variantarg to * pvarg); 进行初始化, 其本质是将vt设置为vt _ empty, 下表我们列举vt与常用数据的对应关系:unsigned char bval; _ ui1 vtshort ival; vt _ i2long lval; vt _ 14float fltval; vt _ r4double dblval; vt _ r8alternate _ bool boolval; vt _ boolscode scode; vt _ errorcy cyval; vt _ cydates dates; vt _ datesbstr bstrval; _ bstr vtiunknown to * punkval; vt _ unknownidispatch to * pdispval; _ dispatch vtsafearray to * parray;vt _ array | *unsigned char father * pbval; vt _ byref | vt _ ui1 short father * pival; vt _ byref | vt _ i2long father * plval; vt _ byref | vt _ i4float father * pfltval; vt _ byref | vt _ r4 double father * pdblval; vt _ byref | vt _ r8variant _ all father * pboolval; vt _ byref | vt _ allscode father * pscode; vt _ byref | vt _ errorcy dad * pcyval; vt _ byref | vt _ cydad * date pdate; vt _ byref | vt _ datebstr father * pbstrval; vt _ byref | vt _ bstriunknown dad dad * * ppunkval; vt _ byref | vt _ unknownidispatch dad dad * * ppdispval; vt _ byref | vt _ dispatchsafearray dad dad * * pparray; vt _ array | *variant father * pvarval; vt _ byref | vt _ variantvoid father * byref; vt _ byref_ variant _ t是variant的封装类, 其赋值可以使用强制类型转换, 其构造函数会自动处理这些数据类型.例如:long l = 222;ing in = 100;_ variant _ t lval (l);lval = (long);colevariant的使用与 _ variant _ t的方法基本一样, 请参考如下例子:colevariant v3 = "字符串", v4 = (long) 1999;cstring str = (bstr) v3.pbstrval;long in = v4.lval;七、其它对消息的处理中我们经常需要将wparam或lparam等32位数据(dword) 分解成两个16位数据 (word), 例如:lparam lparam;word lovalue = loword (lparam); / / / 取低16位word hivalue = hiword (lparam); / / / 取高16位对于16位的数据 (word) 我们可以用同样的方法分解成高低两个8位数据 (byte), 例如:word wvalue;byte lovalue = lobyte (wvalue); / / / 取低8位byte hivalue = hibyte (wvalue); / / / 取高8位后记: 本文匆匆写成, 错误之处在所难免, 欢迎来信指正.int - > str itoa, atoidouble str ftoa, fabrics_ bstr _ t, _ variant _ t, cstring, long 等等看看下面:我给你点详细的例子, 看下面先看懂 _ variant _ t与 _ bstr _ t这两个类的构造函数和operator =里面有重载了很多情况,其他类型向 _ variant _ t 赋值:_ variant _ t (); throw ()_ variant _ t (which variant & varsrc) throw (_ com _ error);_ variant _ t (which variant * pvarsrc) throw (_ com _ error);_ variant _ t (which _ variant _ t & t was _ _ src) throw (_ com _ error);_ variant _ t (variant & varsrc, all fcopy) throw (_ com _ error);_ variant _ t (short ssrc, vartype vtsrc = vt _ i2) throw (_ com _ error);_ variant _ t (long lsrc, vartype vtsrc = vt _ i4) throw (_ com _ error);_ variant _ t (float fltsrc) throw ();_ variant _ t (double dblsrc, vartype vtsrc = vt _ r8) throw (_ com _ error);_ variant _ t (which cy & cysrc) throw ();_ variant _ t (which _ bstr _ t & bstrsrc) throw (_ com _ error);_ variant _ t (which wchar _ t * wstrsrc) throw (_ com _ error);_ variant _ t (which char * strsrc) throw (_ com _ error);_ variant _ t (all bsrc) throw ();_ variant _ t (iunknown * piuknownsrc, all faddref = true) throw ();_ variant _ t (idispatch * pdispsrc, all faddref = true) throw ();_ variant _ t (which decimal & decsrc) throw ();_ variant _ t (byte bsrc) throw ();operator = 的重载形式:_ variant _ t & operator = (which variant & varsrc) throw (_ com _ error);_ variant _ t & operator = (which variant * pvarsrc) throw (_ com _ error);_ variant _ t & operator = (which _ variant _ t & t was _ _ src) throw (_ com _ error);_ variant _ t & operator = (short ssrc) throw (_ com _ error);_ variant _ t & operator = (long lsrc) throw (_ com _ error);_ variant _ t & operator = (float fltsrc) throw (_ com _ error);_ variant _ t & operator = (double dblsrc) throw (_ com _ error);_ variant _ t & operator = (which cy & cysrc) throw (_ com _ error);_ variant _ t & operator = (which _ bstr _ t & bstrsrc) throw (_ com _ error);_ variant _ t & operator = (which wchar _ t * wstrsrc) throw (_ com _ error);_ variant _ t & operator = (char * which strsrc) throw (_ com _ error);_ variant _ t & operator = (idispatch * pdispsrc) throw (_ com _ error);_ variant _ t & operator = (all bsrc) throw (_ com _ error);_ variant _ t & operator = (iunknown * psrc) throw (_ com _ error);_ variant _ t & operator = (which decimal & decsrc) throw (_ com _ error);_ variant _ t & operator = (byte bsrc) throw (_ com _ error); 有了以上两个函数, 举个例子:double f = 1.0_ variant _ t v;v = f; / / 是合法的看看operator = 的重载形式就知道了cstring str = "ddd"_ variant _ t v;v = str.allocsysstring () 或者v = (_ bstr _ t) (char * str); 即可_ variant _ t转换成别的形式你首先必须确定你要转化成什么样的形式double f;_ variant _ t vf = v.dblval 即可或者f = (double) v; 也可以附: _ variant _ t的操作符operator short () which throw (_ com _ error); operator long () which throw (_ com _ error); operator float () which throw (_ com _ error); operator double () which throw (_ com _ error); operator (cy) which throw (_ com _ error);the operator all () which throw (_ com _ error); decimal operator () which throw (_ com _ error); operator byte () which throw (_ com _ error); operator _ bstr _ t () which throw (_ com _ error); operator idispatch * () which throw (_ com _ error); operator iunknown * () which throw (_ com _ error);1 string2 cstringcstring.format ("% s", string.c _ str ());2 cstring 2 stringstring str (cstring.getbuffer (str.getlength ()));3 2 char * stringchar * p = string.c _ str ();4 string char * 2string str (char *);5 cstring 2 char *strcpy (char, cstring, sizeof (char));6 char * 2 cstringcstring.format ("% s", char *);cstring的format方法是非常好用的.string的c _ str () 也是非常常用的, 但要注意和char * 转换时, 要把char定义成为const char *, 这样是最安全的.*********************************************************** *************************************1。
VC++中的char,wchar_t,TCHAR
1.VC++中的char,wchar_t,TCHAR(转载)总体简介：由于字符编码的不同，在C++中有三种对于字符类型：char, wchar_t , TCHAR。
其实TCHAR不能算作一种类型，他紧紧是一个宏。
我们都知道，宏在预编译的时候会被替换成相应的内容。
TCHAR 在使用多字节编码时被定义成char，在Unicode编码时定义成wchar_t。
1.VC++中的char,wchar_t,TCHAR大家一起做一个项目，经常发现有的人爱用strcpy等标准ANSI函数，有的人爱用_tXXXX 函数，这个问题曾经搞的很混乱。
为了统一，有必要把来龙去脉搞清楚。
为了搞清这些函数，就必须理请几种字符类型的写法。
char就不用说了，先说一些wchar_t。
wchar_t是Unicode字符的数据类型，它实际定义在<string.h>里：typedef unsigned short wchar_t;不能使用类似strcpy这样的ANSI C字符串函数来处理wchar_t字符串，必须使用wcs 前缀的函数，例如wcscpy。
为了让编译器识别Unicode字符串，必须以在前面加一个“L”,例如:wchar_t *szTest=L"This is a Unicode string.";下面在看看TCHAR。
如果你希望同时为ANSI和Unicode编译的源代码，那就要include TChar.h。
TCHAR是定义在其中的一个宏，它视你是否定义了_UNICODE宏而定义成char或者wchar_t。
如果你使用了TCHAR，那么就不应该使用ANSI的strXXX 函数或者Unicode的wcsXXX函数了，而必须使用TChar.h中定义的_tcsXXX函数。
另外，为了解决刚才提到带“L”的问题，TChar.h中定义了一个宏：“_TEXT”。
以strcpy函数为例子，总结一下:.如果你想使用ANSI字符串，那么请使用这一套写法：char szString[100];strcpy(szString,"test");.如果你想使用Unicode字符串，那么请使用这一套：wchar_t szString[100];wcscpyszString,L"test");.如果你想通过定义_UNICODE宏，而编译ANSI或者Unicode字符串代码：TCHAR szString[100];_tcscpy(szString,_TEXT("test"));2.字符串及处理之三: 使用TCHAR系列方案使用TCHAR系列方案编写程序TCHAR是一种字符串类型，它让你在以MBCS和UNNICODE来build程序时可以使用同样的代码，不需要使用繁琐的宏定义来包含你的代码。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
VC++常用数据类型及其操作详解-------西安邮电学院计算机系徐兆元()2004/08/03 目录一．VC常用数据类型列表二．常用数据类型转化2.1数学类型变量与字符串相互转换2.2CString及string,char *与其他数据类型的转换和操作●CString,string,char*的综合比较●数学类型与CString相互转化●CString与char*相互转换举例●CString 与BSTR 型转换●V ARIANT 型转化成CString 型2.3 BSTR、_bstr_t与CComBSTR2.4 V ARIANT 、_variant_t 与COleVariant附录CString及字符串转及操作详解参考书籍:CSDN,<<MFC深入浅出(Second Edit)>>一．VC常用数据类型列表说明:(1)-------表示省略(2)1Byte=8Bit,字与机器有关,在8位系统中:字=1字节,16位系统中,1字=2字节，32位中:1字=4字节, 64位中1字=8字节.不要搞混这些概念.二．常用数据类型转化及操作2．1 数学类型变量与字符串相互转换(这些函数都在STDLIB.H里)（1）将数学类型转换为字符串可以用以下一些函数:举例: _CRTIMP char * __cdecl _itoa(int, char *, int);//这是一个将数字转换为一个字符串类型的函数,最后一个int表示转换的进制如以下程序:int iTyep=3;char *szChar;itoa(iType,szChar,2);cout<<szChar;//输出为1010类似函数列表:_CRTIMP char * __cdecl _itoa(int, char *, int);//为了完整性,也列在其中_CRTIMP char * __cdecl _ultoa(unsigned long, char *, int);_CRTIMP char * __cdecl _ltoa(long, char *, int);_CRTIMP char * __cdecl _i64toa(__int64, char *, int);_CRTIMP char * __cdecl _ui64toa(unsigned __int64, char *, int);_CRTIMP wchar_t * __cdecl _i64tow(__int64, wchar_t *, int);_CRTIMP wchar_t * __cdecl _ui64tow(unsigned __int64, wchar_t *, int);_CRTIMP wchar_t * __cdecl _itow (int, wchar_t *, int);//转换为长字符串类型_CRTIMP wchar_t * __cdecl _ltow (long, wchar_t *, int);_CRTIMP wchar_t * __cdecl _ultow (unsigned long, wchar_t *, int);还有很多,请自行研究（2）将字符串类型转换为数学类型变量可以用以下一些函数:举例: _CRTIMP int __cdecl atoi(const char *);//参数一看就很明了char *szChar=”88”;int temp(0);temp=atoi(szChar);cout<<temp;类似的函数列表:_CRTIMP int __cdecl atoi(const char *);_CRTIMP double __cdecl atof(const char *);_CRTIMP long __cdecl atol(const char *);_CRTIMP long double __cdecl _atold(const char *);_CRTIMP __int64 __cdecl _atoi64(const char *);_CRTIMP double __cdecl strtod(const char *, char **);//_CRTIMP long __cdecl strtol(const char *, char **, int);//_CRTIMP long double __cdecl _strtold(const char *, char **);_CRTIMP unsigned long __cdecl strtoul(const char *, char **, int);_CRTIMP double __cdecl wcstod(const wchar_t *, wchar_t **);//长字符串类型转换为数学类型_CRTIMP long __cdecl wcstol(const wchar_t *, wchar_t **, int);_CRTIMP unsigned long __cdecl wcstoul(const wchar_t *, wchar_t **, int);_CRTIMP int __cdecl _wtoi(const wchar_t *);_CRTIMP long __cdecl _wtol(const wchar_t *);_CRTIMP __int64 __cdecl _wtoi64(const wchar_t *);还有很多,请自行研究2．2．CString及string,char *与其他数据类型的转换和操作（1）CString,string,char*的综合比较（这部分CSDN上的作者joise的文章<< CString,string,char*的综合比较>>写的很详细,请大家在仔细阅读他的文章.地址: /或参考附录:(2)转换:●数学类型与CString相互转化数学类型转化为CString可用Format函数,举例:CString s;int i = 64;s.Format("%d", i)CString转换为数学类型:举例CString strValue("1.234");double dblValue;dblValue = atof((LPCTSTR)strValue);●CString与char*相互转换举例CString strValue(“Hello”);char *szValue;szValue=strValue.GetBuffer(szValue);也可用(LPSTR)(LPCTSTR)对CString// 进行强制转换.szValue=(LPSTR)(LPCTSTR)strValue;反过来可直接赋值:char *szChar=NULL;CString strValue;szChar=new char[10];memset(szChar,0,10);strcpy(szChar,”Hello”);strValue=szChar;●CString 与BSTR 型转换CString 型转化成BSTR 型当我们使用ActiveX 控件编程时，经常需要用到将某个值表示成BSTR 类型.BSTR 是一种记数字符串，Intel平台上的宽字符串（Unicode），并且可以包含嵌入的NULL 字符。
可以调用CString 对象的AllocSysString 方法将CString 转化成BSTR：CString str;str = .....; // whateverBSTR bStr = str.AllocSysString();BSTR型转换为CString如果你在UNICODE 模式下编译代码，你可以简单地写成：CString convert(BSTR bStr){if(bStr == NULL)return CString(_T(""));CString s(bStr); // in UNICODE modereturn s;}如果是ANSI 模式CString convert(BSTR b){CString s;if(b == NULL)return s; // empty for NULL BSTR#ifdef UNICODEs = b;#elseLPSTR p = s.GetBuffer(SysStringLen(b) + 1);::WideCharToMultiByte(CP_ACP, // ANSI Code Page0, // no flagsb, // source widechar string-1, // assume NUL-terminatedp, // target bufferSysStringLen(b)+1, // target buffer lengthNULL, // use system default charNULL); // don''t care if default used s.ReleaseBuffer();#endifreturn s;}●V ARIANT 型转化成CString 型V ARIANT 类型经常用来给COM 对象传递参数，或者接收从COM 对象返回的值。
你也能自己编写返回V ARIANT 类型的方法，函数返回什么类型依赖可能（并且常常）方法的输入参数（比如，在自动化操作中，依赖与你调用哪个方法。
IDispatch::Invoke 可能返回（通过其一个参数）一个包含有BYTE、WORD、float、double、date、BSTR 等等V ARIANT 类型的结果，（详见MSDN 上的V ARIANT 结构的定义）。
在下面的例子中，假设类型是一个BSTR的变体，也就是说在串中的值是通过bsrtVal 来引用，其优点是在ANSI 应用中，有一个构造函数会把LPCWCHAR 引用的值转换为一个CString（见BSTR-to-CString 部分）。
在Unicode 模式中，将成为标准的CString 构造函数，参见对缺省::WideCharToMultiByte 转换的告诫，以及你觉得是否可以接受（大多数情况下，你会满意的）。
V ARIANT vaData;vaData = m_com.YourMethodHere();ASSERT(vaData.vt == VT_BSTR);CString strData(vaData.bstrVal);你还可以根据vt 域的不同来建立更通用的转换例程。
为此你可能会考虑：CString VariantToString(V ARIANT * va){CString s;switch(va->vt){ /* vt */case VT_BSTR:return CString(vaData->bstrVal);case VT_BSTR | VT_BYREF:return CString(*vaData->pbstrVal);case VT_I4:s.Format(_T("%d"), va->lVal);return s;case VT_I4 | VT_BYREF:s.Format(_T("%d"), *va->plVal);case VT_R8:s.Format(_T("%f"), va->dblVal);return s;... 剩下的类型转换由读者自己完成default:ASSERT(FALSE); // unknown V ARIANT type (this ASSERT is optional)return CString("");} /* vt */}2．3 BSTR、_bstr_t与CComBSTRCComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。