ATL CString

将网络上关于ATL的CString用法整理了一下

 

 

ATL中使用CString时，会提示说使用WTL::CString，(由于WTL也有CString，但却不受官方支持，最好使

用ATL的实现)而我们只需要使用ATL::CString就可以了，这时只需要在stdafx.h头文件中加如下面2句即

可：
 //注明使用ATL::CString而不是WTL::CString
 #define _WTL_NO_CSTRING
 #include <atlstr.h>
如果还有有问题，放到#include <atlapp.h>前试试。

 

 

来源 http://blog.sina.com.cn/s/blog_4ab2f5c8010006u2.html

 

 

    GetBuffer(int size)是用来返回一个你所指定大小可写内存的成员方法。它和被重载的操作符LPCTSTR还是有点本质区别的，LPCTSTR是直接返回一个只读内存的指针，而GetBuffer则是返回一个可以供调用者写入的内存，并且，你可以给定大小。下面是个简单的，但也是非常典型的例子：

 

 

 int readFile(CString& str, const CString& strPathName)

    {

        FILE* fp = fopen(strPathName, "r"); // 打开文件

        fseek(fp, 0, SEEK_END);

        int nLen = ftell(fp); // 获得文件长度

        fseek(fp, 0, SEEK_SET); // 重置读指针

        char* psz = str.GetBuffer(nLen);

        fread(psz, sizeof(char), nLen, fp); //读文件内容

        str.ReleaseBuffer(); //千万不能缺少

        fclose(fp);

    }

 

 

 

上面的函数是GetBuffer函数最典型的用法了，其实它就相当于申请一块nLen大小的内存，只不过，这块内存是被引用在CString对象的内部而已，这是非常有效的一种用法，如果不直接用GetBuffer函数来申请的话，那么你必须用new操作符（或者malloc()函数）在CString的外部申请，然后再将申请的内存拷贝到CString对象中，显然这是一个非常冗余的操作，会使你函数的效率大大下降。

    ReleaseBuffer函数是用来告诉CString对象，你的GetBuffer所引用的内存已经使用完毕，现在必须对它进行封口，否则CString将不会知道它现在所包含的字符串的长度，所以在使用完GetBuffer之后，必须立即调用ReleaseBuffer函数重置CString的内部属性，其实也就是头部信息。

 

来源 http://hi.baidu.com/idealsoft/blog/item/02d74322339097f6d6cae24e.html

 

 

 

CString str = "abcde/0cde";

输出字符串的值为: abcde

而字符串的长度为 s.GetLength() 的值为: 5

这是因为CString对象在赋值时只检查到'/0',后面的忽略了, 也就是说实际对象str内容为"abcde".

而str真正的存储空间为6(字符串以'/0'结尾).

所以说在字符长度和实际的空间是不一样的. 好!别跑!

请看下面有趣的程序:

 

CString str = "hello";

LPSTR pf = (LPSTR)(LPCSTR)s;

LPSTR pa = s.GetBuffer(0);

        你可以测得 pf == pa;

LPSTR pb = s.GetBuffer(10);

        你可以测得 pf != pb;

 

 

为什么:

 

我们都知道(LPSTR)(LPCSTR)s 实际指向对象str的实际字符串的内存地址, GetBuffer() 函数中的参数(其实就是重新申请的字符串的长度)如果小于等于先前的字符串长度, 则不会重新分配内存使用原来的内存所以 pf == pa, 如果大于先前的字符串长度, 则重新追加内存(也就是要复制原来的内容),

所以pf != pb.

 

 

注意GetBuffer()函数中的参数为重新申请的字符串的长度, 实际内存的大小应再加1.

 

 

CString s = "hello";

LPSTR pf = s.GetBuffer(0);

strcpy(pf,"hi");

这时对象str 的内容为 "hi"

但是s.GetLength()的值为5, 如果加上一条语句:

s.ReleaseBuffer();

则s.GetLength()的值为2

 

解释: 

CString对象在内存中用一个计数器来维持可用缓冲区的大小

void ReleaseBuffer( int nNewLength = -1 )

     {

          if( nNewLength == -1 )

          {

               nNewLength = StringLength( m_pszData );

          }

          SetLength( nNewLength );

     }

很明显ReleaseBuffer的作用就是更新字符串的长度。 CString内，GetLength获取字符串长度并不是动态计算的，而是在赋值操作后计算并保存在一个int变量内的，当通过GetBuffer直接修改CString时，那个int变量并不可能自动更新，于是便有了ReleaseBuffer.

 

 

CString s = "hello";

LPSTR pf = s.GetBuffer(0);

strcpy(pf,"hi");

LPSTR ps = (LPSTR)(LPCSTR)s;    字符串缓冲区的首地址

*(ps+2) = 'x';

                            则字符串的实际内容为:    "hixlo"

*(ps+6) = 'a';        出错, 因为对象s的实际空间为 6

 

 

而

CString s = "hello";

LPSTR pf = s.GetBuffer(10);

strcpy(pf,"hi");

LPSTR ps = (LPSTR)(LPCSTR)s;    字符串缓冲区的首地址

*(ps+2) = 'x';

*(ps+5)= '/0';

                        则字符串的实际内容还是为:    "hixlo"

*(ps+6) = 'a';         可以因为s对象的实际空间为11

 

 

说白了 ReleaseBuffer就是更新赋值之后的字符串的长度, 而实际空间没有根本的变化, GetBuffer才是使内存空间大小变化的罪魁祸首.

 

 

有兴趣的可以测试一下就知道了!!!

 

来源 : http://blog.csdn.net/shyboy_NWPU/archive/2009/07/16/4352602.aspx

 

自定义字符串管理器的实现（基本方法）

为字符串数据自定义内存分配方案的最简单的方式是使用 ATL 提供的 CAtlStringMgr 类，但您需要自己提供内存分配例程。CAtlStringMgr 的构造函数采用单一参数：即指向 IAtlMemMgr 对象的指针。IAtlMemMgr 是提供到堆的一般接口的抽象基类。通过 IAtlMemMgr 接口，CAtlStringMgr 分配、重新分配和释放用于存储字符串数据的内存。您既可以自已实现 IAtlMemMgr 接口，也可以使用由 ATL 提供的五个内存管理器类之一。ATL 提供的内存管理器只包装现有的内存分配功能：

• CCRTHeap   包装标准 CRT 堆功能（malloc、free 和 realloc）
• CWin32Heap   使用 HeapAlloc、HeapFree 和 HeapRealloc 包装 Win32 堆句柄
• CLocalHeap   包装 Win32 API：LocalAlloc、LocalFree 和 LocalRealloc
• CGlobalHeap   包装 Win32 API：GlobalAlloc、GlobalFree 和 GlobalRealloc
• CComHeap   包装 COM 任务分配器 API：CoTaskMemAlloc、CoTaskMemFree 和 CoTaskMemRealloc

要进行字符串内存管理，最有用的类是 CWin32Heap，因为它使您能够创建多个独立的堆。例如，如果使用仅用于字符串的独立堆，可进行以下操作：

 复制代码

//Declare a thread-safe, growable, private heap with initial size 0CWin32Heap g_stringHeap( 0, 0, 0 );// Declare a string manager that uses the private heapCAtlStringMgr g_stringMgr( &g_stringHeap ); 

要使用此专用的字符串管理器来管理 CString 变量的内存，请将一个指针传递给管理器作为 CString 变量的构造函数的一个参数：

 复制代码

void PrintPowers( int nBase ){int n = 1;for( int nPower = 0; nPower < 10; nPower++ ){// Use the private string manager, instead of the defaultCString strPower( &g_stringMgr );strPower.Format( "%d", n );printf( "%s/n", LPCSTR( strPower ) );n *= nBase;}}

http://blog.csdn.net/zero_dian/archive/2006/01/08/573352.aspx  谈新手对CString的使用
CString类功能强大,比STL的string类有过之无不及.新手使用CString时,都会被它强大的功能所吸引.然而由于对它内部机制的不了解,新手在将CString向C的字符数组转换时容易出现很多问题.因为CString已经重载了LPCTSTR运算符,所以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 *.很多人对LPCTSTR是什么东西迷惑不解,让我们来看看: 

　　1.LP表示长指针,在win16下有长指针(LP)和短指针(P)的区别,而在win32下是没有区别的,都是32位.所以这里的LP和P是等价的. 

　　2.C表示const 

　　3.T是什么东西呢,我们知道TCHAR在采用UNICODE方式编译时是wchar_t,在普通时编译成char那么就可以看出LPCTSTR(PCTSTR)在UINCODE时是const wchar_t *,PCWSTR,LPCWSTR,在多字节字符模式时是const char *, PCSTR,LPCSTR.接下来我们看在非UNICODE情况下,怎样将CString转换成char *,很多初学者都为了方便采用如下方法: 
　　(char *)(LPCSTR)str 

　　这样对吗?我们首先来看一个例子: 
　　CString str("aa"); 
　　strcpy((char *)(LPCTSTR)str,"aaaaaaaa"); 
　　cout<<(LPCTSTR)str<<endl; 

　　在Debug下运行出现了异常,我们都知道CString类内部有自己的字符指针,指向一个已分配的字符缓冲区.如果往里面写的字符数超出了缓冲区范围,当然会出现异常.但这个程序在Release版本下不会出现问题.原来对CString类已经进行了优化.当需要分配的内存小于64字节时,直接分配64字节的内存,以此类推,一般CString类字符缓冲区的大小为64,128,256,512...这样是为了减少内存分配的次数,提高速度. 

　　那有人就说我往里面写的字符数不超过它原来的字符数,不就不会出错了,比如 
　　CString str("aaaaaaa"); 
　　strcpy((char *)(LPCTSTR)str,"aa"); 
　　cout<<(LPCTSTR)str<<endl; 

　　这样看起来是没什么问题.我们再来看下面这个例子: 
　　CString str("aaaaaaa"); 
　　strcpy((char *)(LPCTSTR)str,"aa"); 
　　cout<<(LPCTSTR)str<<endl; 
　　cout<<str.GetLength()<<endl; 

　　我们看到str的长度没有随之改变,继续为7而不是2.还有更严重的问题: 
　　CString str("aaaaaaa"); 
　　CString str1 = str; 
　　strcpy((char *)(LPCTSTR)str,"aa"); 
　　cout<<(LPCTSTR)str<<endl; 
　　cout<<(LPCTSTR)str1<<endl; 

　　按说我们只改变了str,str1应该没有改变呀,可是事实时他们都变成了"aa".难道str和str1里面的字符指针指向的缓冲区是一个.我们在Effective C++里面得知,如果你的类内部有包含指针,请为你的类写一个拷贝构造函数和赋值运算符.不要让两个对象内部的指针指向同一区域,而应该重新分配内存.难道是微软犯了错? 

　　原来这里还有一个"写时复制"和"引用计数"的概念.CString类的用途很广,这样有可能在系统内部产生大量的CString临时对象.这时为了优化效率,就采用在系统软件内部广泛使用的"写时复制"概念.即当从一个CString产生另一个CString并不复制它的字符缓冲区内容,而只是将字符缓冲区的"引用计数"加1.当需要改写字符缓冲区内的内容时,才分配内存,并复制内容.以后我会给出一个"写时复制"和"引用计数"的例子我们回到主题上来,当我们需要将CString转换成char *时,我们应该怎么做呢?其时只是麻烦一点,如下所示: 
　　CString str("aaaaaaa"); 
　　strcpy(str.GetBuffer(10),"aa"); 
　　str.ReleaseBuffer(); 

　　当我们需要字符数组时调用GetBuffer(int n),其中n为我们需要的字符数组的长度.使用完成后一定要马上调用ReleaseBuffer();还有很重要的一点就是,在能使用const char *的地方,就不要使用char * 

 

来源：http://www.cppblog.com/elva/archive/2008/12/22/70076.html