Win编程笔记：字符串小结

亦凉 2022-05-15 03:28 223阅读 0赞

**Win** **编程笔记：字符串小结**

JasonLee @ [http://blog.csdn.net/jasonblog][http_blog.csdn.net_jasonblog]

Basics

ANSI 和 Unicode ：

前者是单字节字符编码，用来表示英语以及一些西欧语言的所有字符；后者是双字节字符编码，可以表示现代计算机涉及的所有字符（包括中文、日文等）。

显然，使用 Unicode 更有利于国际化和本地化。除此之外， Windows 所有核心函数也都需要 Unicode 字符串。在调用这些函数时，如果传入 ANSI 字符串，那么这些函数会将其转换成 Unicode 再执行；反之，如果函数返回 ANSI 字符串，那么操作系统也是先将其从 Unicode 字符串转换为 ANSI 字符串再返回。这样的话，会增加开销，而且埋下一些目前已知的转换函数中存在的 bug 。

使用 Unicode ：

ANSI 字符是由 char 类型来表示的，而在 win 编程中， Unicode 字符由 wchar\_t （ wide char type ）来表示的。在使用 wchar\_t 类型时，需要在字符 / 字符串前加上大写字母 L 来告诉编译器这是 Unicode 字符 / 字符串，如下：

wchar\_t c = L 'a' ;

wchar\_t str \[10\] = L "hello" ;

为了更有 Windows 特色，微软做了如下类型定义（ WinNT.h ）：

typedef char CHAR ;

typedef short SHORT ;

typedef long LONG ;

……

typedef wchar\_t WCHAR ;

在前面加 P 、 LP 或者 C 分别表示指针类型和 Const 限定，如：

typedef \_\_nullterminated WCHAR \*NWPSTR , \*LPWSTR , \*PWSTR ;

……

typedef \_\_nullterminated CONST WCHAR \*LPCWSTR , \*PCWSTR ;

……

typedef \_\_nullterminated CHAR \*NPSTR , \*LPSTR , \*PSTR ;

……

typedef \_\_nullterminated CONST CHAR \*LPCSTR , \*PCSTR ;

此外，为了更通用一点，微软还做了如下定义：

\#ifdef UNICODE // r\_winnt

\#ifndef \_TCHAR\_DEFINED

typedef WCHAR TCHAR , \*PTCHAR ;

……

\#define \_\_TEXT (quote ) L \# \#quote // r\_winnt

\#else /\* UNICODE \*/ // r\_winnt

\#ifndef \_TCHAR\_DEFINED

typedef char TCHAR, \*PTCHAR;

……

\#define \_\_TEXT(quote) quote // r\_winnt

\#endif /\* UNICODE \*/ // r\_winnt

\#define TEXT (quote ) \_\_TEXT (quote ) // r\_winnt

即，使用 TCHAR （以及 PTSTR ），无论字符集是 ANSI 还是 Unicode 都可以通过编译，与之相应的通用字符串函数也出现了，比如 \_tcslen （ tchar.h ）：

\#ifdef \_UNICODE

\#define \_tcslen wcslen

\#else

\#define \_tcslen strlen

\#endif

除了 \_tcslen ，还有一堆其他的字符串处理函数，并且与 \_tcslen （计算字符串长度）不同，其它很多函数需要考虑安全性，比如 \_tcscpy 或者 \_tcscat ：

\#ifdef \_UNICODE

\#define \_tcscat wcscat

\#define \_tcscat\_s wcscat\_s

\#define \_tcscpy wcscpy

\#define \_tcscpy\_s wcscpy\_s

\#else

\#define \_tcscat strcat

\#define \_tcscat\_s strcat\_s

\#define \_tcscpy strcpy

\#define \_tcscpy\_s strcpy\_s

\#endif

紧接着处理函数的都是一个安全版本，这些安全性函数都是添加一个 \_s 后缀，它们检验参数的有效性以及缓冲区是否足以容纳结果。

最后， WinNT.h 中还定义了宏 TEXT 、 \_\_TEXT ， tchar.h 中定义了宏 \_T 、 \_\_T 、 \_TEXT ，这些宏的功能都是将字符 / 字符串转换为相应的通用类型，比如：

LPTSTR str1 = \_T ("hello,world" );

LPTSTR str2 = TEXT ("hello" );

ATL 字符串

COM 字符类型

OLECHAR ：不同操作系统上， OLECHAR 对应不同字符类型，比如 win32 上对应 wchar\_t 。

BSTR ：一种带长度前缀、含许多特殊语义的 OLECHAR 字符数组。

ATL 字符串转换类

所有类名称都采用“ C< 源格式缩写 >2< 目标格式缩写 > ”的形式，第一个 C 表示类。缩写中 A 代表指向 char 的字符指针（ LPSTR ）、 W 代表指向 wchar\_t 的字符指针（ LPWSTR ）、 T 代表指向 TCHAR 的字符指针（ LPTSTR ）、 OLE 代表指向 OLECHAR 的字符指针（ LPOLESTR ）、 C 表示 const 限定符。

以下是字符串转换类：

CA2W CA2WEX CA2T CA2TEX CA2CT CA2CTEX

COLE2T COLE2TEX COLE2CT COLE2CTEX CT2A

CT2AEX CT2CA CT2CAEX CT2OLE CT2OLEEX CT2COLE

CT2COLEEX CT2W CT2WEX CT2CW CT2CWEX CW2A

CW2AEX CW2T CW2TEX CW2CT CW2CTEX

BSTR 与 CComBSTR

BSTR 是指向复合数据类型的指针，该复合数据类型由长度前缀、数据字符串和结束符组成，并且要使用 COM 内存管理函数来管理 BSTR ，其专用语义繁多，用法繁琐。

CComBSTR 是 BSTR 的一个封装类。

CComBSTR

CComBSTR 类维护一个 BSTR 类型的 public 成员 m\_str 。

使用小结如下：

//CComBSTR 使用小结

//1. 构造

//CComBSTR() \{ m\_str = NULL; \}

CComBSTR str1 ;

//CComBSTR(LPCOLESTR pSrc);

CComBSTR str2 (LPCOLESTR ("hello,world" ));

//CComBSTR(int nSize, LPCOLESTR sz);

CComBSTR str3 (5, (LPCOLESTR )NULL );

//CComBSTR(int nSize);

CComBSTR str4 (5);

//CComBSTR(LPCSTR pSrc);

CComBSTR str5 ("hello,world" );

//CComBSTR(int nSize, LPCSTR sz);

CComBSTR str6 (5, "hello,world" );

//CComBSTR(REFGUID src);

static const GUID id\_sample =

\{ 0x3d8b3644, 0xf90e, 0x4058, \{ 0x95, 0xaf, 0xda, 0x5a, 0xe8, 0x81, 0x8, 0x98 \} \};

CComBSTR str7 (id\_sample );

//2. 复制构造函数

//CComBSTR(const CComBSTR& src);

CComBSTR str8 (str2 );

//3. 析构

//~CComBSTR() \{::SysFreeString(m\_str); \}

//4. 赋值

//CComBSTR& operator=(const CComBSTR& src)\{ ... m\_str = src.Copy(); ...\}

str3 = str2 ;

//CComBSTR& operator=(LPCOLESTR pSrc)\{ ... m\_str = ::SysAllocString(pSrc); ... \}

str8 = LPCOLESTR ("hello,world" );

//CComBSTR& operator=(LPCSTR pSrc)\{ ... m\_str = A2WBSTR(pSrc); ... \}

str1 = "hello,world" ;

//HRESULT AssignBSTR(const BSTR bstrSrc)\{ ... \}

BSTR bstrTemp = ::SysAllocString (LPCOLESTR ("hello,world" ));

CComBSTR str9 ;

str9 .AssignBSTR (bstrTemp );

//bool LoadString(HINSTANCE hInst, UINT nID);

// 从指定模块hInst 加载指定的字符串资源nID

//bool LoadString(UINT nID);

// 使用全局变量\_AtlBaseModule 从当前模块加载指定的字符串资源nID

//5. 字符串连接

//HRESULT Append(LPCOLESTR lpsz, int nLen);

//HRESULT Append(LPCOLESTR lpsz);

//HRESULT Append(LPCSTR);

//HRESULT Append(char ch);

//HRESULT Append(wchar\_t ch);

//HRESULT Append(const CComBSTR& bstrSrc);

//HRESULT AppendBSTR(BSTR p);

//HRESULT AppendBytes(const char \* lpsz, int nLen);

//CComBSTR& operator+=(const CComBSTR& bstrSrc);

//6. 字符串比较

//bool operator !() const \{ return (m\_str == NULL); \}

//operator<() 一共有四个重载版本，后面个都是调用第一个，第一个使用VarBstrCmp 进行比较

//bool operator<(const CComBSTR& bstrSrc) const\{ ... \}

//bool operator<(LPCSTR pszSrc) const\{ ... \}

//bool operator<(LPCOLESTR pszSrc) const\{ ... \}

//bool operator<(LPOLESTR pszSrc) const\{ ... \}

//operator>() 与operator<() 类似

//operator!=() 和operator==() 则多重载了一个与NULL 比较的版本

//7. 其它操作

// 返回长度

//unsigned int Length() const \{ return ::SysStringLen(m\_str); \}

unsigned int len = str2 .Length ();

// 复制操作

//BSTR Copy() \{ ... \}

//HRESULT CopyTo(BSTR\* pbstr);

// 转换操作

str2 .ToLower ();

str2 .ToUpper ();

//HRESULT BSTRToArray(LPSAFEARRAY \* ppArray)\{ ... \}

//HRESULT ArrayToBSTR(const SAFEARRAY \* pSrc)\{ ... \}

// 清空操作

str1 .Empty ();

// 附加和分离BSTR

//BSTR Detach() \{ BSTR s = m\_str; m\_str = NULL; return s; \}

//void Attach(BSTR src)\{

// if(m\_str != src)\{

// ::SysFreeString(m\_str);

// m\_str = src;

// \}

//\}

CString

从简，使用 CString ，本质是使用 CStringT 模板类。

typedef CStringT < wchar\_t , StrTraitATL < wchar\_t , ChTraitsCRT < wchar\_t > > > CAtlStringW ;

typedef CStringT < char , StrTraitATL < char , ChTraitsCRT < char > > > CAtlStringA ;

typedef CStringT < TCHAR , StrTraitATL < TCHAR , ChTraitsCRT < TCHAR > > > CAtlString ;

……

typedef CAtlStringW CStringW ;

typedef CAtlStringA CStringA ;

typedef CAtlString CString ;

……

template < typename BaseType , class StringTraits >

class CStringT :

public CSimpleStringT ……

CStringT 继承 CSimpleStringT ，该基类提供了很多基本字符串功能； BaseType 模板参数用来确定字符类型，数据保存在基类私有成员 m\_pszData 中； StringTraits 参数确定资源字符串加载的模块、字符串管理器以及提供低级的字符操作。 ATL 提供了默认的字符串管理器，该管理器是一个实现了 IAtlStringMgr 的具体类 CAtlStringMgr 。

CStringT 采用了类型定义来处理一些语法分支， XCHAR 、 PXSTR 、 PCXSTR 代表与模板参数一致的字符类型，而 YCHAR 、 PYSTR 、 PCYSTR 相反。比如如果 BaseType 为 char ，则 XCHAR 代表 char ， YCHAR 代表 wchar\_t ，相应的 PXSTR 为 LPSTR ， PYSTR 为 LPWSTR 。

基本使用小结如下：

//CStringT 基本使用小结

//1. 构造函数

//CStringT();

//explicit CStringT( IAtlStringMgr\* pStringMgr );

//CStringT( const CStringT& strSrc );

//CStringT( const CThisSimpleString& strSrc );

//CStringT( const XCHAR\* pszSrc );

//CStringT( const XCHAR\* pch, int nLength );

//CStringT( const XCHAR\* pch, int nLength, IAtlStringMgr\* pStringMgr );

//CStringT( PXSTR pszSrc, IAtlStringMgr\* pStringMgr );

// 以上例，与之相反的YCHAR 和PYSTR 也可

CStringA caStr1 (L "hello,world" );

CStringW cwStr1 ("hello,world" );

CString cStr1 ;

CString cStr2 (cStr1 );

CString cStr3 ("hello,world" );

CString cStr4 ('a' , 5);

//2. 赋值

//CStringT& operator=( const CStringT& strSrc );

//CStringT& operator=( const CThisSimpleString& strSrc );

//CStringT& operator=( PCXSTR pszSrc );

//CStringT& operator=( XCHAR ch );

// 以上两例，YCHAR 和PCYSTR 也可

caStr1 = L 'b' ;

cwStr1 = 'a' ;

cStr1 = "hello,world" ;

cStr1 = L "hello,world" ;

//3. 字符串连接

//CStringT& operator+=( const CThisSimpleString& str );

//CStringT& operator+=( const PCXSTR pszSrc );

//CStringT& operator+=( const XCHAR ch );

// 以上两例，PCYSTR 和YCHAR 也可

caStr1 \+= L 'a' ;

cwStr1 \+= L "new" ;

cStr1 \+= cStr2 ;

//+ 运算

cStr1 \+ cStr2 ;

cStr1 \+ L 'a' ;

cwStr1 \+ 'a' ;

//Append

//void Append( PCXSTR pszSrc );

//void Append( PCXSTR pszSrc, int nLength );

//void Append( const CSimpleStringT& strSrc );

//void AppendChar( XCHAR ch );

//4. 转换

cStr1 .MakeLower ();

cStr1 .MakeUpper ();

cStr1 .MakeReverse ();

//5. 比较

//== != < >

caStr1 == L "hello,world" ;

cwStr1 != "hello,world" ;

cStr1 < cStr2 ;

//6. 其它操作

// 增

//int Insert( int iIndex, PCXSTR psz )

//int Insert( int iIndex, XCHAR ch )

cStr1 .Insert (0, 'a' );

// 删

// 从iIndex 开始删除nCount 个字符

//int Delete( int iIndex, int nCount = 1 )

// 删除所有chRemove 字符

//int Remove( XCHAR chRemove )

// 改

//int Replace( XCHAR chOld, XCHAR chNew )

//int Replace( PCXSTR pszOld, PCXSTR pszNew )

// 查

//int Find( XCHAR ch, int iStart = 0 ) const

//int Find( PCXSTR pszSub, int iStart = 0 ) const

//int FindOneOf( PCXSTR pszCharSet ) const

//int ReverseFind( XCHAR ch ) const

//CStringT Left( int nCount ) const

//CStringT Mid( int iFirst ) const

//CStringT Mid( int iFirst, int nCount ) const

//CStringT Right( int nCount ) const

//XCHAR operator\[\]( int iChar ) const

str1 \[3\];

//Trim 方法

//CStringT& Trim()

//CStringT& Trim( XCHAR chTarget )

//CStringT& Trim( PCXSTR pszTargets )

//CStringT& TrimLeft()

//CStringT& TrimLeft( XCHAR chTarget )

//CStringT& TrimLeft( PCXSTR pszTargets )

//CStringT& TrimRight()

//CStringT& TrimRight( XCHAR chTarget )

//CStringT& TrimRight( PCXSTR pszTargets )

// 按指定字符分割

//CStringT Tokenize( PCXSTR pszTokens, int & iStart ) const

//CStringT 格式化

//void \_\_cdecl Format( PCXSTR pszFormat, ... );

//void \_\_cdecl Format( UINT nFormatID, .. );

参考资料：

《 Windows 核心编程》

《深入解析 ATL 》

[http_blog.csdn.net_jasonblog]: http://blog.csdn.net/jasonblog

Win编程笔记：字符串小结

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 C++分割字符串小结

相关面向对象编程小结（学习笔记）

相关网络编程小结

相关 win 7 的有点小结

相关 Win编程笔记：字符串小结

相关网络编程小结

相关 js处理字符串小结

相关 Win10安装Postgresql小结

相关 13.字符串小结

相关字符串知识小结