Cstring转化成char*后的问题

CString str="string";
str.insert( 0 , "test ");
这样就可以了

有getbuffer为何不用,把一个类对象前置转化为char*是危险的

CString str = "dsfdsafsf"
char* pStr = str.GetBuffer( 0 )

就是试试不用GetBuffer看看有没有方法解决，我用GetBuffer就可以搞定的
将cstring转化为char*后如用p修改了数据后str并不知道它改变了，现在怎么让str知道它已经被修改了

强制转化是不对的,在我这里CString是无法通过强制转化到char*的

晕，这样p = (BYTE *)(LPCTSTR)str;

CString的缓冲区是动态分配的，如果直接取缓冲区来修改，当长度超过其缓冲区长度时就会出问题。除非你替换掉它的缓冲区。
应该这样：
CString str = "test";
str += " ";
str += "string";

问题是我的程序里有些操作不用直接用CString来实现，转换为char后才好操作

p = (char *)(LPCTSTR)str; 这句没错strcpy(p, "test "); 这句就有问题了，CString重载了LPCTSTR，LPCTSTR=const TCHAR* 你强制转换成const指针怎么能修改其中内容？p是你CString里的指针地址，使用strcpy时你无法保证缓冲区是否会溢出，尤其是在debug模式下，内存是精确分配的，会报异常，在release模式下，为提高效率，内存是以64的倍数分配，可能不会报异常，不过这种做法也是相当危险的最好是强制转换后，复制到另一个安全的地方，再进行操作

这个帖子
关于CString总结前言：串操作是编程中最常用也最基本的操作之一。做为VC程序员，无论是菜鸟或高手都曾用过Cstring。而且好像实际编程中很难离得开它（虽然它不是标准Ｃ++中的库）。因为MFC中提供的这个类对我们操作字串实在太方便了，CString不仅提供各种丰富的操作函数、操作符重载，使我们使用起串起来更象basic中那样直观；而且它还提供了动态内存分配，使我们减少了多少字符串数组越界的隐患。但是，我们在使用过程中也体会到CString简直太容易出错了，而且有的不可捉摸。所以有许多高人站过来，建议抛弃它。在此，我个人认为：CString封装得确实很完美，它有许多优点，如“容易使用，功能强，动态分配内存，大量进行拷贝时它很能节省内存资源并且执行效率高，与标准Ｃ完全兼容，同时支持多字节与宽字节，由于有异常机制所以使用它安全方便” 其实，使用过程中之所以容易出错，那是因为我们对它了解得还不够，特别是它的实现机制。因为我们中的大多数人，在工作中并不那么爱深入地去看关于它的文档，何况它还是英文的。由于前几天我在工作中遇到了一个本不是问题但却特别棘手、特别难解决而且莫名惊诧的问题。好来最后发现是由于CString引发的。所以没办法，我把整个CString的实现全部看了一遍，才慌然大悟，并彻底弄清了问题的原因(这个问题，我已在csdn上开贴)。在此，我想把我的一些关于CString的知识总结一番，以供他（她）人借鉴，也许其中有我理解上的错误，望发现者能通知我，不胜感谢。1． CString实现的机制.   CString是通过“引用”来管理串的，“引用”这个词我相信大家并不陌生，象Window内核对象、COM对象等都是通过引用来实现的。而CString也是通过这样的机制来管理分配的内存块。实际上CString对象只有一个指针成员变量,所以任何CString实例的长度只有4字节.       即: int len = sizeof(CString);//len等于4这个指针指向一个相关的引用内存块，如图:   CString   str("abcd");
                                                                                          ___
            ____________                                                     |       |
          |                         |                                                   |       |
          |   0x04040404   |                                                   |       |     head部，为引用内存块相关信息
          |____________|                                                   |       |
                    str                                                               |___|
                                                                                        |'a'|   0x40404040
                                                                                        |'b'|
                                                                                        |'c'|
                                                                                        |'d'|
                                                                                        |   0   |

  正因为如此，一个这样的内存块可被多个CString所引用，例如下列代码：   CString str("abcd");CString a = str;CString b(str);CString c;c = b;上面代码的结果是：上面四个对象(str,a,b,c)中的成员变量指针有相同的值，都为0x40404040.而这块内存块怎么知道有多少个CString引用它呢？同样，它也会记录一些信息。如被引用数，串长度，分配内存长度。这块引用内存块的结构定义如下：struct CStringData{  long nRefs;       //表示有多少个CString 引用它. 4  int nDataLength;  //串实际长度. 4  int nAllocLength; //总共分配的内存长度（不计这头部的12字节）. 4};由于有了这些信息，CString就能正确地分配、管理、释放引用内存块。如果你想在调试程序的时候获得这些信息。可以在Watch窗口键入下列表达式：(CStringData*)((CStringData*)(this->m_pchData)-1)或(CStringData*)((CStringData*)(str.m_pchData)-1)//str为指CString实例正因为采用了这样的好机制，使得CString在大量拷贝时，不仅效率高，而且分配内存少。 2．LPCTSTR 与 GetBuffer(int nMinBufLength) 这两个函数提供了与标准C的兼容转换。在实际中使用频率很高，但却是最容易出错的地方。这两个函数实际上返回的都是指针，但它们有何区别呢？以及调用它们后，幕后是做了怎样的处理过程呢？  (1) LPCTSTR 它的执行过程其实很简单，只是返回引用内存块的串地址。它是作为操作符重载提供的，所以在代码中有时可以隐式转换，而有时却需强制转制。如：          CString str;          const char* p = (LPCTSTR)str;          //假设有这样的一个函数，Test(const char* p)；  你就可以这样调用          Test(str);//这里会隐式转换为LPCTSTR  (2) GetBuffer(int nMinBufLength) 它类似，也会返回一个指针，不过它有点差别,返回的是LPTSTR  (3) 这两者到底有何不同呢？我想告诉大家，其本质上完全不一样，一般说LPCTSTR转换后只应该当常量使用，或者做函数的入参；而GetBuffer(...)取出指针后，可以通过这个指针来修改里面的内容，或者做函数的出参。为什么呢？也许经常有这样的代码：        CString str("abcd");        char* p = (char*)(const char*)str;        p[2] = 'z';         其实，也许有这样的代码后，你的程序并没有错，而且程序也运行得挺好。但它却是非常危险的。再看        CString str("abcd");        CString test = str;        ....        char* p = (char*)(const char*)str;        p[2] = 'z';     // 转换成LPCTSTR后，千万不能改变CString对象的值        strcpy(p, "akfjaksjfakfakfakj");//这下完蛋了         你知道此时，test中的值是多少吗？答案是"abzd"。它也跟着改变了，这不是你所期望发生的。但为什么会这样呢？你稍微想想就会明白，前面说过，因为CString是指向引用块的，str与test指向同一块地方,当你p[2]='z'后，当然test也会随着改变。所以用它做LPCTSTR做转换后，你只能去读这块数据，千万别去改变它的内容。      假如我想直接通过指针去修改数据的话，那怎样办呢？就是用GetBuffer(...).看下述代码：        CString str("abcd");        CString test = str;        ....        char* p = str.GetBuffer(20);        p[2] = 'z';  //   执行到此，现在test中值却仍是"abcd"        strcpy(p, "akfjaksjfakfakfakj");   //    执行到此，现在test中值还是"abcd"为什么会这样？其实GetBuffer(20)调用时，它实际上另外建立了一块新内块存，并分配20字节长度的buffer，而原来的内存块引用计数也相应减1.  所以执行代码后str与test是指向了两块不同的地方，所以相安无事。(4) 不过这里还有一点注意事项：就是str.GetBuffer(20)后，str的分配长度为20，即指针p它所指向的buffer只有20字节长，给它赋值时，切不可超过，否则灾难离你不远了；如果指定长度小于原来串长度，如GetBuffer(1),实际上它会分配4个字节长度（即原来串长度）；另外，当调用GetBuffer(...)后并改变其内容，一定要记得调用ReleaseBuffer(),这个函数会根据串内容来更新引用内存块的头部信息。   (5) 最后还有一注意事项，看下述代码：      char* p = NULL;      const char* q = NULL;      {          CString str = "abcd";          q = (LPCTSTR)str;          p = str.GetBuffer(20);          AfxMessageBox(q);// 合法的          strcpy(p, "this is test");//合法的，      }      AfxMessageBox(q);// 非法的，可能完蛋      strcpy(p, "this is test");//非法的，可能完蛋     这里要说的就是，当返回这些指针后，如果CString对象生命结束，这些指针也相应无效。 3．拷贝 & 赋值 & "引用内存块" 什么时候释放？   下面演示一段代码执行过程   void Test()   {CString str("abcd");//str指向一引用内存块（引用内存块的引用计数为1,长度为4,分配长度为4）CString a;//a指向一初始数据状态，a = str;//a与str指向同一引用内存块（引用内存块的引用计数为2,长度为4,分配长度为4）CString b(a);//a、b与str指向同一引用内存块（引用内存块的引用计数为3,长度为4,分配长度为4）     {        LPCTSTR temp = (LPCTSTR)a;//temp指向引用内存块的串首地址。（引用内存块的引用计数为3,长度为4,分配长度为4）        CString d = a;//a、b、d与str指向同一引用内存块（引用内存块的引用计数为4,                                长度为4,分配长度为4）        b = "testa";//这条语句实际是调用CString::operator=(CString&)函数。                    b指向一新分配的引用内存块。（新分配的引用内存块的                       引用计数为1, 长度为5, 分配长度为5）//同时原引用内存块引用计数减1. a、d与str仍指向原                      引用内存块（引用内存块的引用计数为3,长度为4,分配长度为4）                     }//由于d生命结束，调用析构函数，导至引用计数减1（引用内存块的引用计数为2,长度为4,分配长度为4）LPTSTR temp = a.GetBuffer(10);//此语句也会导致重新分配新内存块。temp指向新分配引用内存块的串首地址（新                                   分配的引用内存块的引用计数为1,长度为0,分配长度为10）//同时原引用内存块引用计数减1.  只有str仍                                     指向原引用内存块（引用内存块的引用计数为1,                                     长度为4, 分配长度为4）                      strcpy(temp, "temp"); //a指向的引用内存块的引用计数为1,长度为0,分配长度为10 a.ReleaseBuffer();//注意:a指向的引用内存块的引用计数为1,长度为4,分配长度为10   }   //执行到此，所有的局部变量生命周期都已结束。对象str a b 各自调用自己的析构构   //函数，所指向的引用内存块也相应减1   //注意，str a b 所分别指向的引用内存块的计数均为0,这导致所分配的内存块释放       通过观察上面执行过程，我们会发现CString虽然可以多个对象指向同一引用内块存，但是它们在进行各种拷贝、赋值及改变串内容时，它的处理是很智能并且非常安全的，完全做到了互不干涉、互不影响。当然必须要求你的代码使用正确恰当，特别是实际使用中会有更复杂的情况，如做函数参数、引用、及有时需保存到CStringList当中，如果哪怕有一小块地方使用不当，其结果也会导致发生不可预知的错误 5  FreeExtra()的作用   看这段代码   (1)   CString str("test");   (2)   LPTSTR temp = str.GetBuffer(50);   (3)   strcpy(temp, "there are 22 character");   (4)   str.ReleaseBuffer();   (5)   str.FreeExtra();   上面代码执行到第(4)行时，大家都知道str指向的引用内存块计数为1,长度为22,分配长度为50. 那么执行str.FreeExtra()时，它会释放所分配的多余的内存。(引用内存块计数为1,长度为22,分配长度为22) 6  Format(...)  与 FormatV(...)   这条语句在使用中是最容易出错的。因为它最富有技巧性，也相当灵活。在这里，我没打算对它细细分析，实际上sprintf(...)怎么用，它就怎么用。我只提醒使用时需注意一点：就是它的参数的特殊性，由于编译器在编译时并不能去校验格式串参数与对应的变元的类型及长度。所以你必须要注意，两者一定要对应上，   否则就会出错。如：   CString str;   int a = 12;   str.Format("first:%l, second: %s", a, "error");//result?试试 7  LockBuffer() 与 UnlockBuffer()   顾名思议，这两个函数的作用就是对引用内存块进行加锁及解锁。但使用它有什么作用及执行过它后对CString串有什么实质上的影响。其实挺简单，看下面代码:   (1)   CString str("test");   (2)   str.LockBuffer();   (3)   CString temp = str;   (4)   str.UnlockBuffer();   (5)   str.LockBuffer();   (6)   str = "error";

(7) str.ReleaseBuffer(); 执行完(3)后，与通常情况下不同，temp与str并不指向同一引用内存块。你可以在watch窗口用这个表达式(CStringData*)((CStringData*)(str.m_pchData)-1)看看。其实在msdn中有说明： While in a locked state, the string is protected in two ways: No other string can get a reference to the data in the locked string, even if that string is assigned to the locked string. The locked string will never reference another string, even if that other string is copied to the locked string. 8 CString 只是处理串吗？不对，CString不只是能操作串，而且还能处理内存块数据。功能完善吧！看这段代码 char p[20]; for(int loop=0; loop<sizeof(p); loop++) { p[loop] = 10-loop; } CString str((LPCTSTR)p, 20); char temp[20]; memcpy(temp, str, str.GetLength()); str完全能够转载内存块p到内存块temp中。所以能用CString来处理二进制数据

我就是想用char指针修改str后用操作符”+“插入几个字符

CString str;
str.GetBufferSetLength(5);
char *p; p = (char *)(LPCTSTR)str; strcpy(p, "test "); str += "string";

CString str;
str.GetBufferSetLength(5);
char *p; p = (char *)(LPCTSTR)str; strcpy(p, "test "); str += "string";
提前给CString 分配空间就可以这样用。

不分配空间，用strcpy（），CString的计数器不增加，再用str += 相当用计数器还是0；

我只说一句,我这里的CString是UNICODE编码的,你转化char* .......

可以调试看，到str += "string";这句执行完，p 和str中存储数据首地址已不一样，
为什么能(LPCTSTR)str强制转换，是因为CString第一个成员变量是存储数据的字符指针，要不然就无法转换。
CString str后存储数据的字符指针没申请空间，strcpy（），相当于给没申请空间的指针赋值，到str += "string";CString类蔡第一次给存储数据的字符指针申请空间，strcpy（）操作没起任何作用，只有在strcpy（）之前主动申请相应空间。

先不管strcpy（）这里了，问题用转换的指针修改str后，如何时在原来的字符串后面插入字符

CString str; char *p;
//str.GetBufferSetLength(5);p = (char *)(LPCTSTR)str; strcpy(p, "test ");
strcpy(p+5,"string");
不可能有其他方法

代码肯定是错的。知道LPCTSTR的C是什么意思吗？

CString --> char *:CString str("OK");
char *p = str.GetBuffer(str.GetLength());

CString可以这样转换（LPTSTR)(LPCTSTR),但是转换后最好只用于right operand。
你的问题如下不是直接了当吗：str="test ";
str+="buffer";

另外请注意unicode下
LPTSTR<>char*
LPTSTR<>BYTE*

(LPCSTR)(LPCTSTR)str --> char *

WideCharToMultiByte你用了么。不用unicode字符集试一下。

我把代码贴上来吧，不然都要跑题了CString strInPut, strOutPut, strTemp;
int InPutLineCoutnt, LineLength, nStrLength,nByteLen;
int i, j;
BYTE *pBufIn, *pBufOut, *psText;
char szTemp[2] = {0};
WORD iTemp; UpdateData(TRUE);

InPutLineCoutnt = m_eInPut.GetLineCount();
m_eOutPut.SetSel(0, -1, FALSE);
m_eOutPut.Clear();
for(i=0; i<InPutLineCoutnt; i++)
{
LineLength = m_eInPut.LineLength(m_eInPut.LineIndex(i));
m_eInPut.GetLine(i, strInPut.GetBuffer(LineLength), LineLength);
strInPut.ReleaseBuffer(LineLength);

switch(m_ConvertType)
{
case 0:
pBufIn = (BYTE*)(LPCTSTR)strInPut;
nStrLength = strInPut.GetLength() * sizeof(TCHAR);
strOutPut.Empty();
for(j=0; j<nStrLength; j+=2)
{
strTemp.Format(_T("%02X"), pBufIn[j+1]);
strOutPut += strTemp;
strTemp.Format(_T("%02X"), pBufIn[j]);
strOutPut += strTemp;
}
break;
case 1:
pBufOut = (BYTE*)(LPCTSTR)strOutPut;

nByteLen = WideCharToMultiByte(CP_ACP, NULL, strInPut, -1, NULL, 0, NULL, FALSE);
//pBufOut = (BYTE*)strOutPut.GetBuffer(nByteLen);
psText = new BYTE[nByteLen];
if(!psText)
{
delete []psText;
}
WideCharToMultiByte (CP_ACP, NULL, strInPut, -1,(LPSTR)psText, nByteLen, NULL, FALSE);
for(j=0; j<(nByteLen-1); j+=2)
{
szTemp[0] = psText[j];
szTemp[1] = psText[j+1];
sscanf_s(szTemp,"%X",&iTemp);
if(j/2%2 != 0)
{
pBufOut[j/2 - 1] = (BYTE)iTemp;
}
else
{
pBufOut[j/2 + 1] = (BYTE)iTemp;
}
}
pBufOut[j/2] = 0;
pBufOut[j/2 + 1] = 0;
//strOutPut.ReleaseBuffer(j/2);

delete []psText;
break;
}

strOutPut += _T("\r\n");
m_eOutPut.ReplaceSel(strOutPut);
}

如果用pBufOut = (BYTE*)(LPCTSTR)strOutPut;
当执行完strOutPut += _T("\r\n"); 后strOutPut就这空了
用pBufOut = (BYTE*)strOutPut.GetBuffer(nByteLen); 就没问题了

SetString的参数跟P的类型不对，还得转化

这样就可以了，和用GetBuffer一样，基本搞定
strOutPut.SetString((LPTSTR)pBufOut);

还有一个问题我用DEBUG模式编译上面的代码后，运行会出现如图的错误
用RELEASE模式编译就没问题，把WideCharToMultiByte (CP_ACP, NULL, strInPut, -1,(LPSTR)psText, nByteLen, NULL, FALSE);
这句去掉也没问题，不知道是什么原因。搞不定！！！

The contents of a CString object are copied when one CString object is assigned to another. Thus, the two strings do not share a reference to the actual characters that make up the string. For more information on using CString objects as values, see the article CString Semantics.

调试易

Cstring转化成char*后的问题

解决方案 »