zoukankan      html  css  js  c++  java
  • VC++常用数据类型及其操作详解

    目录

    一.              VC常用数据类型列表

    二.              常用数据类型转化

    2.1数学类型变量与字符串相互转换

    2.2 CString及string,char *与其他数据类型的转换和操作

    ●CString,string,char*的综合比较

    ●数学类型与CString相互转化

    ●CString与char*相互转换举例

    ●CString 与 BSTR 型转换

    ●VARIANT 型转化成 CString 型

    2.3 BSTR、_bstr_t与CComBSTR

    2.4 VARIANT 、_variant_t 与 COleVariant

    附录CString及字符串转及操作详解

    参考书籍:CSDN,<<MFC深入浅出(Second Edit)>>

                                 一.VC常用数据类型列表

    Type

    Default Size

    Description

    说明:这些基础数据类型对于MFC还是API都是被支持的

    boolean

    unsigned 8 bit ,

    取值TRUE/FALSE

    byte

    unsigned 8 bit,

    整数,输出按字符输出

    char

    unsigned 8 bit,

    字符

    double

    signed 64 bit

    浮点型

    float

    signed32 bit

    浮点型

    handle_t

    Primitive handle type

    hyper

    signed 64 bit

    整型

    int

    signed 32 bit

    整型

    long

    signed 32 bit

    整型

    short

    signed 16 bit

    整型

    small

    signed 8 bit

    整型

    void *

    32-bit

    指向未知类型的指针

    wchar_t

    unsigned 16 bit

    16位字符,比char可容纳更多的字符

    Win32

    API

    说明: 这些Win32API支持的简单数据类型主要是用来定义函数返回值,消息参数,结构成员。这类数据类型大致可以分为五大类:字符型、布尔型、整型、指针型和句柄型(?). 总共大概有100多种不同的类型,

    BOOL/BOOLEAN

    8bit,TRUE/FALSE

    布尔型

    BYTE

    unsigned 8 bit

    BSTR

    CComBSTR

    _bstr_t

    32 bit

    BSTR是指向字符串的32位指针

    是对BSTR的封装

    是对BSTR的封装

    CHAR

    8 bit

    (ANSI)字符类型

    COLORREF

    32 bit

    RGB颜色值 整型

    DWORD

    unsigned 32 bit

    整型

    FLOAT

    float型

    float型

    HANDLE

    Object句柄

    HBITMAP

    bitmap句柄

    HBRUSH

    brush句柄

    HCURSOR

    cursor句柄

    HDC

    设备上下文句柄

    HFILE

    OpenFile打开的File句柄

    HFONT

    font句柄

    HHOOK

    hook句柄

    HKEY

    注册表键句柄

    HPEN

    pen句柄

    HWND

    window句柄

    INT

    --------

    --------

    LONG

    --------

    ---------

    LONGLONG

    64位带符号整型

    LPARAM

    32 bit

    消息参数

    LPBOOL

    BOOL型指针

    LPBYTE

    BYTE型指针

    LPCOLOREF

    COLORREF型指针

    LPCSTR/LPSTR/PCSTR

    指向8位(ANSI)字符串类型指针

    LPCWSTR/LPWSTR/PCWSTR

    指向16位Unicode字符串类型

    LPCTSTR/LPTSTR/PCTSTR

    指向一8位或16位字符串类型指针

    LPVOID

    指向一个未指定类型的32位指针

    LPDWORD

    指向一个DWORD型指针

    其他相似类型: LPHANDLE、LPINT、LPLONG、LPWORD、LPRESULT

    PBOOL、PBOOLEAN、PBYTE、PCHAR、PDWORD、PFLOAT、PHANDLE、PINT、PLONG、PSHORT……

    说明:(1)在16位系统中 LP为16bit,P为8bit,在32位系统中都是32bit(此时等价)

    (2)LPCSTR等 中的C指Const,T表示TCHAR模式即可以工作在ANSI下也可UNICODE

    SHORT

    usigned

    整型

    其他UCHAR、UINT、ULONG、ULONGLONG、USHORT为无符号相应类型

    TBYTE

    WCHAR型或者CHAR型

    TCHAR

    ANSI与unicode均可

    VARIANT

    _variant_t

    COleVariant

    一个结构体参考OAIDL.H

    _variant_t是VARIANT的封装类

    COleVariant也是VARIANT的封装类

    WNDPROC

    指向一个窗口过程的32位指针

    WCHAR

    16位Unicode字符型

    WORD

    16位无符号整型

    WPARAM

    消息参数

    MFC

    独有

    数据

    类型

    下面两个数据类型是微软基础类库中独有的数据类型

    POSITION

    标记集合中一个元素的位置的值,被MFC中的集合类所使用

    LPCRECT

    指向一个RECT结构体常量(不能修改)的32位指针

    CString

    其实是MFC中的一个类

    说明:

    (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 *);

    还有很多,请自行研究

    22CStringstring,char *与其他数据类型的转换和操作

    (1)CString,string,char*的综合比较(这部分CSDN上的作者joise的文章

    << CString,string,char*的综合比较>>写的很详细,请大家在仔细阅读他的文章.

    地址: http://blog.csdn.net/joise/

    或参考附录:

    (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 = .....; // whatever

    BSTR bStr = str.AllocSysString();

    BSTR型转换为CString

    如果你在 UNICODE 模式下编译代码,你可以简单地写成:

    CString convert(BSTR bStr)

    {

        if(bStr == NULL)

            return CString(_T(""));

        CString s(bStr); // in UNICODE mode

        return s;

    }

    如果是 ANSI 模式

    CString convert(BSTR b)

    {

        CString s;

        if(b == NULL)

           return s; // empty for NULL BSTR

    #ifdef UNICODE

        s = b;

    #else

        LPSTR p = s.GetBuffer(SysStringLen(b) + 1);

        ::WideCharToMultiByte(CP_ACP,            // ANSI Code Page

                              0,                 // no flags

                              b,                 // source widechar string

                              -1,                // assume NUL-terminated

                              p,                 // target buffer

                              SysStringLen(b)+1, // target buffer length

                              NULL,              // use system default char

                              NULL);             // don''t care if default used

        s.ReleaseBuffer();

    #endif

        return s;

    }

    ●VARIANT 型转化成 CString 型

    VARIANT 类型经常用来给 COM 对象传递参数,或者接收从 COM 对象返回的值。你也能自己编写返回 VARIANT 类型的方法,函数返回什么类型 依赖可能(并且常常)方法的输入参数(比如,在自动化操作中,依赖与你调用哪个方法。IDispatch::Invoke 可能返回(通过其一个参数)一个 包含有BYTE、WORD、float、double、date、BSTR 等等 VARIANT 类型的结果,(详见 MSDN 上的 VARIANT 结构的定义)。在下面的例子中,假设 类型是一个BSTR的变体,也就是说在串中的值是通过 bsrtVal 来引用,其优点是在 ANSI 应用中,有一个构造函数会把 LPCWCHAR 引用的值转换为一个 CString(见 BSTR-to-CString 部分)。在 Unicode 模式中,将成为标准的 CString 构造函数,参见对缺省::WideCharToMultiByte 转换的告诫,以及你觉得是否可以接受(大多数情况下,你会满意的)。VARIANT vaData;

    vaData = m_com.YourMethodHere();

    ASSERT(vaData.vt == VT_BSTR);

    CString strData(vaData.bstrVal);

    你还可以根据 vt 域的不同来建立更通用的转换例程。为此你可能会考虑:

    CString VariantToString(VARIANT * 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 VARIANT type (this ASSERT is optional)

              return CString("");

          } /* vt */

    }

    2.3 BSTR、_bstr_t与CComBSTR

    CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。

    char *转换到BSTR可以这样:

    BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上头文件comutil.h

    反之可以使用char *p=_com_util::ConvertBSTRToString(b);

    2.4(引)VARIANT 、_variant_t 与 COleVariant

    VARIANT的结构可以参考头文件VC98IncludeOAIDL.H中关于结构体tagVARIANT的定义。

    对于VARIANT变量的赋值:首先给vt成员赋值,指明数据类型,再对联合结构中相同数据类型的变量赋值,举个例子:

    VARIANT va;

    int a=2001;

    va.vt=VT_I4;///指明整型数据

    va.lVal=a; ///赋值

    对于不马上赋值的VARIANT,最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:

    unsigned char 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

    IUnknown FAR* punkVal; VT_UNKNOWN

    IDispatch FAR* pdispVal; VT_DISPATCH

    SAFEARRAY FAR* parray; VT_ARRAY|*

    unsigned char 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* pboolVal; VT_BYREF|VT_BOOL

    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* ppunkVal; VT_BYREF|VT_UNKNOWN

    IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH

    SAFEARRAY FAR* FAR* pparray; VT_ARRAY|*

    VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT

    void FAR* byref; VT_BYREF

    _variant_t是VARIANT的封装类,其赋值可以使用强制类型转换,其构造函数会自动处理这些数据类型。

    例如:

    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;

    附录

    CString,string,char*的综合比较

    (一)  概述

    string和CString均是字符串模板类,string为标准模板类(STL)定义的字符串类,已经纳入C++标准之中;

    CString(typedef CStringT<TCHAR, StrTraitMFC<TCHAR>> CString)为Visual C++中最常用的字符串类,继承自CSimpleStringT类,主要应用在MFC和ATL编程中,主要数据类型有char(应用于ANSI),wchar_t(unicode),TCHAR(ANSI与unicode均可);

    char*为C编程中最常用的字符串指针,一般以’’为结束标志;

    (二)  构造

    ²        string是方便的,可以从几乎所有的字符串构造而来,包括CString和char*;

    ²        CString次之,可以从基本的一些字符串变量构造而来,包括char*等;

    ²        char*没有构造函数,仅可以赋值;

    ²        举例:

    char* psz = “joise”;

    CString cstr( psz );

    string str( cstr );

    (三)  运算符重载

    a)       operator=

    ²        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;

    b)          operator+

    ²        string与CString差不多,可以直接与char*进行加法,但不可以相互使用+运算符,即string str = str + cstr是非法的,须转换成char*;

    ²        char*没有+运算,只能使用strcat把两个指针连在一起;

    ²        举例:

    char* psz = “joise”;

    CString cstr = psz;

    cstr = cstr + psz;

    string str = psz;

    str = str + str + psz;

    strcat( psz, psz );

    strcat( psz, cstr );//合法

    strcat( psz, str );//非法,由此可见,CString可自动转换为const char*,而string不行

    c)      operator +=

    ²        string是最强大的,几乎可以与所有的字符串变量+=,包括CString和char*;

    ²        CString次之,可以与基本的一些字符串变量进行+=而来,包括char*等;

    ²        char*没有+=运算符,只能使用strcat把两个指针连在一起;

    d)      operator[]

    ²    CString最好,当越界时会抛出断言异常;

    ²    string与char*下标越界结果未定义;

    ²        举例:

    char* psz = “joise”;

    CString cstr = psz;

    cout << cstr[8];

    string str = psz;

    cout << str[8];

    cout << psz[8];

    e)       operator== 、operator!=、operator> 、operator< 、operator>= 、perator<=

    ²        CString与string之间不可以进行比较,但均可以与char*进行比较,并且比较的是值,而不是地址;

         cout << ( psz == cstr );

         cout << ( psz == str );

         cout << ( str == psz );

         cout << ( cstr == psz );//以上代码返回均为1

    (四)  常用算法

    a)       查找

    作用

    char*

    string

    CString

    查找指定值

    strchr

    strstr

    strrstr

    strspn

    find

    Find

    第一个匹配的值

    fild_first_of

    FindOneOf

    从后面开始查找

    ReserveFind

    指定匹配方式

    find_if

    注:find_if中是把范围内的值挨个代入匹配函数直至返回true

    b)      比较

    作用

    char*

    string

    CString

    查找指定值(区分大小写)

    strcmp

    strncmp

    strcoll

    _strncoll

    operator<

    operator>

    operator<=

    operator>=

    operator==

    operator!=

    Collate

    Compare

    查找指定值(不区分大小写)

    _stricmp

    _strnicmp

    _stricoll

    _strnicoll

    CollateNoCase

    CompareNoCase

    注:返回值如果<0则前面的值小于后面的值,反之亦然

    c)      替换

    作用

    char*

    string

    CString

    查找指定值

    _strset

    _strnset

    replace

    replace_copy

    replace_copy_if

    replace_if

    Replace

    d)      插入

    作用

    char*

    string

    CString

    查找指定值

    insert

    Insert

    e)       增加

    作用

    char*

    string

    CString

    动态增加值

    strcat

    push

    append

    Append

    AppendChar

    AppendFormat

    f)      截取

    作用

    char*

    string

    CString

    得到部分值

    用下标操作

    substr

    Left

    Mid

    Right

    Truncate

    g)      移除

    作用

    char*

    string

    CString

    移除部份值

    remove

    Remove

    移除空白值

    RemoveBlanks

    注:此为ATL提供,非C函数

    remove_if

    Trim

    TrimLeft

    TrimRigth

    h)      转换大小写

    作用

    char*

    string

    CString

    转换大小写

    _strlwr

    _strupr

    MakeLower

    MakeUpper

    i)       与其他类型转换

    作用

    char*

    string

    CString

    转化为数字

    atoi

    atod

    atof

    Format

    转化为char*

    c_str

    GetBuffer

    GetBufferSetLength

    j)       格式化

    作用

    char*

    string

    CString

    格式化

    sprintf

    Format

    k)      得到长度

    作用

    char*

    string

    CString

    得到长度

    strlen

    length

    GetLength

    得到大小

    size

    GetAllocLength

    l)      判断为空

    作用

    char*

    string

    CString

    判断是否为空

    判断是否==NULL或者第一个字符是否是’’

    empty

    IsEmpty

    m)        重定义大小

    作用

    char*

    string

    CString

    重定义大小

    realloc

    new

    resize

    GetBufferSetLength

    n)        释放资源

    作用

    char*

    string

    CString

    释放

    free

    delete (delete[])

    ReleaseBuffer

    ReleaseBufferSetLength

    (五)  安全性

    CString > string > char*;

    (六)  灵活性

    CString > string >char*;

    (七)  可移植性

    char* = string > CString

    (八)  MFC中常用字符串结构图(此非比较,但为了方便查阅就一并算在这儿了)

     

    (九)  总结

    综上所述,我个人认为,在MFC、ATL中使用字符串尽量使用CString,毕竟都是微软的孩子,各方面都比其它更有优势,而在非微软平台上或对移植性要求较高的场合推荐使用string,标准模板库提供了那么强大的泛型算法,没必要再自己去造车轮。

    (十)  参考文献

    主要参考的是MSDN,西安邮电学院计算机系  FLxyzsby@163.com FLxyzsby@yahoo.com.cn

  • 相关阅读:
    0101
    正则表达式 re模块
    经典算法>>mor-c3 / 删除排序
    网络编程
    面向对象>>类(三大特性:继承多态封装)>>反射,内置函数/方法,
    经典算法>冒泡 和二分法
    Apollo 5.0 障碍物行为预测技术
    一种新颖鲁棒的自动驾驶车辆换道轨迹规划方法
    自动驾驶中轨迹规划的探索和挑战
    Lattice Planner规划算法
  • 原文地址:https://www.cnblogs.com/xiao-fang/p/3344559.html
Copyright © 2011-2022 走看看