CString string char * int double float 之间转化大全

一、CString  string  char* 之间的比较

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

CStringtypedef CStringT > CString)为Visual C++中最常用的字符串类,继承自CSimpleStringT类,主要应用在MFCATL编程中,主要数据类型有char(应用于ANSI)wchar_t(unicode)TCHAR(ANSIunicode均可)

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

(构造

string是方便的,可以从几乎所有的字符串构造而来,包括CStringchar*

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

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

举例:

char* psz = “joise”;

CString cstr( psz );

string str( cstr );

(运算符重载

a) operator=

string是最方便的,几乎可以直接用所有的字符串赋值,包括CStringchar*

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是最强大的,几乎可以与所有的字符串变量+=,包括CStringchar*

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

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

d) operator[]

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

stringchar*下标越界结果未定义;

举例:

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<=

CStringstring之间不可以进行比较,但均可以与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

CompareNoCas 
注:返回值如果<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

TrimRig 

h) 转换大小写

作用 char* string CString 转换大小写 _strlwr

_strupr MakeLower

MakeUpper 

i) 与其他类型转换

作用 char* string CString 转化为数字 atoi

atod

atof Format 转化为char* c_str
GetBuffer

GetBufferSetLen 
j) 格式化

作用 char* string CString 格式化 sprintf Format


k) 得到长度

作用 char* string CString
得到长度 strlen length GetLength 得到大小 size GetAllocLength 
l) 判断为空

作用 char* string CString 判断是否为空判断是否==NULL或者第一个字符是否是'\0' 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 

二、CStringstring区别

CString,ATL/MFC共享的, stringC++标准库的

相同点:

1)用他们都可以取代对char*的使用。

2)都封装了有丰富的字符串操作接口。

3)他们都是C++的类库。--

string的使用为例,不能有如下用法:

     string * pstr = NULL;              //定义一个指向字符串的指针

     pstr->append("Hello world.");      //在该字符串的末尾粘接上另一个字符。

这样做编译器不会有任何警告和错误,但是运行的时候就会有异常。

原因是没有理解string是一个类,而在定义类的对象的时候是需要调用其构造函数的。上面既没有调用string的构造函数,而且还把指针赋值为NULL,很明显调用该类的对象的接口的时候会出错。但是编译器却发现不了这个问题的。

正确的方法是如下:

 

string * pstr = new string("Hello world.");

 pstr->append("Hello world.");

 cout<<"string * pstr is:"<<*pstr<<endl;

或者不用指针,如下也可以:

string str;     //会自动调用默认的构造函数,构造一个string类的对象。

str.apend("Hello world.");

cout<<"string str is:"<<str<<endl;

4)他们都使用了模板的技术。

不同之处:

1CString 类是微软的visual c++提供的MFC里面的一个类,所以只有支持MFC的工程才可以使用。如在linux上的工程就不能用CString了,只能用标准C++中的string类了。另外,因为string类是在c++标准库中,所以它被封装在了std命名空间中,使用之前需要声明using namespace std;CString类并不在std命名空间中,因为它不是c++的标准库,只是微软的一个封装库。这点看来用string类的程序的移植性更好。

2string类既是一个标准c++的类库,同时也是STLStandard Template Library,标准模版库)中的类库,所以支持Iterator操作。

3CString类和string类提供的方法接口并不完全相同,所以不要糊里糊涂的认为某个类中怎么没有另外一个类中的方法啊。:-)。。

4)他们和char*之间的转换方法也不一样。

string类型的变量如果要转换成char*类型字符串,string类中提供了三个方法如下:

const charT* c_str() const //c_str 直接返回一个以\0结尾的字符串。 const charT* data() const //data 直接以数组方式返回string的内容,其大小为size()的返回值,结尾并没有\0字符size_type copy(charT* buf, size_type n, size_type pos = 0) const //copy string的内容拷贝到buf空间中。

注意:c_str()的返回类型是指向常量charT类型的指针,说明指针所指空间的内容不允许修改,只可以读取不可以更改。c_str()返回的指针

string内部的指针,并没有像copy函数一样把其内容拷贝出来。这可以从下面例子中看出来:

 string * pstr = new string("Hello world.");

 const char * ptmp = pstr->c_str(); //并没有通过malloc或者new为指针ptmp分配内存,只是把string中的数据指针赋给了ptmp而已

cout<<"Get the string->cstr is:"<<ptmp<<endl; //正确的输出了Hello world.

但是如果用copy方法时必须如下方法:

 char * p = (char *)malloc(100*sizeof(char)); //必须为指针p分配内存空间用于存放从string里拷贝出来的数据

 pstr->copy(p,pstr->length(),0); //如果没有上面分配内存空间,这个语句在运行时就会报段错误。

 cout<<"char * p:copy from string is:"<<p<<endl; //正确的输出了字符串Hello world

CString类型字符串对象转换成char*字符串比较麻烦一点,方法也有3种:

今天遇到一个难题,以前一直都是从TCHAR *转换到CString,今天需要CString 转换成TCHAR *的方法,找了一下MSDN文档,没有发现有现成的函数可以用。后来上网搜索了一下,方法还不少。如下几种:

方法一,使用强制转换。例如:

CString theString( "This is a test" );

LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;

方法二,使用strcpy。例如:

CString theString( "This is a test" );

LPTSTR lpsz = new TCHAR[theString.GetLength()+1];

_tcscpy(lpsz, theString);

需要说明的是,strcpy(或可移值Unicode/MBCS_tcscpy)的第二个参数是 const wchar_t* (Unicode)const char* (ANSI),系统编译器将会自动对其进行转换。

方法三,使用CString::GetBuffer。例如:

CString s(_T("This is a test "));

LPTSTR p = s.GetBuffer();

// 在这里添加使用p的代码

if(p != NULL) *p = _T('\0');

s.ReleaseBuffer();

// 使用完后及时释放,以便能使用其它的CString成员函数

我尝试了后面两种,都能成功,最后我还是选用了简单的第二种方法,因为采用第三种方法的话,需要用GetBuffer();函数,而该函数的使用需要非常的小心谨慎。

源码如下:

 

BOOL CAutoBuildConfigDlg::CheckMobileName(CString strMobileName)

{ wchar_t * pdest;

 CString strMobileName_temp;

 strMobileName_temp = strMobileName;

 TCHAR strCOOLPAD[] = L"COOLPAD_";

 LPTSTR lpsz =  new TCHAR[strMobileName_temp.GetLength()+1];

 wcsncpy_s(lpsz,(strMobileName_temp.GetLength()+1),strMobileName_temp, (strMobileName_temp.GetLength()+1));

 errno_t err;

 err = _wcsupr_s(lpsz,strMobileName_temp.GetLength()+1);//因为没有找到不区分大小写的查找子字符串的函数,所以决定转换成大写然后进行比较。

 pdest = wcsstr( lpsz,strCOOLPAD );

 if( pdest != NULL )

 {   return TRUE; }

 else

 {  return FALSE; }

三 CString 介绍

  CString位于头文件afx.h中。

  CString 是一种很有用的数据类型。它们很大程度上简化了MFC中的许多操作,使得MFC在做字符串操作的时候方便了很多。不管怎样,使用CString有很多特殊的技巧,特别是对于纯C背景下走出来的程序员来说有点难以学习。

CString 对象的连接

  格式化字符串(包括 int 型转化为 CString 

  CString 型转化成 int 

  CString 型和 char* 类型的相互转化

  char* 转化成 CString

  CString 转化成 char* 之一:使用LPCTSTR强制转化

  CString 转化成 char* 之二:使用CString对象的GetBuffer方法

  CString 转化成 char* 之三和控件的接口

  CString 型转化成 BSTR 型;

  BSTR 型转化成 CString 型;

  VARIANT 型转化成 CString 型;

  载入字符串表资源;

  CString 和临时对象;

  CString 的效率;

总结

1CString 对象的连接

  能体现出 CString 类型方便性特点的一个方面就是字符串的连接,使用 CString 类型,你能很方便地连接两个字符串,正如下面的例子:

  CString gray("Gray");

  CString cat("Cat");

  CString graycat = gray + cat;

  要比用下面的方法好得多:

  char gray[] = "Gray";

  char cat[] = "Cat";

  char * graycat = malloc(strlen(gray) + strlen(cat) + 1);

  strcpy(graycat, gray);

  strcat(graycat, cat);

2、格式化字符串

  与其用 sprintf() 函数或 wsprintf() 函数来格式化一个字符串,还不如用 CString 对象的Format()方法:

  CString s;

  s.Format(_T("The total is %d"), total);

  用这种方法的好处是你不用担心用来存放格式化后数据的缓冲区是否足够大,这些工作由CString类替你完成。

  格式化是一种把其它不是字符串类型的数据转化为CString类型的最常用技巧,比如,把一个整数转化成CString类型,可用如下方法:

  CString s;

  s.Format(_T("%d"), total);

  我总是对我的字符串使用_T()宏,这是为了让我的代码至少有Unicode的意识,当然,关于Unicode的话题不在这篇文章的讨论范围。_T()宏在8位字符环境下是如下定义的:

  #define _T(x) x // Unicode版本(non-Unicode version

  而在Unicode环境下是如下定义的:

  #define _T(x) L##x // Unicode版本(Unicode version

  所以在Unicode环境下,它的效果就相当于:

  s.Format(L"%d", total);

  如果你认为你的程序可能在Unicode的环境下运行,那么开始在意用 Unicode 编码。比如说,不要用 sizeof() 操作符来获得字符串的长度,因为在Unicode环境下就会有2倍的误差。我们可以用一些方法来隐藏Unicode的一些细节,比如在我需要获得字符长度的时候,我会用一个叫做DIM的宏,这个宏是在我的dim.h文件中定义的,我会在我写的所有程序中都包含这个文件:

  #define DIM(x) ( sizeof((x)) / sizeof((x)[0]) )

  这个宏不仅可以用来解决Unicode的字符串长度的问题,也可以用在编译时定义的表格上,它可以获得表格的项数,如下:

  这里要提醒你的就是一定要注意那些在参数中需要真实字节数的API函数调用,如果你传递字符个数给它,它将不能正常工作。如下:TCHAR data[20];

  lstrcpyn(data, longstring, sizeof(data) - 1); // WRONG!

  lstrcpyn(data, longstring, DIM(data) - 1); // RIGHT

  WriteFile(f, data, DIM(data), &bytesWritten, NULL); // WRONG!

  WriteFile(f, data, sizeof(data), &bytesWritten, NULL); // RIGHT

  造成以上原因是因为lstrcpyn需要一个字符个数作为参数,但是WriteFile却需要字节数作为参数。

  同样需要注意的是有时候需要写出数据的所有内容。如果你仅仅只想写出数据的真实长度,你可能会认为你应该这样做:

  WriteFile(f, data, lstrlen(data), &bytesWritten, NULL); // WRONG

  但是在Unicode环境下,它不会正常工作。正确的做法应该是这样:

  WriteFile(f, data, lstrlen(data) * sizeof(TCHAR), &bytesWritten, NULL); // RIGHT

因为WriteFile需要的是一个以字节为单位的长度。(可能有些人会想"在非Unicode的环境下运行这行代码,就意味着总是在做一个多余的乘1操作,这样不会降低程序的效率吗?"这种想法是多余的,你必须要了解编译器实际上做了什么,没有哪一个CC++编译器会把这种无聊的乘1操作留在代码中。在Unicode环境下运行的时候,你也不必担心那个乘2操作会降低程序的效率,记住,这只是一个左移一位的操作而已。使用_T宏并不是意味着你已经创建了一个Unicode的程序,你只是创建了一个有Unicode意识的程序而已。如果你在默认的8-bit模式下编译你的程序的话,得到的将是一个普通的8-bit的应用程序(这里的8-bit指的只是8位的字符编码,并不是指8位的计算机系统);当你在Unicode环境下编译你的程序时,你才会得到一个Unicode的程序。记住,CString 在 Unicode 环境下,里面包含的可都是16位的字符哦。

  这是初学者使用 CString 时最常见的问题。有了 C++ 的帮助,很多问题你不需要深入的去考虑它,直接拿来用就行了,但是如果你不能深入了解它的运行机制,又会有很多问题让你迷惑,特别是有些看起来没有问题的代码,却偏偏不能正常工作。

  比如,你会奇怪为什么不能写像下面这样的代码呢:

  CString graycat = "Gray" + "Cat";

  或者这样:

  CString graycat("Gray" + "Cat");

  事实上,编译器将抱怨上面的这些尝试。为什么呢?因为针对CString 和 LPCTSTR数据类型的各种各样的组合," +" 运算符 被定义成一个重载操作符。而不是两个 LPCTSTR 数据类型,它是底层数据类型。你不能对基本数据(如 intchar 或者 char*)类型重载 C++ 的运算符。你可以象下面这样做:

  CString graycat = CString("Gray") + CString("Cat");

  或者这样:

  CString graycat = CString("Gray") + "Cat";

  研究一番就会发现:" +"总是使用在至少有一个 CString 对象和一个 LPCSTR 的场合。

  注意,编写有 Unicode 意识的代码总是一件好事,比如:

  CString graycat = CString(_T("Gray")) + _T("Cat");

这将使得你的代码可以直接移植。

  char* 转化为 CString

  现在你有一个 char* 类型的数据,或者说一个字符串。怎么样创建 CString 对象呢?这里有一些例子:

  char * p = "This is a test";

  或者象下面这样更具有 Unicode 意识:

  TCHAR * p = _T("This is a test")

  或

  LPTSTR p = _T("This is a test");

  你可以使用下面任意一种写法:

  CString s = "This is a test"; // 8-bit only

  CString s = _T("This is a test"); // Unicode-aware

  CString s("This is a test"); // 8-bit only

  CString s(_T("This is a test")); // Unicode-aware

  CString s = p;

  CString s(p);

  用这些方法可以轻松将常量字符串或指针转换成 CString。需要注意的是,字符的赋值总是被拷贝到 CString 对象中去的,所以你可以象下面这样操作:

  TCHAR * p = _T("Gray");

  CString s(p);

  p = _T("Cat");

  s += p;

  结果字符串肯定是"GrayCat"

  CString 类还有几个其它的构造函数,但是这里我们不考虑它,如果你有兴趣可以自己查看相关文档。

  事实上,CString 类的构造函数比我展示的要复杂,比如:

  CString s = "This is a test";

这是很草率的编码,但是实际上它在 Unicode 环境下能编译通过。它在运行时调用构造函数的 MultiByteToWideChar 操作将 位字符串转换成 16 位字符串。不管怎样,如果 char * 指针是网络上传输的 位数据,这种转换是很有用的。

  CString 转化成 char* 之一:强制类型转换为 LPCTSTR

  这是一种略微硬性的转换,有关"正确"的做法,人们在认识上还存在许多混乱,正确的使用方法有很多,但错误的使用方法可能与正确的使用方法一样多。

  我们首先要了解 CString 是一种很特殊的 C++ 对象,它里面包含了三个值:一个指向某个数据缓冲区的指针、一个是该缓冲中有效的字符记数以及一个缓冲区长度。 有效字符数的大小可以是从0到该缓冲最大长度值减1之间的任何数(因为字符串结尾有一个NULL字符)。字符记数和缓冲区长度被巧妙隐藏。

  除非你做一些特殊的操作,否则你不可能知道给CString对象分配的缓冲区的长度。这样,即使你获得了该0缓冲的地址,你也无法更改其中的内容,不能截短字符串,也 绝对没有办法加长它的内容,否则第一时间就会看到溢出。

  LPCTSTR 操作符(或者更明确地说就是 TCHAR * 操作符)在 CString 类中被重载了,该操作符的定义是返回缓冲区的地址,因此,如果你需要一个指向 CString 的 字符串指针的话,可以这样做:

  CString s("GrayCat");

  LPCTSTR p = s;

  它可以正确地运行。这是由C语言的强制类型转化规则实现的。当需要强制类型转化时,C++规测容许这种选择。比如,你可以将(浮点数)定义为将某个复数 (有一对浮点数)进行强制类型转换后只返回该复数的第一个浮点数(也就是其实部)。可以象下面这样:

  Complex c(1.2f, 4.8f);

  float realpart = c;

  如果(float)操作符定义正确的话,那么实部的的值应该是1.2

  这种强制转化适合所有这种情况,例如,任何带有 LPCTSTR 类型参数的函数都会强制执行这种转换。 于是,你可能有这样一个函数(也许在某个你买来的DLL中):

  BOOL DoSomethingCool(LPCTSTR s);

  你象下面这样调用它:

  CString file("c:\\myfiles\\coolstuff")

  BOOL result = DoSomethingCool(file);

  它能正确运行。因为 DoSomethingCool 函数已经说明了需要一个 LPCTSTR 类型的参数,因此 LPCTSTR 被应用于该参数,在 MFC 中就是返回的串地址。

  如果你要格式化字符串怎么办呢?

  CString graycat("GrayCat");

  CString s;

  s.Format("Mew! I love %s", graycat);

  注意由于在可变参数列表中的值(在函数说明中是以"..."表示的)并没有隐含一个强制类型转换操作符。你会得到什么结果呢?

  一个令人惊讶的结果,我们得到的实际结果串是:

  "Mew! I love GrayCat"

  因为 MFC 的设计者们在设计 CString 数据类型时非常小心, CString 类型表达式求值后指向了字符串,所以这里看不到任何象 Format 或 sprintf 中的强制类型转换,你仍然可以得到正确的行为。描述 CString 的附加数据实际上在 CString 名义地址之后。

  有一件事情你是不能做的,那就是修改字符串。比如,你可能会尝试用","代替"."(不要做这样的,如果你在乎国际化问题,你应该使用十进制转换的 National Language Support 特性,),下面是个简单的例子:

  CString v("1.00"); // 货币金额,两位小数

  LPCTSTR p = v;

  p[lstrlen(p) - 3] = ,;

  这时编译器会报错,因为你赋值了一个常量串。如果你做如下尝试,编译器也会错:

  strcat(p, "each");

  因为 strcat 的第一个参数应该是 LPTSTR 类型的数据,而你却给了一个 LPCTSTR

  不要试图钻这个错误消息的牛角尖,这只会使你自己陷入麻烦!

  原因是缓冲有一个计数,它是不可存取的(它位于 CString 地址之下的一个隐藏区域),如果你改变这个串,缓冲中的字符计数不会反映所做的修改。此外,如果字符串长度恰好是该字符串物理限制的长度(梢后还会讲到这个问题),那么扩展该字符串将改写缓冲以外的任何数据,那是你无权进行写操作的内存(不对吗?),你会毁换坏不属于你的内存。这是应用程序真正的死亡处方。

  CString转化成char* 之二:使用 CString 对象的 GetBuffer 方法;

  如果你需要修改 CString 中的内容,它有一个特殊的方法可以使用,那就是 GetBuffer,它的作用是返回一个可写的缓冲指针。 如果你只是打算修改字符或者截短字符串,你完全可以这样做:

  CString s(_T("File.ext"));

  LPTSTR p = s.GetBuffer();

  LPTSTR dot = strchr(p, .); // OK, should have used s.Find...

  if(p != NULL)

  *p = _T(\0);

  s.ReleaseBuffer();

  这是 GetBuffer 的第一种用法,也是最简单的一种,不用给它传递参数,它使用默认值 0,意思是:"给我这个字符串的指针,我保证不加长它"。当你调用 ReleaseBuffer 时,字符串的实际长度会被重新计算,然后存入 CString 对象中。

  必须强调一点,在 GetBuffer 和 ReleaseBuffer 之间这个范围,一定不能使用你要操作的这个缓冲的 CString 对象的任何方法。因为 ReleaseBuffer 被调用之前,该 CString 对象的完整性得不到保障。研究以下代码:

  CString s(...);

  LPTSTR p = s.GetBuffer();

  //... 这个指针 发生了很多事情

  int n = s.GetLength(); // 很糟D!!!!! 有可能给出错误的答案!!!

  s.TrimRight(); // 很糟!!!!! 不能保证能正常工作!!!!

  s.ReleaseBuffer(); // 现在应该 OK

  int m = s.GetLength(); // 这个结果可以保证是正确的。

  s.TrimRight(); // 将正常工作。

  假设你想增加字符串的长度,你首先要知道这个字符串可能会有多长,好比是声明字符串数组的时候用:

  char buffer[1024];

  表示 1024 个字符空间足以让你做任何想做得事情。在 CString 中与之意义相等的表示法:

  LPTSTR p = s.GetBuffer(1024);

  调用这个函数后,你不仅获得了字符串缓冲区的指针,而且同时还获得了长度至少为 1024 个字符的空间(注意,我说的是"字符",而不是"字节",因为 CString 是以隐含方式感知 Unicode 的)。

  同时,还应该注意的是,如果你有一个常量串指针,这个串本身的值被存储在只读内存中,如果试图存储它,即使你已经调用了 GetBuffer ,并获得一个只读内存的指针,存入操作会失败,并报告存取错误。我没有在 CString 上证明这一点,但我看到过大把的 程序员经常犯这个错误。

  程序员有一个通病是分配一个固定长度的缓冲,对它进行 sprintf 操作,然后将它赋值给一个 CString

  char buffer[256];

  sprintf(buffer, "%......", args, ...); // ... 部分省略许多细节

  CString s = buffer;

  虽然更好的形式可以这么做:

  CString s;

  s.Format(_T("%...."), args, ...);

  如果你的字符串长度万一超过 256 个字符的时候,不会破坏堆栈。

  另外一个常见的错误是:既然固定大小的内存不工作,那么就采用动态分配字节,这种做法弊端更大:

  int len = lstrlen(parm1) + 13 lstrlen(parm2) + 10 + 100;

  char * buffer = new char[len];

  sprintf(buffer, "%s is equal to %s, valid data", parm1, parm2);

  CString s = buffer;

  ......

  delete [] buffer;

  它可以能被简单地写成:

  CString s;

  s.Format(_T("%s is equal to %s, valid data"), parm1, parm2);

  需要注意 sprintf 例子都不是 Unicode 就绪的,尽管你可以使用 tsprintf 以及用 _T() 来包围格式化字符串,但是基本 思路仍然是在走弯路,这这样很容易出错。

  CString to char * 之三:和控件的接口;

  我们经常需要把一个 CString 的值传递给一个控件,比如,CTreeCtrlMFC为我们提供了很多便利来重载这个操作,但是 在大多数情况下,你使用"原始"形式的更新,因此需要将墨某个串指针存储到 TVINSERTITEMSTRUCT 结构的 TVITEM 成员中。如下:

  TVINSERTITEMSTRUCT tvi;

  CString s;

  // ... s赋一些值。

  tvi.item.pszText = s; // Compiler yells at you here

  // ... 填写tvi的其他域

  HTREEITEM ti = c_MyTree.InsertItem(&tvi);

  为什么编译器会报错呢?明明看起来很完美的用法啊!但是事实上如果你看看 TVITEM 结构的定义你就会明白,在 TVITEM 结构中 pszText 成员的声明如下:

  LPTSTR pszText;

  int cchTextMax;

  因此,赋值不是赋给一个 LPCTSTR 类型的变量,而且编译器无法知道如何将赋值语句右边强制转换成 LPCTSTR。好吧,你说,那我就改成这样:

  tvi.item.pszText = (LPCTSTR)s; //编译器依然会报错。

  编译器之所以依然报错是因为你试图把一个 LPCTSTR 类型的变量赋值给一个 LPTSTR 类型的变量,这种操作在CC++中是被禁止的。你不能用这种方法 来滥用常量指针与非常量指针概念,否则,会扰乱编译器的优化机制,使之不知如何优化你的程序。比如,如果你这么做:

  const int i = ...;

  //... do lots of stuff

  ... = a; // usage 1

  // ... lots more stuff

  ... = a; // usage 2

  那么,编译器会以为既然 是 const ,所以 usage1usage2的值是相同的,并且它甚至能事先计算好 usage1 处的 的地址,然后保留着在后面的 usage2 处使用,而不是重新计算。如果你按如下方式写的话:

  const int i = ...;

  int * p = &i;

  //... do lots of stuff

  ... = a; // usage 1

  // ... lots more stuff

  (*p)++; // mess over compilers assumption

  // ... and other stuff

  ... = a; // usage 2

  编译器将认为 是常量,从而 的位置也是常量,这样间接地破坏了先前的假设。因此,你的程序将会在 debug 编译模式(没有优化)和 release 编译模式(完全优化)中反映出不同的行为,这种情况可不好,所以当你试图把指向 的指针赋值给一个 可修改的引用时,会被编译器诊断为这是一种伪造。这就是为什么(LPCTSTR)强制类型转化不起作用的原因。

  为什么不把该成员声明成 LPCTSTR 类型呢?因为这个结构被用于读写控件。当你向控件写数据时,文本指针实际上被当成 LPCTSTR,而当你从控件读数据 时,你必须有一个可写的字符串。这个结构无法区分它是用来读还是用来写。

  因此,你会常常在我的代码中看到如下的用法:

  tvi.item.pszText = (LPTSTR)(LPCTSTR)s;

  它把 CString 强制类型转化成 LPCTSTR,也就是说先获得改字符串的地址,然后再强制类型转化成 LPTSTR,以便可以对之进行赋值操作。 注意这只有在使用 Set 或 Insert 之类的方法才有效!如果你试图获取数据,则不能这么做。

  如果你打算获取存储在控件中的数据,则方法稍有不同,例如,对某个 CTreeCtrl 使用 GetItem 方法,我想获取项目的文本。我知道这些 文本的长度不会超过 MY_LIMIT,因此我可以这样写:

  TVITEM tvi;

  // ... assorted initialization of other fields of tvi

  tvi.pszText = s.GetBuffer(MY_LIMIT);

  tvi.cchTextMax = MY_LIMIT;

  c_MyTree.GetItem(&tvi);

  s.ReleaseBuffer();

  可以看出来,其实上面的代码对所有类型的 Set 方法都适用,但是并不需要这么做,因为所有的类 Set 方法(包括 Insert方法)不会改变字符串的内容。但是当你需要写 CString 对象时,必须保证缓冲是可写的,这正是 GetBuffer 所做的事情。再次强调: 一旦做了一次 GetBuffer 调用,那么在调用 ReleaseBuffer 之前不要对这个 CString 对象做任何操作。

[编辑本段]5CString 型转化成 BSTR 

  当我们使用 ActiveX 控件编程时,经常需要用到将某个值表示成 BSTR 类型。BSTR 是一种记数字符串,Intel平台上的宽字符串(Unicode),并且 可以包含嵌入的 NULL 字符。

  你可以调用 CString 对象的 AllocSysString 方法将 CString 转化成 BSTR

  CString s;

  s = ... ; // whatever

  BSTR b = s.AllocSysString();

  现在指针 指向的就是一个新分配的 BSTR 对象,该对象是 CString 的一个拷贝,包含终结 NULL字符。现在你可以将它传递给任何需要 BSTR 的接口。通常,BSTR 由接收它的组件来释放,如果你需要自己释放 BSTR 的话,可以这么做:

  ::SysFreeString(b);

  对于如何表示传递给 ActiveX 控件的字符串,在微软内部曾一度争论不休,最后 Visual Basic 的人占了上风,BSTR"Basic String"的首字母缩写)就是这场争论的结果。

[编辑本段]6BSTR 型转化成 CString 

  由于 BSTR 是记数 Unicode 字符串,你可以用标准转换方法来创建 位的 CString。实际上,这是 CString 内建的功能。在 CString 中 有特殊的构造函数可以把 ANSI 转化成 Unicode,也可以把Unicode 转化成 ANSI。你同样可以从 VARIANT 类型的变量中获得 BSTR 类型的字符串,VARIANT 类型是 由各种 COM 和 Automation (自动化)调用返回的类型。

  例如,在一个ANSI程序中:

  BSTR b;

  b = ...; // whatever

  CString s(b == NULL ? L"" : b)

  对于单个的 BSTR 串来说,这种用法可以工作得很好,这是因为 CString 有一个特殊的构造函数以LPCWSTRBSTR正是这种类型) 为参数,并将它转化成 ANSI 类型。专门检查是必须的,因为 BSTR 可能为空值,而 CString 的构造函数对于 NULL 值情况考虑的不是很周到,(感谢 Brian Ross 指出这一点!)。这种用法也只能处理包含 NUL 终结字符的单字符串;如果要转化含有多个 NULL 字符 串,你得额外做一些工作才行。在 CString 中内嵌的 NULL 字符通常表现不尽如人意,应该尽量避免。

  根据 C/C++ 规则,如果你有一个 LPWSTR,那么它别无选择,只能和 LPCWSTR 参数匹配。

  在 Unicode 模式下,它的构造函数是:

  CString::CString(LPCTSTR);

  正如上面所表示的,在 ANSI 模式下,它有一个特殊的构造函数:

  CString::CString(LPCWSTR);

  它会调用一个内部的函数将 Unicode 字符串转换成 ANSI 字符串。(在Unicode模式下,有一个专门的构造函数,该函数有一个参数是LPCSTR类型——一个8位 ANSI 字符串 指针,该函数将它加宽为 Unicode 的字符串!)再次强调:一定要检查 BSTR 的值是否为 NULL

  另外还有一个问题,正如上文提到的:BSTRs可以含有多个内嵌的NULL字符,但是 CString 的构造函数只能处理某个串中单个 NULL 字符。 也就是说,如果串中含有嵌入的 NUL字节,CString 将会计算出错误的串长度。你必须自己处理它。如果你看看 strcore.cpp 中的构造函数,你会发现 它们都调用了lstrlen,也就是计算字符串的长度。

  注意从 Unicode 到 ANSI 的转换使用带专门参数的 ::WideCharToMultiByte,如果你不想使用这种默认的转换方式,则必须编写自己的转化代码。

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

  CString convert(BSTR b)

  {

  if(b == NULL)

  return CString(_T(""));

  CString s(b); // in UNICODE mode

  return s;

  }

  如果是 ANSI 模式,则需要更复杂的过程来转换。注意这个代码使用与 ::WideCharToMultiByte 相同的参数值。所以你 只能在想要改变这些参数进行转换时使用该技术。例如,指定不同的默认字符,不同的标志集等。 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); // dont care if default used

  s.ReleaseBuffer();

  #endif

  return s;

  }

  我并不担心如果 BSTR 包含没有映射到 位字符集的 Unicode 字符时会发生什么,因为我指定了::WideCharToMultiByte 的最后两个参数为 NULL。这就是你可能需要改变的地方。

7VARIANT 型转化成 CString 

  事实上,我从来没有这么做过,因为我没有用 COM/OLE/ActiveX 编写过程序。但是我在microsoft.public.vc.mfc 新闻组上看到了 Robert Quirk 的一篇帖子谈到了这种转化,我觉得把他的文章包含在我的文章里是不太好的做法,所以在这里多做一些解释和演示。如果和他的文章有相孛的地方可能是我的疏忽。

  VARIANT 类型经常用来给 COM 对象传递参数,或者接收从 COM 对象返回的值。你也能自己编写返回 VARIANT 类型的方法,函数返回什么类型 依赖可能(并且常常)方法的输入参数(比如,在自动化操作中,依赖与你调用哪个方法。IDispatch::Invoke 可能返回(通过其一个参数)一个 包含有BYTEWORDfloatdoubledateBSTR ?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 */

  }

8、载入字符串表资源

  如果你想创建一个容易进行语言版本移植的应用程序,你就不能在你的源代码中直接包含本土语言字符串 (下面这些例子我用的语言都是英语,因为我的本土语是英语),比如下面这种写法就很糟:CString s = "There is an error";

  你应该把你所有特定语言的字符串单独摆放(调试信息、在发布版本中不出现的信息除外)。这意味着向下面这样写比较好:

  s.Format(_T("%d - %s"), code, text);

  在你的程序中,文字字符串不是语言敏感的。不管怎样,你必须很小心,不要使用下面这样的串:

  // fmt is "Error in %s file %s"

  // readorwrite is "reading" or "writing"

  s.Format(fmt, readorwrite, filename);

  这是我的切身体会。在我的第一个国际化的应用程序中我犯了这个错误,尽管我懂德语,知道在德语的语法中动词放在句子的最后面,我们的德国方面的发行人还是苦苦的抱怨他们不得不提取那些不可思议的德语错误提示信息然后重新格式化以让它们能正常工作。比较好的办法(也是我现在使用的办法)是使用两个字符串,一个用 于读,一个用于写,在使用时加载合适的版本,使得它们对字符串参数是非敏感的。也就是说加载整个格式,而不是加载串"reading""writing"

  // fmt is "Error in reading file %s"

  // "Error in writing file %s"

  s.Format(fmt, filename);

  一定要注意,如果你有好几个地方需要替换,你一定要保证替换后句子的结构不会出现问题,比如在英语中,可以是主语-宾语,主语-谓语,动词-宾语的结构等等。

  在这里,我们并不讨论 FormatMessage,其实它比 sprintf/Format 还要有优势,但是不太容易和CString 结合使用。解决这种问题的办法就是我们按照参数出现在参数表中的位置给参数取名字,这样在你输出的时候就不会把他们的位置排错了。

  接下来我们讨论我们这些独立的字符串放在什么地方。我们可以把字符串的值放入资源文件中的一个称为 STRINGTABLE 的段中。过程如下:首先使用 Visual Studio 的资源编辑器创建一个字符串,然后给每一个字符串取一个ID,一般我们给它取名字都以 IDS_开头。所以如果你有一个信息,你可以创建一个字符串资源然后取名为 IDS_READING_FILE,另外一个就取名为 IDS_WRITING_FILE。它们以下面的形式出现在你的 .rc 文件中:

  STRINGTABLE

  IDS_READING_FILE "Reading file %s"

  IDS_WRITING_FILE "Writing file %s"

  END

  注意:这些资源都以 Unicode 的格式保存,不管你是在什么环境下编译。他们在Win9x系统上也是以Unicode 的形式存在,虽然 Win9x 不能真正处理 Unicode

  然后你可以这样使用这些资源:

  // 在使用资源串表之前,程序是这样写的:

  CString fmt;

  if(...)

  fmt = "Reading file %s";

  else

  fmt = "Writing file %s";

  // much later

  CString s;

  s.Format(fmt, filename);

  // 使用资源串表之后,程序这样写: CString fmt;

  if(...)

  fmt.LoadString(IDS_READING_FILE);

  else

  fmt.LoadString(DS_WRITING_FILE);

  // much later

  CString s;

  s.Format(fmt, filename);

  现在,你的代码可以移植到任何语言中去。LoadString 方法需要一个字符串资源的 ID 作为参数,然后它从 STRINGTABLE 中取出它对应的字符串,赋值给 CString 对象。 CString 对象的构造函数还有一个更加聪明的特征可以简化 STRINGTABLE 的使用。这个用法在 CString::CString 的文档中没有指出,但是在 构造函数的示例程序中使用了。(为什么这个特性没有成为正式文档的一部分,而是放在了一个例子中,我记不得了!)——【译者注:从这句话看,作者可能是CString的设计者。其实前面还有一句类似的话。说他没有对使用GetBuffer(0)获得的指针指向的地址是否可读做有效性检查 】。这个特征就是:如果你将一个字符串资源的ID强制类型转换为 LPCTSTR,将会隐含调用 LoadString。因此,下面两个构造字符串的例子具有相同的效果,而且其 ASSERT debug模式下不会被触发:CString s;

  s.LoadString(IDS_WHATEVER);

  CString t( (LPCTSTR)IDS_WHATEVER );

  ASSERT(s == t);//不会被触发,说明st是相同的。

  现在,你可能会想:这怎么可能工作呢?我们怎么能把 STRINGTABLE ID 转化成一个指针呢?很简单:所有的字符串 ID 都在1~65535这个范围内,也就是说,它所有的高位都是0,而我们在程序中所使用的指针是不可能小于65535的,因为程序的低 64K 内存永远也不可能存在的,如果你试图访问0x000000000x0000FFFF之间的内存,将会引发一个内存越界错误。所以说1~65535的值不可能是一个内存地址,所以我们可以用这些值来作为字符串资源的ID

  我倾向于使用 MAKEINTRESOURCE 宏显式地做这种转换。我认为这样可以让代码更加易于阅读。这是个只适合在 MFC 中使用的标准宏。你要记住,大多数的方法即可以接受一个 UINT 型的参数,也可以接受一个 LPCTSTR 型的参数,这是依赖 C++ 的重载功能做到的。C++重载函数带来的 弊端就是造成所有的强制类型转化都需要显示声明。同样,你也可以给很多种结构只传递一个资源名。

  CString s;

  s.LoadString(IDS_WHATEVER);

  CString t( MAKEINTRESOURCE(IDS_WHATEVER));

  ASSERT(s == t);

  告诉你吧:我不仅只是在这里鼓吹,事实上我也是这么做的。在我的代码中,你几乎不可能找到一个字符串,当然,那些只是偶然在调试中出现的或者和语言无关的字符串除外。

9CString 和临时对象

  这是出现在 microsoft.public.vc.mfc 新闻组中的一个小问题,我简单的提一下,这个问题是有个程序员需要往注册表中写入一个字符串,他写道:

  我试着用 RegSetValueEx() 设置一个注册表键的值,但是它的结果总是令我困惑。当我用char[]声明一个变量时它能正常工作,但是当我用 CString 的时候,总是得到一些垃圾:"YYYY...YYYYYY"为了确认是不是我的 CString 数据出了问题,我试着用 GetBuffer,然后强制转化成 char*LPCSTRGetBuffer 返回的值是正确的,但是当我把它赋值给 char* 时,它就变成垃圾了。以下是我的程序段:

  char* szName = GetName().GetBuffer(20);

  RegSetValueEx(hKey, "Name", 0, REG_SZ,

  (CONST BYTE *) szName,

  strlen (szName + 1));

  这个 Name 字符串的长度小于 20,所以我不认为是 GetBuffer 的参数的问题。

  真让人困惑,请帮帮我。

  亲爱的 Frustrated

  你犯了一个相当微妙的错误,聪明反被聪明误,正确的代码应该象下面这样:

  CString Name = GetName();

  RegSetValueEx(hKey, _T("Name"), 0, REG_SZ,

  (CONST BYTE *) (LPCTSTR)Name,

  (Name.GetLength() + 1) * sizeof(TCHAR));

  为什么我写的代码能行而你写的就有问题呢?主要是因为当你调用 GetName 时返回的 CString 对象是一个临时对象。参见:《C++ Reference manual》§12.2

  在一些环境中,编译器有必要创建一个临时对象,这样引入临时对象是依赖于实现的。如果编译器引入的这个临时对象所属的类有构造函数的话,编译器要确保这个类的构造函数被调用。同样的,如果这个类声明有析构函数的话,也要保证这个临时对象的析构函数被调用。

  编译器必须保证这个临时对象被销毁了。被销毁的确切地点依赖于实现.....这个析构函数必须在退出创建该临时对象的范围之前被调用。

  大部分的编译器是这样设计的:在临时对象被创建的代码的下一个执行步骤处隐含调用这个临时对象的析构函数,实现起来,一般都是在下一个分号处。因此,这个 CString 对象在 GetBuffer 调用之后就被析构了(顺便提一句,你没有理由给 GetBuffer 函数传递一个参数,而且没有使用ReleaseBuffer 也是不对的)。所以 GetBuffer 本来返回的是指向这个临时对象中字符串的地址的指针,但是当这个临时对象被析构后,这块内存就被释放了。然后 MFC 的调试内存分配器会重新为这块内存全部填上 0xDD,显示出来刚好就是"Y"符号。在这个时候你向注册表中写数据,字符串的内容当然全被破坏了。

  我们不应该立即把这个临时对象转化成 char* 类型,应该先把它保存到一个 CString 对象中,这意味着把临时对象复制了一份,所以当临时的 CString 对象被析构了之后,这个 CString 对象中的值依然保存着。这个时候再向注册表中写数据就没有问题了。

  此外,我的代码是具有 Unicode 意识的。那个操作注册表的函数需要一个字节大小,使用lstrlen(Name+1) 得到的实际结果对于 Unicode 字符来说比 ANSI 字符要小一半,而且它也不能从这个字符串的第二个字符起开始计算,也许你的本意是 lstrlen(Name) + 1OK,我承认,我也犯了同样的错误!)。不论如何,在 Unicode 模式下,所有的字符都是2个字节大小,我们需要处理这个问题。微软的文档令人惊讶地对此保持缄默:REG_SZ 的值究竟是以字节计算还是以字符计算呢?我们假设它指的是以字节为单位计算,你需要对你的代码做一些修改来计算这个字符串所含有的字节大小。

10CString 的效率

  CString 的一个问题是它确实掩藏了一些低效率的东西。从另外一个方面讲,它也确实可以被实现得更加高效,你可能会说下面的代码:CString s = SomeCString1;

  s += SomeCString2;

  s += SomeCString3;

  s += ",";

  s += SomeCString4;

  比起下面的代码来,效率要低多了:

  char s[1024];

  lstrcpy(s, SomeString1);

  lstrcat(s, SomeString2);

  lstrcat(s, SomeString 3);

  lstrcat(s, ",");

  lstrcat(s, SomeString4);

  总之,你可能会想,首先,它为 SomeCString1 分配一块内存,然后把 SomeCString1 复制到里面,然后发现它要做一个连接,则重新分配一块新的足够大的内存,大到能够放下当前的字符串加上SomeCString2,把内容复制到这块内存 ,然后把 SomeCString2 连接到后面,然后释放第一块内存,并把指针重新指向新内存。然后为每个字符串重复这个过程。把这 个字符串连接起来效率多低啊。事实上,在很多情况下根本就不需要复制源字符串(在 += 操作符左边的字符串)。

  在 VC++6.0 中,Release 模式下,所有的 CString 中的缓存都是按预定义量子分配的。所谓量子,即确定为 64128256 或者 512 字节。这意味着除非字符串非常长,连接字符串的操作实际上就是 strcat 经过优化后的版本(因为它知道本地的字符串应该在什么地方结束,所以不需要寻找字符串的结尾;只需要把内存中的数据拷贝到指定的地方即可)加上重新计算字符串的长度。所以它的执行效率和纯 的代码是一样的,但是它更容易写、更容易维护和更容易理解。

  如果你还是不能确定究竟发生了怎样的过程,请看看 CString 的源代码,strcore.cpp,在你 vc98的安装目录的 mfc\src 子目录中。看看 ConcatInPlace 方法,它被在所有的 += 操作符中调用。

  啊哈!难道 CString 真的这么"高效"吗?比如,如果我创建

  CString cat("Mew!");

  然后我并不是得到了一个高效的、精简的5个字节大小的缓冲区(4个字符加一个结束字符),系统将给我分配64个字节,而其中59个字节都被浪费了。

  如果你也是这么想的话,那么就请准备好接受再教育吧。可能在某个地方某个人给你讲过尽量使用少的空间是件好事情。不错,这种说法的确正确,但是他忽略了事实中一个很重要的方面。

  如果你编写的是运行在16K EPROMs下的嵌入式程序的话,你有理由尽量少使用空间,在这种环境下,它能使你的程序更健壮。但是在 500MHz, 256MB的机器上写 Windows 程序,如果你还是这么做,它只会比你认为的"低效"的代码运行得更糟。

  举例来说。字符串的大小被认为是影响效率的首要因素,使字符串尽可能小可以提高效率,反之则降低效率,这是大家一贯的想法。但是这种想法是不对的,精确的内存分配的后果要在程序运行了好几个小时后才能体现得出来,那时,程序的堆中将充满小片的内存,它们太小以至于不能用来做任何事,但是他们增加了你程序的内存用量,增加了内存页面交换的次数,当页面交换的次数增加到系统能够忍受的上限,系统则会为你的程序分配更多的页面,直到你的程序占用了所有的可用内存。由此可见,虽然内存碎片是决定效率的次要因素,但正是这些因素实际控制了系统的行为,最终,它损害了系统的可靠性,这是令人无法接受的。

  记住,在 debug 模式下,内存往往是精确分配的,这是为了更好的排错。

  假设你的应用程序通常需要连续工作好几个月。比如,我常打开 VC++WordPowerPointFrontpageOutlook ExpressForté AgentInternet Explorer和其它的一些程序,而且通常不关闭它们。我曾经夜以继日地连续用 PowerPoint 工作了好几天(反之,如果你不幸不得不使用像 Adobe FrameMaker 这样的程序的话,你将会体会到可靠性的重要;这个程序机会每天都要崩溃4~6次,每次都是因为用完了所有的空间并填满我所有的交换页面)。所以精确内存分配是不可取的,它会危及到系统的可靠性,并引起应用程序崩溃。

  按量子的倍数为字符串分配内存,内存分配器就可以回收用过的内存块,通常这些回收的内存块马上就可以被其它的 CString 对象重新用到,这样就可以保证碎片最少。分配器的功能加强了,应用程序用到的内存就能尽可能保持最小,这样的程序就可以运行几个星期或几个月而不出现问题。

  题外话:很多年以前,我们在 CMU 写一个交互式系统的时候,一些对内存分配器的研究显示出它往往产生很多内存碎片。Jim Mitchell,现在他在 Sun Microsystems 工作,那时候他创造了一种内存分配器,它保留了一个内存分配状况的运行时统计表,这种技术和当时的主流分配器所用的技术都不同,且较为领先。当一个内存块需要被分割得比某一个值小的话,他并不分割它,因此可以避免产生太多小到什么事都干不了的内存碎片。事实上他在内存分配器中使用了一个浮动指针,他认为:与其让指令做长时间的存取内存操作,还不如简单的忽略那些太小的内存块而只做一些浮动指针的操作。(His observation was that the long-term saving in instructions by not having to ignore unusable small storage chunks far and away exceeded the additional cost of doing a few floating point operations on an allocation operation.)他是对的。

  永远不要认为所谓的"最优化"是建立在每一行代码都高速且节省内存的基础上的,事实上,高速且节省内存应该是在一个应用程序的整体水平上考虑的。在软件的整体水平上,只使用最小内存的字符串分配策略可能是最糟糕的一种方法。

  如果你认为优化是你在每一行代码上做的那些努力的话,你应该想一想:在每一行代码中做的优化很少能真正起作用。你可以看我的另一篇关于优化问题的文章《Your Worst Enemy for some thought-provoking ideas》。

  记住,+= 运算符只是一种特例,如果你写成下面这样:

  CString s = SomeCString1 + SomeCString2 + SomeCString3 + "," + SomeCString4;

  则每一个 的应用会造成一个新的字符串被创建和一次复制操作。

总结

以上是使用 CString 的一些技巧。我每天写程序的时候都会用到这些。CString 并不是一种很难使用的类,但是 MFC 没有很明显的指出这些特征,需要你自己去探索、去发现。

四、String 介绍

成员函数(Member functions)

(constructor)                     

    构建字符串对象  (构造函数成员

operator=

    字符串赋值  (公有成员函数)

  以下全为公有成员函数

迭代器(Iterator

begin 

返回指向字符串开始处的迭代器

end

返回指向字符串结束处之后的迭代器

rbegin

返回指向反向开始处的反向迭代器,即:指向结束处的迭代器

rend

返回指向反向结束处的反向迭代器,即:指向开始处之前的迭代器

容量(Capacity

size       

返回字符串长度                         

length

返回字符串长度

max_size

返回字符串的最大长度

resize

改变字符串大小,即:多去少补

capasity

返回分配存储空间大小

reserve

请求改变存储空间大小

clear

清空字符串

empty

测试字符串是否为空

访问元素(Eelment access

operator[]                            

得到字符串中的字符       

at

得到字符串中的字符

修改(Modifiers

operator+=        

追加  

append

追加

push_back

追加字符到字符串

assign

赋值

insert

插入

erase

从字符串中擦除一些字符

replase

替换部分或全部字符

swap

与另一字符串交换内容

字符串操作(String operation

c_str  

得到等效的字符数组 

data

得到等效的字符串数据

get_allocator

得到分配器

copy

从字符串中复制字符序列

find

查找某个内容第一次出现的位置

rfind

查找某个内容最后一次出现的位置

find_first_of

查找字符

find_last_of

从后向前查找字符

find_first_not_of

Find absence of character in string    注:英文原意比较准确

find_last_not_of

Find absence of character in string from the end

substr

生成子字符串

compare

比较

C++标准函数库》中说的
有三个函数可以将字符串的内容转换为字符数组和C—string
1.data(),返回没有”\0“的字符串数组
2,c_str(),返回有”\0“的字符串数组
3copy()    size_type copy( char *str, size_type num, size_type index );

copy()函数拷贝自己的num个字符到str中(从索引index开始)。返回值是拷贝的字符数

备注:c_str函数的返回值是const char*的,不能直接赋值给char*,所以就需要我们进行相应的操作转化 

 string add_to="hello!";

  const string add_on="baby";

  const char*cfirst = add_to.c_str();

  const char*csecond = add_on.c_str();

  char*copy = new char[strlen(cfirst) + strlen(csecond) + 1];

  strcpy( copy, cfirst);

  std::cout<<copy<<endl;

  //strcat( copy, csecond);

  add_to = copy;

  delete [] copy;

  std::cout<<add_to<<std::endl;

注意:一定要使用strcpy()函数 等来操作方法c_str()返回的指针

  比如:最好不要这样:

  char* c;

  string s="1234";

  c = s.c_str(); //c最后指向的内容是垃圾,因为s对象被析构,其内容被处理,应该这样用:

  char c[20];

  string s="1234";

  strcpy(c,s.c_str());

  这样才不会出错,c_str()返回的是一个临时指针,不能对其进行操作

  再举个例子

  c_str() 以 char* 形式传回 string 内含字符串

如果一个函数要求char*参数,可以使用c_str()方法:

五、CString与wchar_t,int,string,char* double float之间的转换

1. CString 转 wchar_t

CString path = "asdf";

wchar_t wstr[256] = path.AllocSysString();

或者:

wchar_t wcstring[256];

MultiByteToWideChar(CP_ACP,0,path,-1,wcstring,256);

2. wchar_tCString

WideCharToMultiByte(CP_ACP,0,wcstring,256,path.GetBuffer(0),256,NULL,NULL);

path.ReleaseBuffer(0);

3. string 转 CString

CString.format("%s", string.c_str());

4 CString string

string s(CString.GetBuffer());

GetBuffer()后一定要ReleaseBuffer(),否则就没有释放缓冲区所占的空间

4. char 转 CString

CString.format("%s", char*);

7.CString 转 string

string s(CString.GetBuffer());

CString   str   =   "fdjfdas";   
string   s   =   (LPCTSTR)str;

8,string -> CString
CString.format("%s", string.c_str());
c_str()确实比data()要好.


10,CString ->int
  将字符转换为整数,可以使用atoi_atoi64atol

把 CString 类型的数据转化成整数类型最简单的方法就是使用标准的字符串到整数转换例程。虽然通常你怀疑使用_atoi()函数是一个好的选择,它也很少会是一个正确的选择。如果你准备使用 Unicode 字符,你应该用_ttoi(),它在 ANSI 编码系统中被编译成_atoi(),而在 Unicode 编码系统中编译成_wtoi()。你也可以考虑使用_tcstoul()或者_tcstol(),它们都能把字符串转化成任意进制的长整数(如二进制、八进制、十进制或十六进制),不同点在于前者转化后的数据是无符号的(unsigned),而后者相反。看下面的例子:

  CString hex = _T("FAB");

  CString decimal = _T("4011");

ASSERT(_tcstoul(hex, 0, 16) == _ttoi(decimal));

CString ss="1212.12";
int temp=atoi((char*)LPCTSTR(ss));

11 intCString

  而将数字转换为CString变量,可以使用CStringFormat函数CString s;
CString s; 

int i = 64;
s.Format("%d", i)

12 CString ---double /float/ long double

wcstod(), wcstof(), wcstold()

Convert a wide-character string into a double, float, or long double

#include <wchar.h>

double wcstod( const wchar_t * ptr,  wchar_t ** endptr );

float wcstof( const wchar_t * ptr, wchar ** endptr );

long double wcstold( const wchar_t * ptr,wchar ** endptr );

nptr   A pointer to the string to parse. 

endptr   If this argument isn't NULL, the function stores in it a pointer to the first unrecognized character found in the string. 

   CString str_alt=_T("123.52");

   double alt=0.0;

   alt=wcstod(str_alt,NULL);   //NULL 不能少   不需要 自动转换  unicode

alt=wcstod(str_alt. AllocSysString(),NULL);    需要将 CString 转成 wchar_t

13 CString to char *

CString strtest;

1charpoint=strtest.GetBuffer(strtest.GetLength());

标准C里没有string,char *==char []==string

2用操作符(LPCSTRstrtest 或者 (char*)LPCSTRstrtest 就可以了

14 char *转成CString

可以用CString.Format("%s",char *)这个方法来将char *转成CString

CString转成char *

CString strtest;
char * charpoint;
charpoint="give string a value";
strtest=charpoint;

15 CString转换 char[100]

char a[100];
CString str("aaaaaa");
strncpy(a,(LPCTSTR)str,sizeof(a));

部分小结

1CString::GetBuffer(0);//取得CStringchar* 
2int intv=atoi(CString::GetBuffer(0));//CString to Int 
3float floatv=(float)atof(CString::GetBuffer(0));//CString to float 
4long longvv=atol(CString::GetBuffer(0));//CString to Long 
5double doublev=atof(CString::GetBuffer(0));//CString to Double 
6CString::Format(_T("%d,%f,%ld,%lf,%c,%s"),int,float,long,double,char,char*)//各类型到CString

六、String 与 intcharchar*CStringdoublefloat 

1 string -> CString
CString.format("%s", string.c_str());
c_str()确实比data()要好.

2 string ->char *

char *p = string.c_str();

cannot convert from 'const char *' to 'char *' 
const char *p= string.c_str();

3. char *转 string

string s(char *);

你的只能初始化,在不是初始化的地方最好还是用assign().

赋值(assign) 

语法

basic_string &assign( const basic_string &str );  用str为字符串赋值

basic_string &assign( const char *str );  用str为字符串赋值

basic_string &assign( const char *str, size_type num ); 用str的开始num个字符为字符串赋值,

basic_string &assign( const basic_string &str, size_type index, size_type len ); 用str的子串为字符串赋值,子串以index索引开始,长度为len

basic_string &assign( size_type num, char ch ); 用num个字符ch为字符串赋值.

    string str1, str2 = "War and Peace";

    str1.assign( str2, 4, 3 ); 

    cout << str1 << endl;

显示

And

4 string 转 int double

Method 1使用Catoi()和atof()。先利用c_str()轉成C string,再用atoi()atof() #include <cstdlib>

 Int i= atoistring.c_str())先转化成const char *

String s="123";
double n=atof(s.c_str());
int n = atoi(s.c_str());

Method 2
利用stringstream  #include<sstream>

这里使用functon template的方式将std::stringintstd::stringdouble

编写模板函数

template<classT>
void convertFromString(T &value,const std::string&s){
std::stringstream ss(s);
ss>>value;
}

5 int  doublestring

 方法一 间接转化 转化成char* Csting 在转化

方法二 stringstream  #include <sstream>

编写的函数

string int2str(int &i) {

String s;
stringstream ss(s);
ss<<i;    //C++  <<   >> 的特点

return ss.str();
}

tringstream::stringstream(string str); 原型

七、char * 转 int double string CString

1 char * 转化成 int

#include <stdlib.h> 
int atoi(const char *nptr); 
long atol(const char *nptr); 
long long atoll(const char *nptr); 
long long atoq(const char *nptr);

2 int 转成 char*

sprintf(s,"%d",i); 

_itoa(i, s, 10);

_itoa

  整形转换为字符串 int--->string

  char *_itoa( int value, char *string, int radix );

  参数说明:

  value-----要转换的整形值

  string-----转换后的字符串

  radix------表示基数(2, 8, 10, 16)等进制基数

  本函数与char * itoa(int, char *, int);相同

  还有其他类似的转换函数

  char *_i64toa( __int64 value, char *string, int radix );

  char * _ui64toa(unsigned _int64 value, char *string, int radix );

  wchar_t * _itow(int value, wchar_t *string, int radix ); 以宽字符串的形式存放在str

  wchar_t * _i64tow( __int64 value, wchar_t *string, int radix );

wchar_t * _ui64tow(unsigned __int64 value, wchar_t *string, int radix );

3 double /float 转化成char*

 sprintf(s,"%f",i);  float to char *

 sprintf(s,"%lf",i);  double to char *

  函数名: gcvt 、高版本 _gcvt  _gcvt_s 

  功 能把浮点数转换成字符串

用 法char *gcvt(double value, int ndigit, char *buf); 

 参数

  value——被转换的值。

  Digits——存储的有效数字位数。

  Buffe——结果的存储位置

  说明

  gcvt函数把一个浮点值转换成一个字符串(包括一个小数点和可能的符号字节)并存储该字符串在buffer中。该buffer应足够大以便容纳转换的值加上结尾的空格字符,它是自动添加的。如果一个缓冲区的尺寸为digits的尺寸+1,该函数覆盖该缓冲区的末尾。这是因为转换的字符串包括一个小数点以及可能包含符号和指数信息。不提供上溢出。gcvt试图以十进制格式产生digits数字,如果不可能,它以指数格式产生digits数字,在转换时可能截除尾部的0

 函数名: fcvt   高版本_fcvt  _fcvt_s

  功 能把一个浮点数转换为字符串

  用 法: char *fcvt(double value, int ndigit, int *decpt, int *sign);

  参数:

  value:要转换的浮点数,输入参数

  ndigit:小数点后面的位数,输入参数

  decpt:表示小数点的位置,输出参数

sign:表示符号,0为正数,1为负数,输出参数

函数名: ecvt

  功 能将双精度浮点型数转换为字符串,转换结果中不包括十进制小数点

  用 法: char* ecvt(double value, int ndigit, int *decpt, int *sign);

  详细解释:ecvt函数把一个双精度浮点数转换成一个字符串。value参数是要转换的浮点数。这个函数存储最多ndigit个数字值作为一个字符串,并添加一个空数字符('\0'),如果value中的数字个数超过ndigit,低位数字被舍入。如果少于ndigit个数字,该字符串用0填充。 只有数字才存储在该字符串中,小数点位置和value符号在调用之后从decptsign获取。decpt参数指出给出小数点位置的整数值它是从该字符串的开头位置计算的。0或负数指出小数点在第一个数字的左边。sign参数指出一个指出转换的数的符号的整数。如果该整数为0,这个数为正数,否则为负数。

  参 数:

  value:待转换的双精度浮点数。

  ndigit:存储的有效数字位数。

  *decpt:存储的小数点位置。

  *sign:转换的数的符号。

  返回值:

  char*:指向生成的字符串。

  备注:该函数的头文件是"stdlib.h"

_itoa_sitoa  VS2008中的_itoa_s使用说明 

   在C++的程序开发中,经常需要将不同基本类型的值进行转换,VS2008中的VC项目中,如果直接用itoa这个函数,在编译的时候会有警告说让你用_itoa,然后你用_itoa的时候呢,它又有警告说要用_itoa_s这个函数才行。

_itoa_sitoa是有区别的,_itoa_s(int ,char *,int ,int )有四个参数,比itoa的参数个数要多一些,_itoa_s函数的四个参数的意思分别是:

第一个参数是你要转换的整形变量

第二个参数是转换后存放结果的字符串指针

第三个参数是第一个参数的进制表示,如二进制,十进制,八进制,16进制这样的值,

第四个参数是转换后的字符串结果数的进制表示,如二进制,十进制,八进制,16进制这样的值

_itoa_s.net2005VC8.0提供的一个更安全的函数如果你的VC7.0的代码在转换到VC8.0时都回警告你将itoa_itoa更换成_itoa_s.net2003里面没有这个函数

4/ char*转化成 double  float

可以用 atof函数(不一定每个库都有)或 sscanf(我喜欢用这个):
double b;
sscanf(a,"%lf",b);

  sscanf() - 从一个字符串中读进与指定格式相符的数据.

函数原型:

  Int sscanf( const char *, const char *, ...);

int scanf( const char *, ..)

sscanfscanf类似,都是用于输入的,只是后者以键盘(stdin)为输入源,前者以固定字符串为输入源。

   第一个参数可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | ' ' | '\t' | '\n' | %符号}

  注:

  1、 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)

  2{a|b|c}表示a,b,c中选一,[d],表示可以有d也可以没有d

  3width表示读取宽度。

  4{h | l | I64 | L}:参数的size,通常h表示单字节sizeI表示2字节 size,L表示4字节size(double例外),l64表示8字节size

  5type :这就很多了,就是%s,%d之类。

  6、特别的:%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉,不会向目标参数中写入值 

TCHAR.H routine 

_UNICODE & _MBCS not defined

_MBCS defined

_UNICODE defined

_tstof

atof

atof

_wtof

_ttof

atof

atof

_wtof

 Configuration requise 

Routine(s)

Required header

atof

<math.h> and <stdlib.h>

_atof_l

<math.h> and <stdlib.h>

_wtof, _wtof_l

<stdlib.h> or <wchar.h>

5. char*CString的相互转换

CString 饱含了3个值:指向某个数据缓冲区的指针、该缓冲区中有效的字符记数(它是不可存取的,是位于CString 地址之下的一个隐藏区域)及一个缓冲区长度。有效字符数的大小可以是从0到该缓冲最大长度值减1之间的任何数(因为字符串结尾有一个NULL字符)
(1) char* 转换为 CString

直接赋值

利用格式化转换
 CString strConvert;
TCHAR* P = _T("this is a chTostring test ");
 strConvert = p;  // 直接赋值
strConvert.Format("%s",p);    // 格式化
(2) CString 转换为 char*☆强制类型转换为LPCTSTR
CString theString((_T("Char test "));
 LPTSTR lpsz = (LPTSTR) (LPCTSTR)theString;使用strcpy
CString theString( (_T("Char test "));
LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
 _tcscopy(lpsz, theSting);需要说明的是, strcpy(或可移植的_tcscpy)的第二参数是const wcahr_t*(Unicode)const char*(ANSI),系统编译器将会自动对其进行转换。
 (3)使用GetBuffer
 如果需要修改CString中的内容,它有一个特殊的方法可以使用,哪就是GetBuffer,它的作用是返回一个可写的缓冲指针。如果只是打算修改字符或者截短字符串,例如:
 CString s(_T("Char test "));
LPTSTR p = s.GetBuffer();
 // 添加P的代码
s.ReleaseBuffer()   // 使用完后及时释放。

发布了24 篇原创文章 · 获赞 7 · 访问量 2万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览