VC中新常用数据类型使用转换详解
VC 中类型转换(CString,TCHAR,string)
AfxMessageBox(buf);
delete(buf);
_bstr_t变量
_bstr_t类型是对BSTR的封装，因为已经重载了=操作符，所以很容易使用
_bstr_t bstrVar("test");
const char *buf = bstrVar;///不要修改buf中的内容
AfxMessageBox(buf);
buffer = _fcvt( source, 7, &decimal, &sign );
运行结果:source: 3.1415926535 buffer: '31415927' decimal: 1 sign: 0
decimal表示小数点的位置,sign表示符号:0为正数，1为负数
CString变量
VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋值
_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
使用时需加上#include <comdef.h>
例如：
long l=222;
特别是_bstr_t,建议大家使用它。
VC6里用到的一些类型转换
VC6里用到的一些类型转换[引子]在做毕设的时候，用到VC6里面的串口控件。
我对VC几乎是一窍不通的，这次做毕设里面的类型转换也困扰了我好久。
在此小小总结一下。
[主要内容]一、MSComm里用到的VARIANT, COleVariant类型与CString, BYTE之间的转换，以实现数据的发送和接收二、CString与int的转换，实现对接收来的数据的运算一、MSComm和VARIANTVC6自带的串口ActiveX MSComm的对象使用SetOutput()和GetInput()方法实现发送和接收。
这两个函数的参数都是VARIANT类型。
void CMSComm::SetOutput(const VARIANT& newValue)VARIANT CMSComm::GetInput()发送过程：VARIANT其实是一个C++结构类型，COleVariant类型对VARIANT做了进一步的封装和扩展，提供了许多新的功能和操作方法，支持OLE自动化，且更容易向其数据成员填入数据。
由于COleVariant类型由VARIANT派生而来，因此将COleVariant类型的变量传递给SetOutput函数更为方便。
另外，SetOutput的参数newValue类型必须是存放字节类型数据的动态数组。
因此，可以利用Visual C++提供CByteArray类型来构造COleVariant类型的对象，并将其传递给SetOutput函数。
对CByteArray类型变量的操作相对来说要容易的多，比如其成员函数SetSize可用来设置动态数组的大小，下标操作符[]可用来为其元素赋值等等。
下面的程序代码可实现将存放在缓冲区strBuf中的100个字节的数据通过通讯控件发送出去：……BYTE strBuf[128];CByteArray OutBuf;COleVariant varOutput;……OutBuf.SetSize(100);for(i=0;i<100;i++)OutBuf[i] = strBuf[i];//BYTE转CByteArrayvarOutput = OutBuf;//CByteArray转COleVariantm_pCommDlg->m_Comm.SetOutput(varOutput);……利用通讯控件发送数据的关键在于构造COleVariant类型的变量，并向其中填入通讯数据，使其能满足通讯控件的成员函数SetOutput 的需要。
强制转换数据类型c语言
强制转换数据类型c语言在C语言中，强制转换数据类型是一种常见且重要的操作。
当我们需要将一个数据类型转换为另一个数据类型时，就需要使用强制转换操作符。
强制转换可以帮助我们在需要时将数据类型转换为另一种数据类型，以满足特定的需求。
在C语言中，强制转换的语法如下：(目标数据类型) 表达式其中，目标数据类型表示需要转换的目标数据类型，表达式表示需要转换的表达式或变量。
下面我们来看几种常见的强制转换数据类型的情况：1. 将整数转换为浮点数：当我们需要将整数转换为浮点数时，可以使用强制转换操作符。
例如，我们有一个整数变量a，我们想将其转换为浮点数，可以这样做：float b = (float)a;这样就可以将整数a转换为浮点数b。
2. 将浮点数转换为整数：同样，当我们需要将浮点数转换为整数时，也可以使用强制转换操作符。
例如，我们有一个浮点数变量c，我们想将其转换为整数，可以这样做：int d = (int)c;这样就可以将浮点数c转换为整数d。
需要注意的是，强制转换会截断小数部分，只保留整数部分。
3. 将字符转换为整数：在C语言中，字符类型实际上是整数类型的一种，可以将字符转换为整数。
例如，我们有一个字符变量ch，我们想将其转换为整数，可以这样做：int num = (int)ch;这样就可以将字符ch转换为整数num，实际上是将字符的ASCII码转换为整数。
4. 将指针转换为整数：在C语言中，可以将指针转换为整数类型，这在某些情况下是有用的。
例如，我们有一个指针变量ptr，我们想将其转换为整数，可以这样做：int num = (int)ptr;这样就可以将指针ptr转换为整数num，但需要注意的是，指针转换为整数可能会丢失指针的信息，不建议经常使用。
总的来说，强制转换数据类型是C语言中的一种重要操作，可以帮助我们在需要时转换数据类型，但需要注意转换的合法性，避免数据丢失或错误转换的情况发生。
在使用强制转换时，需要注意转换的目的和转换的方式，确保转换的正确性和安全性。
c语言不同数据类型间的混合运算转换规则+常见数据类型
c语言不同数据类型间的混合运算转换规则+常见数据类型C语言中，不同数据类型之间的混合运算会按照一定的规则进行自动转换，具体规则如下：1. 整数和浮点数运算：- 如果一个操作数是浮点数，那么另一个操作数也会被转换为浮点数，然后进行运算。
- 如果一个操作数是整数，而另一个操作数是浮点数，那么整数会自动转换为浮点数，然后进行运算。
2. 整数之间的运算：- 如果两个操作数的类型相同，那么不需要进行任何转换，直接进行运算。
- 如果两个操作数的类型不同，那么会将较低精度的操作数自动提升为较高精度的类型，然后再进行运算。
常见的C语言数据类型包括：1. 整数类型：- char：1字节，有符号或无符号的整数。
- short：2字节，有符号或无符号的短整数。
- int：2或4字节，有符号或无符号的整数。
在不同系统中，其长度可能会有所不同。
- long：4或8字节，有符号或无符号的长整数。
在不同系统中，其长度可能会有所不同。
2. 浮点数类型：- float：4字节，单精度浮点数。
- double：8字节，双精度浮点数。
- long double：8字节以上，长双精度浮点数。
3. 其他类型：- void：空类型，用于标识无返回值或不可具体化的函数。
- bool（C99标准引入）：用于表示布尔值，取值为true或false。
- 数组类型、指针类型、结构体类型、枚举类型等。
需要注意的是，在进行混合运算时，应尽量避免不必要的类型转换，以免影响程序的可读性和正确性。
同时，对于可能引起精度丢失的情况（如整数与浮点数之间的运算），需注意选择合适的数据类型和进行必要的类型转换。
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位指针。
VC类型格式转换
项目中经常用到各种不同的语言的朋友们应该会比较有这样的体会：一种开发语言用了比较长的时间，突然间转到另外一种语言的话，不管是数据类型或者语法结构，多多少少都会有那么一点不适应。
哪怕MFC中的类型与标准C++也是一样的。
下面是MFC/C++/C中字符类型CString, int, string, char*之间的转换的说明与举例，经常用的东西，相信对于用C/C++的朋友，还是比较有用的。
1、CString,int,string,char*之间的转换string转CStringCString.format("%s", string.c_str());char转CStringCString.format("%s", char*);char转stringstring s(char *);string转char *char *p = string.c_str();// CString转std::stringCStringstr = dlg.GetPathName(); setlocale(LC_ALL, "chs");char *p = new char[256];wcstombs( p, str, 256 );m_fileName = p;1，string ->CStringCString.format("%s", string.c_str());用c_str()确实比data()要好. 2，char -> stringstring s(char *);你的只能初始化，在不是初始化的地方最好还是用assign(). 3,CString -> string string s(CString.GetBuffer()); GetBuffer()后一定要ReleaseBuffer(),否则就没有释放缓冲区所占的空间.《C++标准函数库》中说的有三个函数可以将字符串的内容转换为字符数组和C—string1.data(),返回没有“\0”的字符串数组2,c_str()，返回有“\0”的字符串数组3，copy()CString互转int将字符转换为整数，可以使用atoi、_atoi64或atol。
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等）的模板类型。
C语言数据类型转换
1.自动类型转换自动类型转换就是编译器默默地、隐式地、偷偷地进行的数据类型转换，这种转换不需要程序员干预，会自动发生。
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。
自动类型转换示例：#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语言不同类型数据间的转换与运算
c语言不同类型数据间的转换与运算
C语言中不同类型的数据可以进行转换，但需要注意数据精度的损失和溢出问题。
以下是数据类型间的转换及其运算：
1. 整型转浮点型：整型可以直接转换为浮点型，即将整数值转换为浮点数值，例如将int类型变量a转换为float类型的变量b，可以使用如下语句：
float b = (float)a; 强制类型转换
2. 浮点型转整型：浮点型转换为整型需要注意精度的损失和溢出问题，可以使用强制类型转换方式或者使用取舍方法进行转换：
int a = (int)3.14f; 强制类型转换，a的值为3
int b = (int)(-3.14f); 强制类型转换，b的值为-3
int c = (int)(3.14f + 0.5f); 取舍方法转换，c的值为3
int d = (int)(-3.14f - 0.5f); 取舍方法转换，d的值为-3
3. 字符类型转换：字符类型可以转换为整型和浮点型，例如将char类型变量c 转换为int类型的变量a，可以使用如下语句：
char c = 'A';
int a = (int)c; 强制类型转换，a的值为65
4. 数组类型转换：可以使用指针类型进行数组间的转换，例如将int类型的数组a转换为float类型的数组b，可以使用如下语句：
int a[3] = {1, 2, 3};
float *b = (float *)a; 强制类型转换，b指向a的首地址
5. 布尔类型转换：布尔类型不可以直接强制类型转换为整型或浮点型，但是可以使用True和False来表示0和1，例如：
bool flag = true;
int a = flag; a的值为1。
CC++数据类型的转换
C/C++数据类型的转换之终极无惑数据类型在编程中经常遇到，虽然可能存在风险，但我们却乐此不疲的进行数据类型的转换。
1.隐式数据类型转换数据类型转换，到底做了些什么事情呢？实际上，数据类型转换的工作相当于一条函数调用，若有一个函数撰文负责从double转换到int（假设函数是dtoi），则下面的转换语句：double d=4.48;int i=d;//报告警告等价于i=dtoi(d)。
函数dtoi的原型应该是：int dtoi(double)或者是int dtoi(const double&)。
有些类型的数据转换时绝对安全的，所以可以自动进行，编译器不会给出任何警告，如由int 型转换成double型。
另一些转换会丢失数据，编译器只会给出警告，并不算一个语法错误，如上面的例子。
各种基本数据类型（不包括void）之间的转换都属于以上两种情况。
以上两种不显示指明数据类型的转换就是隐式数据类型转换。
隐式数据类型转换无处不在，主要出现在一下集中情况。
（1）算术运算式中，低类型能够转换为高类型。
（2）赋值表达式中，右边表达式的值自动隐式转换为左边变量的类型，并赋值给他。
（3）函数调用中参数传递时，系统隐式地将实参转换为形参的类型后，赋给形参。
（4）函数有返回值时，系统将隐式地将返回表达式类型转换为返回值类型，赋值给调用函数。
编程原则，请尽量不要使用隐式类型转换，即使是隐式的数据类型转换是安全的，因为隐式类型数据转换降低了程序的可读性。
2.显示数据类型转换显示数据类型转换是显示指明需要转换的类型，首先考察如下程序。
#include<iostream>usingnamespace std;int main(int argc,char* argv[]){short arr[]={65,66,67,0};wchar_t *s;s=arr;wcout<<s<<endl;getchar();}由于short int和wchar_t是不同的数据类型，直接把arr代表的地址赋给s会导致一个编译错误：error C2440：“=”：无法从“short[4]”转换为“wchar_t”。
c语言数据类型转换规则
c语言数据类型转换规则数据类型转换是计算机程序开发中必不可少的一个环节。
C语言作为一种底层语言，数据类型转换的规则极为严格，必须遵守一定的规范才能保证程序的正确性和稳定性。
本文将介绍C 语言数据类型转换的规则和注意事项，帮助程序员更好地处理数据类型。
C语言数据类型转换的规则：1. 隐式类型转换：当将一种数据类型赋值给另一种类型时，编译器会自动进行类型转换，这种类型转换称为隐式类型转换。
例如整型赋值给浮点型，字符型赋值给整型等。
2. 显式类型转换：当需要进行一种复杂的数据类型转换时，需要使用强制类型转换运算符，这种类型转换称为显式类型转换。
强制类型转换运算符包括：（1）(char)（2）(int)（3）(float)（4）(double)（5）(long)注意事项：1. C语言在进行数据类型转换时，有时会出现数据丢失的情况，例如将一个int类型赋值给char类型时，如果int类型的值大于127或小于-128，则会造成数据丢失。
因此，在进行数据类型转换时，需要确保不会发生数据丢失的情况。
2. 在进行整型和浮点型之间的转换时，需要注意精度问题。
在将一个浮点型转换成整型时会丢失小数部分，而在将一个整型转换成浮点型时会增加小数部分，因此需要考虑到精度的问题。
3. 在进行字符串和其他数据类型之间的转换时，需要使用标准库函数，例如atoi()函数将字符串转换成整型，atof()函数将字符串转换成浮点型等。
同时需要注意字符串长度的限制，防止缓冲区溢出。
4. C语言中可以使用强制类型转换运算符来进行数据类型转换，但是需要注意该运算符可能会造成数据丢失。
因此，在进行强制类型转换时需要慎重考虑，避免出现程序崩溃等问题。
总之，C语言数据类型转换规则虽然复杂，但是只要遵守相关规范并注意细节，就能够轻松完成各种数据类型转换操作。
同时，程序员在使用强制类型转换时需要慎重考虑，避免产生不必要的程序错误。
c语言不同类型数据间的转换
c语言不同类型数据间的转换C语言中，不同类型的数据之间需要进行转换的情况是非常常见的。
这些数据类型包括整型、浮点型、字符型等。
本文将详细介绍在C 语言中不同类型数据间的转换方式和规则。
一、整型数据间的转换在C语言中，整型数据间的转换可以分为两种情况：从较小的整型向较大的整型转换以及从较大的整型向较小的整型转换。
1. 从较小的整型向较大的整型转换当把一个较小的整型数据赋值给一个较大的整型变量时，C语言会自动进行类型转换，保证数据的正确传递。
例如，将一个short类型的变量赋值给一个int类型的变量，编译器会自动将short类型转换为int类型。
2. 从较大的整型向较小的整型转换当把一个较大的整型数据赋值给一个较小的整型变量时，C语言会截断高位数据，只保留低位数据。
这可能导致数据的精度丢失。
为了避免这种情况，可以使用强制类型转换来告诉编译器我们知道可能会有精度丢失。
例如，将一个int类型的变量赋值给一个short 类型的变量，可以使用强制类型转换来明确告知编译器。
二、浮点型数据间的转换在C语言中，浮点型数据间的转换也包含两种情况：从较小的浮点型向较大的浮点型转换以及从较大的浮点型向较小的浮点型转换。
1. 从较小的浮点型向较大的浮点型转换当把一个较小的浮点型数据赋值给一个较大的浮点型变量时，C语言会自动进行类型转换，保证数据的正确传递。
例如，将一个float类型的变量赋值给一个double类型的变量，编译器会自动将float类型转换为double类型。
2. 从较大的浮点型向较小的浮点型转换当把一个较大的浮点型数据赋值给一个较小的浮点型变量时，C语言会进行舍入操作，只保留有效位数，可能导致精度丢失。
为了避免这种情况，可以使用强制类型转换来明确告知编译器。
例如，将一个double类型的变量赋值给一个float类型的变量，可以使用强制类型转换来告知编译器。
三、字符型数据和整型数据间的转换在C语言中，字符型数据和整型数据之间的转换是非常常见的。
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语言数据类型转换优先级摘要：1.C 语言数据类型转换概述2.C 语言数据类型转换优先级规则3.实例分析4.总结正文：【1.C 语言数据类型转换概述】在C 语言编程中，数据类型转换是指将一种数据类型的值转换为另一种数据类型的值。
这种转换通常发生在不同类型的变量之间进行运算时，或者当需要将一个数据类型的值赋给另一个数据类型的变量时。
数据类型转换可以提高程序的灵活性和可读性，但同时也需要注意转换的优先级和规则。
【2.C 语言数据类型转换优先级规则】C 语言中，数据类型转换的优先级遵循以下规则：1) 从低类型到高类型：即从占用内存较小的数据类型向占用内存较大的数据类型转换。
例如，从int 转换为float，从float 转换为double 等。
2) 从简单的数据类型向复杂的数据类型转换：例如，从基本的整型、浮点型转换为结构体、数组等复合数据类型。
3) 指针类型转换：指针类型转换分为两种情况，一种是将基类型指针转换为派生类型指针，另一种是将派生类型指针转换为基类型指针。
其中，将基类型指针转换为派生类型指针时，需要进行类型转换，而将派生类型指针转换为基类型指针时，不需要进行类型转换。
【3.实例分析】以下是一个简单的C 语言程序，演示了数据类型转换的过程：```c#include <stdio.h>int main() {int a = 5;float b = 3.14;double c = 2.718;float db = (float)a; // 将int 类型转换为float 类型double dc = (double)b; // 将float 类型转换为double 类型int di = (int)c; // 将double 类型转换为int 类型printf("a = %d", a);printf("b = %.2f", b);printf("c = %.2lf", c);printf("db = %.2f", db);printf("dc = %.2lf", dc);printf("di = %d", di);return 0;}```该程序首先定义了三个变量a、b 和c，分别属于int、float 和double 类型。
c语言数据类型转换方式
c语言数据类型转换方式C语言是一种面向过程的编程语言，数据类型转换是在不同数据类型之间进行转换的过程。
C语言提供了强制类型转换和隐式类型转换两种方式。
1. 强制类型转换：强制类型转换是通过使用强制类型转换运算符将一个数据类型转换为另一个数据类型。
其基本语法形式为：(type) expression。
其中，type表示要转换的目标数据类型，expression表示要进行转换的表达式或变量。
例如，将一个整数转换为浮点数类型：```int num = 10;float result = (float) num;```在上述代码中，通过使用强制类型转换运算符将整数类型的变量num转换为浮点数类型，并将结果赋值给浮点数类型的变量result。
2. 隐式类型转换：隐式类型转换是在不使用强制类型转换运算符的情况下自动进行的类型转换。
在某些情况下，C语言会根据所需的数据类型自动将其他类型的值转换为目标类型。
例如，将一个整数除以一个浮点数：```int num1 = 10;float num2 = 3.5;float result = num1 / num2;```在上述代码中，整数类型的变量num1被隐式转换为浮点数类型，以便与浮点数类型的变量num2进行除法运算，最终结果赋值给浮点数类型的变量result。
在进行数据类型转换时，需要注意以下几点：1. 数据精度丢失：在进行数据类型转换时，可能会导致数据精度的丢失。
例如，将一个浮点数转换为整数类型时，小数部分将被截断。
2. 数据溢出：在进行数据类型转换时，可能会导致数据溢出的问题。
例如，将一个大范围的整数转换为较小范围的整数类型时，可能会导致数据溢出，从而导致结果不准确。
3. 不同类型之间的兼容性：在进行数据类型转换时，需要考虑不同数据类型之间的兼容性。
某些数据类型之间可以直接进行转换，而某些数据类型之间需要使用强制类型转换运算符进行转换。
除了基本的数据类型转换之外，C语言还提供了一些特殊的数据类型转换方式，如指针类型转换和结构体类型转换等。
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。
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转换为字符型```需要注意的是，在进行显式转换时，可能会导致数据精度的丢失或溢出，因此在进行类型转换时要慎重，确保转换的结果符合预期。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
介绍一些常用数据类型的使用。
先定义一些常见类型变量借以说明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;BSTR变量BSTR bstrValue = ::SysAllocString(L"程序员"); char * buf =_com_util::ConvertBSTRToString(bstrValue); SysFreeString(bstrValue);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中的内容 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变量。
四、BSTR、_bstr_t与CComBSTRCComBSTR 是ATL对BSTR的封装，_bstr_t是C++对BSTR的封装,BSTR是32位指针,但并不直接指向字串的缓冲区。
char *转换到BSTR可以这样:BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上comutil.h和comsupp.libSysFreeString(bstrValue);反之可以使用char *p=_com_util::ConvertBSTRToString(b);delete p;具体可以参考一，二段落里的具体说明。
CComBSTR与_bstr_t对大量的操作符进行了重载，可以直接进行=,!=,==等操作，所以使用非常方便。
特别是_bstr_t,建议大家使用它。
五、VARIANT 、_variant_t 与 COleVariantVARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：VARIANT va;int a=2001;va.vt=VT_I4;///指明整型数据va.lVal=a; ///赋值对于不马上赋值的VARIANT，最好先用VoidVariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:Byte bVal;// VT_UI1.Short iVal;// VT_I2.long lVal;// VT_I4.float fltVal;// VT_R4.double dblVal;// VT_R8.VARIANT_BOOL boolVal;// VT_BOOL.SCODE scode;// VT_ERROR.CY cyVal;// VT_CY.DATE date;// VT_DATE.BSTR bstrVal;// VT_BSTR.DECIMAL FAR* pdecVal// VT_BYREF|VT_DECIMAL.IUnknown FAR* punkVal;// VT_UNKNOWN.IDispatch FAR*// VT_DISPATCH. pdispVal;SAFEARRAY FAR* parray;// VT_ARRAY|*.Byte FAR* pbVal;// VT_BYREF|VT_UI1.short FAR* piVal;// VT_BYREF|VT_I2.long FAR* plVal;// VT_BYREF|VT_I4.float FAR* pfltVal;// VT_BYREF|VT_R4.double FAR* pdblVal;// VT_BYREF|VT_R8.VARIANT_BOOL FAR*// VT_BYREF|VT_BOOL. pboolVal;SCODE FAR* pscode;// VT_BYREF|VT_ERROR.CY FAR* pcyVal;// VT_BYREF|VT_CY.DATE FAR* pdate;// VT_BYREF|VT_DATE.BSTR FAR* pbstrVal;// VT_BYREF|VT_BSTR.IUnknown FAR* FAR*// VT_BYREF|VT_UNKNOWN. ppunkVal;IDispatch FAR* FAR*// VT_BYREF|VT_DISPATCH. ppdispVal;SAFEARRAY FAR* FAR*// VT_ARRAY|*.pparray;VARIANT FAR* pvarVal;// VT_BYREF|VT_VARIANT.void FAR* byref;// Generic ByRef.char cVal;// VT_I1.unsigned short uiVal;// VT_UI2.unsigned long ulVal;// VT_UI4.int intVal;// VT_INT.unsigned int uintVal;// VT_UINT.char FAR * pcVal;// VT_BYREF|VT_I1.unsigned short FAR *// VT_BYREF|VT_UI2.puiVal;unsigned long FAR *// VT_BYREF|VT_UI4.pulVal;int FAR * pintVal;// VT_BYREF|VT_INT.unsigned int FAR *//VT_BYREF|VT_UINT.puintVal;_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
使用时需加上#include <comdef.h>例如：long l=222;ing i=100;_variant_t lVal(l);lVal = (long)i;COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：COleVariant v3 = "字符串", v4 = (long)1999;CString str =(BSTR)v3.pbstrVal;long i = v4.lVal;六、其它一些COM数据类型根据ProgID得到CLSIDHRESULT CLSIDFromProgID( LPCOLESTRlpszProgID,LPCLSID pclsid);CLSID clsid;CLSIDFromProgID( L"MAPI.Folder",&clsid);根据CLSID得到ProgIDWINOLEAPI ProgIDFromCLSID( REFCLSIDclsid,LPOLESTR * lplpszProgID);例如我们已经定义了 CLSID_IApplication,下面的代码得到ProgIDLPOLESTR pProgID = 0;ProgIDFromCLSID( CLSID_IApplication,&pProgID);...///可以使用pProgIDCoTaskMemFree(pProgID);//不要忘记释放七、ANSI与UnicodeUnicode称为宽字符型字串,COM里使用的都是Unicode字符串。