CString与const char*互转
前篇:
①CString强制类型转换为const char*，在变量前加上：(char *)(LPCTSTR)，这样做虽不会报错，但其转换后的值可能是乱码，不推荐这样做！
②利用中间变量(string类型)，原理：
1）const char*类型可自动装换为CString。
CString cs("Hello");
2）CString类型不能自动转换为const char*。但可以通过Cstring先转化为string,string再调用c_str()转换为const char*
a.Cstring 直接重载LPCTSTR,可以转换到string(在2005貌似编译不过)
CString cs("Hello");
std::string s((LPCTSTR)cs); //CString->string
b.std::string类型调用c_str()方法就可轻松转换为const char*。
std::string s("Hello");
const char* k = s.c_str(); //string->Const char*
使用下面的方法可以实现 Cstring(PCTSTR)转换为Const Char*
在Unicode环境下
char str[1024];
wsprintfA(str,"%ls",lpWideChars);
或者
CStringW strw = _T("test");
CStringA stra(strw.GetBuffer(0));
strw.ReleaseBuffer();
std::string imgpath=stra.GetBuffer(0);
stra.ReleaseBuffer();
非Unicode环境下:
CString strMfc=“test“;
std::string strStl;
strStl=strMfc.GetBuffer(0);
灵活使用WIndows基本API:WsprintfA,WsprintfW,如下:
(无论什么 Character Set 都可以转换)
- //字符串
- char szTemp[] = "hello world";
- wchar_t szOut[0x100] = {0};
- wsprintfW(szOut, L"%hs", szTemp);
- //单个字符
- wsprintf(szOut, L"%hc", 'X');
- Unicode->ANSI
- //字符串
- wchar_t szTemp = L"hello world";
- char szOut[0x100] = {0};
- wsprintfA(szOut, "%ls", szTemp);
- //单个字符
- wsprintf(szOut, "%lc", L'X');
- //%hs可以在任何Character Set情况下输入编码为ANSI的字符串
- //%ls可以在任何Character Set情况下输入编码为Unicode的字符串
- //同时，wsprintf这个函数最好用的地方是你可以把它当作C下的标准格式化输入sprintf来使用，除了sprintf的基本功能外，更增加了字符转换功能，非常方便。
- //需要注意的是，在wsprintfA中，%s默认的是ANSI,在wsprintfW中%s默认对应Unicode,如果搞混的话，会输出乱码的.
- //混合使用的例子：
- //现在，我们的工程设置Character Set为Use Unicode Character Set，有一个传入char*类型的函数，我们需要用默认的CreateFile来打开文件（Unicode下默认//调用的CreateFile实际是CreateFileW）
- bool Open(char* szName)
- {
- TCHAR szPath[0x100] = {0};
- wsprintf(szPath, _T("C://Windows//System32//%hs.exe"), szName);
- CreateFile(..., szPath, ...);
- ......
- return true;
- }
//ANSI->Unicode
//字符串
char szTemp[] = "hello world";
wchar_t szOut[0x100] = {0};
wsprintfW(szOut, L"%hs", szTemp);
//单个字符
wsprintf(szOut, L"%hc", 'X');
Unicode->ANSI
//字符串
wchar_t szTemp = L"hello world";
char szOut[0x100] = {0};
wsprintfA(szOut, "%ls", szTemp);
//单个字符
wsprintf(szOut, "%lc", L'X');
//%hs可以在任何Character Set情况下输入编码为ANSI的字符串
//%ls可以在任何Character Set情况下输入编码为Unicode的字符串
//同时，wsprintf这个函数最好用的地方是你可以把它当作C下的标准格式化输入sprintf来使用，除了sprintf的基本功能外，更增加了字符转换功能，非常方便。
//需要注意的是，在wsprintfA中，%s默认的是ANSI,在wsprintfW中%s默认对应Unicode,如果搞混的话，会输出乱码的.
//混合使用的例子：
//现在，我们的工程设置Character Set为Use Unicode Character Set，有一个传入char*类型的函数，我们需要用默认的CreateFile来打开文件（Unicode下默认//调用的CreateFile实际是CreateFileW）
bool Open(char* szName)
{
TCHAR szPath[0x100] = {0};
wsprintf(szPath, _T("C://Windows//System32//%hs.exe"), szName);
CreateFile(..., szPath, ...);
......
return true;
}
std::string转换为CString
//string先调用c_str转为const char*,const char*再直接转为cstring
std::string s("Hello");
const char* k = s.c_str();
CString cs(k);
CString cs(s.c_str());一般需要const char*类型时可用string变量转换，而需要CString类型时则直接用const char*类型赋值。应尽量避免CString转换为const char *的情况！
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';
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当中，如果哪怕有一小块地方使用不当，其结果也会导致发生不可预知的错误
C语言中表示字符串，没有string概念，只可以用char*和char[];在MFC中，为了服务于字符串操作，添加了类CString,该类的头 文件是afx.h.
从char* 到CString的转换很简单，只需要用CString的构造函数即可。
本文介绍了CString到const char*和char* 的转换方法。
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)); flyhorse注：上面语句将CString-->const char*
以上两种用法都是正确地.因为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-->char*,转换后不修改字符串的内容，这个转换是可以的。
这样对吗?我们首先来看一个例子:
CString str("aa");
strcpy((char *)(LPCTSTR)str,"aaaaaaaa");
cout<<(LPCTSTR)str<
那有人就说我往里面写的字符数不超过它原来的字符数,不就不会出错了,比如
CString str("aaaaaaa");
strcpy((char *)(LPCTSTR)str,"aa");
cout<<(LPCTSTR)str<
CString str("aaaaaaa");
strcpy((char *)(LPCTSTR)str,"aa");
cout<<(LPCTSTR)str<
CString str("aaaaaaa");
CString str1 = str;
strcpy((char *)(LPCTSTR)str,"aa");
cout<<(LPCTSTR)str<
原来这里还有一个"写时复制"和"引用计数"的概念.CString类的用途很广,这样有可能在系统内部产生大量的CString临时对象.这时为了优化效率,就采用在系统软件内部广泛使用的"写时复制"概念.即当从一个CString产生另一个CString并不复制它的字符缓冲区内容,而只是将字符缓冲区的"引用计数"加1.当需要改写字符缓冲区内的内容时,才分配内存,并复制内容.以后我会给出一个"写时复制"和"引用计数"的例子我们回到主题上来,当我们需要将CString转换成char *时,我们应该怎么做呢?其时只是麻烦一点,如下所示:
CString str("aaaaaaa");
strcpy(str.GetBuffer(10),"aa");
str.ReleaseBuffer();
注：将CString-->char*,并修改字符串内容。
当我们需要字符数组时调用GetBuffer(int n),其中n为我们需要的字符数组的长度.使用完成后一定要马上调用ReleaseBuffer();还有很重要的一点就是,在能使用const char *的地方,就不要使用char *