SYMBIAN OS:描述符

近来在家中休息，想整理一下自己的笔记，还是从基本的开始吧

缓冲区描述符

TBufC   //e32cmn.h

基本用法

       _LIT(KText1,"Hello World\n");

       TBufC<30> bufText1;

       bufText1 = KText1;   //这个“=”已经被重载过了

       console->Write(bufText1);

      

       _LIT(KText2,"Hello World\n");

       TBufC<30> bufText2(KText2);

       console->Write(bufText2);

 

类函数

template <TIntS>

#if defined(_UNICODE) && !defined(__KERNEL_MODE__)

classTBufC :publicTBufCBase16

#else

class TBufC :public TBufCBase8

#endif

       {

public:

       inlineTBufC();

       inlineTBufC(constTText* aString);

       inlineTBufC(constTDesC& aDes);

 

       inlineTBufC<S>&operator=(constTText* aString);  //这个“=”已经被重载过了

       inlineTBufC<S>&operator=(constTDesC& aDes);   //这个“=”已经被重载过了

 

       inlineTPtrDes();

private:

       TTextiBuf[__Align(S)];

       };

 

//拷贝构造函数和默认的重载操作符

       TBufC(constTBufC<S>& buf);

       TBufC<S>&operator = (constTBufC<S>& aBuf);

 

 

TBuf    //e32cmn.h

基本用法

       _LIT(KText,"YunYun\n");

       TBuf<100> buf;

       buf.Copy(KText);

       console->Write(buf);

      

       TBufC<30> bufText(KText);

       buf.Copy(bufText);

       console->Write(buf);

      

       buf.Zero();

       buf.AppendFormat(_L("this is a TBuf example,%S"),&KText);

       buf.AppendFormat(_L("++_ %S"),&bufText);

       console->Write(buf);

//也可以用 =，但是那样多了一个32位的最大长度iMaxLength，不好

 

 

使用方法基本跟TBufC相同，在栈上分配空间，直接声明使用

修改方法都是从TDes中继承的

 

类函数

template <TIntS>

#if defined(_UNICODE) && !defined(__KERNEL_MODE__)

classTBuf :publicTBufBase16

#else

class TBuf :public TBufBase8

#endif

       {

public:

       inlineTBuf();

       inlineexplicitTBuf(TInt aLength);  //explicit 不能被隐式转换

       inlineTBuf(constTText* aString);

       inlineTBuf(constTDesC& aDes);

 

       inlineTBuf<S>&operator=(constTText* aString);

       inlineTBuf<S>&operator=(constTDesC& aDes);

       inlineTBuf<S>&operator=(constTBuf<S>& aBuf);

private:

       TTextiBuf[__Align(S)];

       };

 

 

指针描述符

TPtrC    //e32des16.h

  //iPtr存放指向buffer的指针

基本用法

       _LIT(KText,"YunYun\n");

       TBuf<100> buf;

       buf.Copy(KText);

      

       TPtrC ptrc1 = buf.Left(3);

       TPtrC ptrc2(ptrc1);

       TPtrC ptrc3;

       ptrc3.Set(buf);

       console->Write(ptrc1);

       console->Write(ptrc2);

       console->Write(ptrc3);

 

类函数

classTPtrC16 :publicTDesC16

       {

public:

//构造函数，第一种给TPtrC设置缓冲区的方法

       IMPORT_CTPtrC16();

       IMPORT_CTPtrC16(constTDesC16 &aDes);

       IMPORT_CTPtrC16(constTUint16 *aString); //以“0”结尾的字符串指针

       IMPORT_CTPtrC16(constTUint16 *aBuf,TInt aLength);  //传递一个缓冲区的指针，设置TPtrC对象的长度

//默认的拷贝构造函数

       TPtrC(constTPrtC &aDes);

//可以通过set方法设置缓冲区，第二种给TPtrC设置缓冲区的方法

       inlinevoidSet(constTUint16 *aBuf,TInt aLength);

       inlinevoidSet(constTDesC16 &aDes);

       inlinevoidSet(constTPtrC16 &aPtr);

//Set方法不能改变缓冲区里面的数据，但是可以改变TPtrC对象指向的缓冲区

private:

       TPtrC16&operator=(constTPtrC16 &aDes); //TPtrC也重载了“=”

protected:

       constTUint16 *iPtr;

private:

       __DECLARE_TEST;

       };

 

第三种给TPtrC设置缓冲区的方法，直接通过其他缓冲区描述符获取TPtrC对象

       _LIT(KText1,"YunYun\n");

       TBuf<100> bufText1;

       bufText1.Copy(KText1);

      

       TPtrC ptrcLeft = bufText1.Left(3);

       TPtrC ptrcRight;

       ptrcRight.Set(bufText1.Right(4));

 

TPtr   //e32des16.h

基本用法

       _LIT(KText1,"YunYun\n");

       TBufC<100> bufText1;

       bufText1 = KText1;

      

       _LIT(KText2,"YunYun");

       TBufC<30> bufText2(KText2);

      

       TPtr ptr = bufText1.Des(); //变成Ptr型的

       ptr.Set(bufText2.Des());

       ptr.AppendFormat(_L(" %d"),20);

       console->Write(ptr);

//通过指针描述符轻松的绕过了TBufC的不能修改的限制

 

//还可以用这个

       TText text[100];

       TPtr ptrText(text,100);

 

类方法

classTPtr16 :publicTDes16

       {

public:

//注意没有空的构造函数

       IMPORT_CTPtr16(TUint16 *aBuf,TInt aMaxLength);

       IMPORT_CTPtr16(TUint16 *aBuf,TInt aLength,TInt aMaxLength);

//拷贝构造函数

       TPtr(TPtr& aTPtr);

       //重载的“=”运算符

       inlineTPtr16&operator=(constTUint16 *aString);

       inlineTPtr16&operator=(constTDesC16& aDes);

       inlineTPtr16&operator=(constTPtr16& aDes);

 

       inlinevoidSet(TUint16 *aBuf,TInt aLength,TInt aMaxLength);

       inlinevoidSet(constTPtr16 &aPtr);

private:

       IMPORT_CTPtr16(TBufCBase16 &aLcb,TInt aMaxLength); //注意这个是一个私有的方法

protected:

       TUint16 *iPtr;

private:

       friendclassTBufCBase16;

       __DECLARE_TEST;

       };

 

实际开发过程中，很多时候是直接取得指向缓存区的指针描述符TPtr对象，然后使用TPtr对象操作缓冲区中的数据，常用的方法有下面两种

1）取得TBufC的指针描述符

       _LIT(KText2,"YunYun");

       TBufC<30> bufText2(KText2);

      

       TPtr ptr = bufText1.Des(); //变成Ptr型的

2）取得缓冲区描述符HBufC的指针描述符

       HBufC* pBuf =HBufC::New(30);

       TPtr ptrBuf = pBuf->Des();            //注意堆是->，TBufC是.

 

堆缓冲区描述符

HBufC

在堆上，要用New方法

classRReadStream;

classHBufC16 :publicTBufCBase16

{

public:

       IMPORT_CstaticHBufC16 *New(TInt aMaxLength);

       IMPORT_CstaticHBufC16 *NewL(TInt aMaxLength);

       IMPORT_CstaticHBufC16 *NewLC(TInt aMaxLength);

       IMPORT_CstaticHBufC16 *NewMax(TInt aMaxLength);

       IMPORT_CstaticHBufC16 *NewMaxL(TInt aMaxLength);

       IMPORT_CstaticHBufC16 *NewMaxLC(TInt aMaxLength);

       IMPORT_CstaticHBufC16 *NewL(RReadStream &aStream,TInt aMaxLength);

       IMPORT_CstaticHBufC16 *NewLC(RReadStream &aStream,TInt aMaxLength);

      

       //也重载了“=”操作符

       IMPORT_CHBufC16&operator=(constTUint16 *aString);

       IMPORT_CHBufC16&operator=(constTDesC16 &aDes);

       inlineHBufC16&operator=(constHBufC16 &aLcb);

 

       IMPORT_CHBufC16 *ReAlloc(TInt aMaxLength);  //失败返回NULL，且原来的buffer的内容不变

       IMPORT_CHBufC16 *ReAllocL(TInt aMaxLength); //失败返回Leave。且原来的buffer的内容不变

 

       IMPORT_CTPtr16Des();

private:

       inlineHBufC16(TInt aLength);

private:

       TText16iBuf[1];

       __DECLARE_TEST;

       };

 

注意：

一旦重新分配，必须改变指向原来buffer的指针的指向，包括cleanup stack中的指针

       HBufC* buf =HBufC::New(15);

       CleanupStack::PushL(buf);

       _LIT(KText,"YunYun\n");

       *buf = KText;

       console->Write(*buf);

       buf = buf->ReAlloc(20);

       CleanupStack::Pop(buf);

       CleanupStack::PushL(buf);

       _LIT(KRepText,"&YunYun&&YunYun&\n");

       *buf = KRepText;

       console->Write(*buf);

       CleanupStack::PopAndDestroy(buf);

附：

1、小补充

1)、跟C++的小类比

TPtrC可以被看作是const char*的使用
TBufC可以被看作是char[]的使用

 

2)、对于所有的描述符，要访问其中数据，通过基类TDesC的非虚方法Ptr（），获取指向数据的指针。

 

3)、两种赋值方式的比较

TPtr p=buf->Des();

TPtr p(buf->Des());

第一句只是根据buf当前的真实长度得到一个指针（p的最大长度与当前的实际长度一样，就是buf此时的真实长度11），而第二句则完全用buf的信息来构造了p，所以它的最大长度应该是64,虽然当前的真实长度也是11。

 

4)、_LIT和_L宏

_LIT(KSayHelloSTR,"Hello world.");

而那个_L宏不提倡用了，因为效率太低的原因。

这里的KSayHelloSTR是另一种描述符TLitC。而TLitC提供两个运算符要注意：

&操作符能得到它的const TDesC*，而()操作符则得到它的const TDesC&。

KSayHelloSTR().Length(); //得到这个字串的长度

 

_L()可以生成一个指向字符值的地址（TPtrC），它经常被用来传递字符串到函数中：
NEikonEnvironment::MessageBox(_L("Error: init file not found!"));

 

TBuf<256> str;

str.Format(KFormatSTR,&KSayHelloSTR); //得到这个字串的引用地址

 

5)、两种字符串附值方法

HBufC* textResource;

textResource = StringLoader::LoadLC( R_HEWP_TIME_FORMAT_ERROR );
textResource =iEikonEnv->AllocReadResourceL(R_EXAMPLE_TEXT_HELLO);

TBuf<32> timeAsText;
timeAsText = *textResource;

 

6)、与C++的字符串不一样，Symbian中的描述符都是用一个附加的整数描述其长度，而不是以'\0'做终结符。因此，描述符可以表达任意数据，字符串或者二进制串。

  

2、选择描述符

 

使用原则

如果描述符里面包含二进制内容，应该使用8bit的描述符。
如果描述符里面包含宽字符，应该使用16bit的描述符。
否则应该使用没有制定bit的描述符。

 

 

一些常用的转化

一、描述符之间的转换

//TBuf  转换为 TPtrC16   

       TBuf<32> tText(_L("&YunYun& Miss You&"));   

       TPtrC16 tPtrSecond=tText.Mid(1,3);

 

//TPtrC16 转换为 TBufC16     

       TBufC16<10> bufcs(tPtrSecond);

 

//TBufC16 转换为 TPtr16   

       TPtr16 f=bufcs.Des();

 

//TPtr16 转换为 TBuf   

       TBuf<10> bufSecond;  

       bufSecond.Copy(f);

 

//TBuf 转换为 TPtr16    

       TBuf<10> buf1(_L("12132"));   

       TPtr16 ptr(f);   

       ptr.Copy(buf1);

 

//TBuf 转换为 TInt   

       TInt aSecond;   

       TLex iLexS(buf1);  

       iLexS.Val(aSecond); //现在aSecond里面就是buf1的值

 

 

       //TInt转换为 TBuf   

       TBuf<32> tbuf;   

       TInt i=200;   

       tbuf.Num(i);

       tbuf.Format(_L("%d" ) , aSecond);

       tbuf.AppendNum(aSecond);//又加了一次的aSecond

       console->Write(tbuf);  //12132

二、其他类型转化

1）TTime转TBuf型
       TBuf<32>theTime;//存储转换后的时间

       TTime tt;

       tt.HomeTime();

       _LIT(KTimeFormat,"%Y%M%D%1-%2-%3 %H:%T:%S");//格式为：2009-8-29 11:37:50

       tt.FormatL(theTime,KTimeFormat);//FormatL()会以KTimeFormat字符串的形式来格式化时间在赋值给theTime

 

2）TDateTime转TBuf型
       TTime currentTime;//声明一个TTime类型

       currentTime.HomeTime();//设置TTime为当前时间

       TDateTime tdt=currentTime.DateTime();//TTime   --->    TDateTime

       TBuf<32> tmp;//存储转换完的Buf

       tmp.AppendNum(tdt.Year());//用AppendNum()方法将一个Tint加入到TBuf中。

       _LIT(gang,"-");//声明一个横线分隔年月日，同样可声明冒号分隔小时分秒

       tmp.Append(gang);

       tmp.AppendNum(tdt.Month());

       tmp.Append(gang);

       tmp.AppendNum(tdt.Day());//…………时分秒的转换同上

      

方案1:

       _LIT(KTimeFormat," %H:%T:%S");

       TBuf<32> theTime;

       currentTime.FormatL(theTime,KTimeFormat);

       tmp.Append(theTime);

方案2:

       _LIT(mao,":");

       _LIT(kong," ");

       tmp.Append(kong);

       tmp.AppendNum(tdt.Hour());

       tmp.Append(mao);

       tmp.AppendNum(tdt.Minute());

       tmp.Append(mao);

       tmp.AppendNum(tdt.Second());

 

 

5）TBuf转TDateTime型
       _LIT(buf1,"2009-8-29 16:30:03");

       TBuf<32> timeBuf(buf1);

       TInt tmpInt = 0;

       TDateTime nowDate;

       _LIT(gang,"-");

       _LIT(mao,":");

       _LIT(kong," ");

      

       timeBuf.TrimAll();

      

       TBuf<4> sYear(timeBuf.Left(4));

       timeBuf.Delete(0,5);

       TLex iLexSY(sYear);  

       iLexSY.Val(tmpInt);

       nowDate.SetYear(tmpInt);

 

       TBuf<4> sMonth(timeBuf.Left(timeBuf.Find(gang)));

       timeBuf.Delete(0,timeBuf.Find(gang)+1);

       TLex iLexSM(sMonth);  

       iLexSM.Val(tmpInt);

       nowDate.SetMonth(TMonth(tmpInt));

      

       TBuf<4> sDay(timeBuf.Left(timeBuf.Find(kong)));

       TLex iLexSD(sDay);  

       iLexSD.Val(tmpInt);

       nowDate.SetDay(tmpInt);

       timeBuf.Delete(0,timeBuf.Find(kong)+1);

      

       TBuf<2> sHour(timeBuf.Left(timeBuf.Find(mao)));

       TLex iLexSH(sHour);  

       iLexSH.Val(tmpInt);

       nowDate.SetHour(tmpInt);

       timeBuf.Delete(0,timeBuf.Find(mao)+1);

      

       TBuf<2> sMinute(timeBuf.Left(timeBuf.Find(mao)));

       TLex iLexSm(sMinute);  

       iLexSm.Val(tmpInt);

       nowDate.SetMinute(tmpInt);

 

       TBuf<2> sSecond(timeBuf.Right(2));

       TLex iLexSS(sSecond);  

       iLexSS.Val(tmpInt);

       nowDate.SetSecond(tmpInt);

 

6）TPtrc8与TPtrc16之间转化

       // Get a iBuf8 from a iBuf16 (data are not modified)

       _LIT(KText,"YunYun");

       TBuf16<6> iBuf16(KText);

       TPtrC8 ptr8(reinterpret_cast<constTUint8*>(iBuf16.Ptr()),(iBuf16.Length()*2));

//Length()函数，返回字符串的长度(16位跟8位是2倍关系)。Size()函数，描述符所占的字节数（16位跟8位是4倍关系）      

TBuf8<12> iBuf8(ptr8);

 

       // Get a iBuf16 from a iBuf8 (data are not modified)

       TPtrC16 ptr16(reinterpret_cast<constTUint16*>(iBuf8.Ptr()),(iBuf8.Size()/2));

       iBuf16=ptr16;

 

       // Get a iBuf8 from a iBuf16 (data are modified)

       CnvUtfConverter::ConvertFromUnicodeToUtf8(iBuf8,iBuf16);

 

       // Get a iBuf16 from a iBuf8 (data are modified)

       CnvUtfConverter::ConvertToUnicodeFromUtf8(iBuf16,iBuf8);

 

7）Symbian串和char串间的转换

//将symbian串转换成char串

           char* p =NULL;

           TBuf8<20> buf( _L("aaaaa" ) );

           p = (char *)buf.Ptr();

 

 

//将char串转换成symbian串

           char* cc ="aaaa";

           TPtrC8 a;

          a.Set( (constTUint8*)cc ,strlen(cc) );

8)再加一点
       TDesC8 & buf ;

       TUint8* pdata ;

       pdata = buf.Ptr() ;
然后，这个pdata就可以当成unsigned char *用了，这在网络通讯的时候很重要。
如果，怕pdata破坏的话，可以
    TBuf8<1024> tmp_buf;

       tmp_buf.Copy(buf) ;

       pdata = tmp_buf.Ptr();
这样就可以保护一下buf的数据了，尤其是如果这个buf是Socket的接收的数据是接收函数自己分配的时候。

2009-04-16 23:10 977人阅读 评论(0)收藏 举报

Symbian描述符
描述符是symbian的基本类，不同于字符串，它可以处理字符串，也可以处理二进制
T类型的描述符,跟其他基本类(Tint)一样,都是在栈中创建
描述符同时支持8位和16位两种:TPtr8,TPtr16等
在创建时并不需要指定它时那种类型,它是在创建时的设置决定的
当用来存储二进制数据的时候,使用的是8位的版本

可实例化的类
TBufC:缓冲区描述符(不能直接创建)
TBuf:缓冲区描述符(可改变)
TPtrC:指针描述符(不能改变)
TPtr:指针描述符(可改变)
HBufC:堆缓冲区描述符(不能改变,也能声明在栈中)

这些描述符常用的属性都有如下:
Length:可以存储在buffer中的数据项(item)数目
Size:buffer中有效数据所占用的字节数
Maximum length:可能存储在buffer中数据项的最大数目
_LIT(KHello, "hello");
TBuf<12> buf(KHello);
这里length=5 size如果是ASCII构建的就是5,如果是Unicode构建的就是10
max length是12

越界问题
所有描述符都不能赋予超过它自身长度的数据,不然会发生panic,这是一种内部机制
对于TPtr和TBuf都不能改变一个已经存在的描述符的长度使其超过MAXLENGTH

_LIT宏
它用来声明一个字符串成员
可以产生一个8位或16位的TLitC对象
TLitC提供了转换操作符,因此可以作为TDesC&类型传递给各种函数,包括构造函数
注意:TLitC并不是描述符

TBufC<S>和TBuf<S>
前者数据是不可以修改的,后者可以修改数据
TBufC有四个构造函数
TBufC();
TBufC(const TBufC<s>& aLcb);
TBufC(const TDesC& aDesc);
TBufC(const TUint* aString);
TBuf与TBufC的构造函数相同,其中<S>代表最大长度

TBufC<S>的赋值操作符
TBufC<S>& operator=(const TBufC<S>& aBuf);
TBufC<S>& operator=(const TDesC& aDes);
TBufC<S>& operator=(const TUint* aString);
TBuf<S>跟它一样

TPtrC
它的数据是只读的,它指向一个数据缓冲区
它的构造函数
TPtrC();
TPtrC(const TPtrC& aDes);
TPtrC(const TDesC& aDes);
TPtrC(const TUint* aString);
TPtrC(const TUint* aBuf, TInt aLength);
最后一种可以进行字符集转换
TPtrC16 myPtr(reinterpret_cast<const TUint16*>(iDataBuffer.Ptr()),
(iDataBuffer.Size()/2));
iDataBuffer16 = myPtr;

也可以通过set方法对其进行设置
void Set(const TDesC& aDes);
void Set(const TPtrC& aPtr);
void Set(const TUint* aBuf, TInt aLength);

 

 

 

 

描述符是Symbian C++字符串的描述类，不同于string，它既可以表示字符串，也可以表示二进制数据；同时支持8位和16位，但是用来存储字符串时并不需要指定哪种类型 ，而是由编译时的设置决定，也可以在创建对象时声明，如TDes8,TDes16等等

      #if defined（_UNICODE）

           typedef TPtrC16 TPtrC

        else

           typedef TPtrC8 TPtrC

  一般来说用来存储二进制数据时通常使用8位版本。

上面的宏定义在symbian里面到处可见，在e32def.h里面，有很多symbian重新定义的类型。

类型

描述符可以分为五大类，分别是抽象描述符、文字描述符、缓冲区描述符、指针描述符和堆缓冲区描述符。下图为类继承关系图（抽象类不能创建对象，一般用于参数，C结尾的为不可修改const）

 

 

 

说明

1、抽象描述符

     抽象描述符包含TDesC和TDes，TDes 是从TDes派生的，因为这些类是抽象的，所以不能实例化，它们多数用于函数参数。TDesC是所有描述符的基类，而TDes与TDesC不同的是 TDes可以对数据进行修改，并引入数据最大长度的概念。因为它是所有描述符的基类，继承它的所有类型都拥有它的方法。

  2、文字描述符

     文字描述符是我们用的比较多，它主要用来保存字符串常量，常用方法如下：

_LIT(KHelloWorld,"Hello World!");

_L("Hello world!");

上面是根据宏定义来建立文字描述符对象，建议这样使用，不建议使用TLitC来创建文字对象；

 

当使用_LIT()宏的时候，产生的其实是一个TLitC对象（8位或16位），数据实际上被存储在装载到RAM的二进制应用程序内，虽然它们实际上并不存储在ROM（或与ROM类似的闪存）中，所以可以把它们看成是只读的

可以使用（）操作符将描述符转换成常量的TDesC对象，比如：

TInt length=KHelloWorld().Length()；

 

 3、缓冲区描述符

   缓冲区描述符TBufC和TBuf将它们的数据存储为本身的一部分，既然该描述符使用在编译时就确定的固定数量的内存，因此可以在栈上对其进行声明（作为局部或者成员变量），这里看个小例子。

_LIT(KHelloWorld,"Hello World");

const TInt maxBuf=32;

...

TBufC<maxBuf> buf;//空缓冲器，长度为0，从这里也可以看得出，缓冲描述符一定要声明一个长度。

TInt currentLen=buf.Length();//==0

buf=KHelloWorld;//在构造函数之后设置内容

currenLen=buf.Length();//==11

TText ch=buf[2]//=="l"

  这里要注意的是TBufC是TDesC的子类，而TBuf是TDes的子类，因此TBuf也提供了修改数据等的多种功能。后面会总结它的修改的方法。

4、指针描述符

      指针描述符TPtrC和TPtr用于引用存储在别处的、不属于该描述符所拥有的数据。使用TPtr或者TPtrC来访问字符串比维护指向零值终止（zero-terminated）字符串指针更加安全。下面是一个小例子:

_LIT(KHelloWorld,"Hello World");

TBufC<maxBuf> buf;

buf=KHelloWorld;//设置内容

TPtr ptr=buf.Des();//取得指向该缓冲器的指针

ptr[7]='a';//将‘0’变成'a'

ptr[8]='l';//将‘r’变成'l'

ptr[9]='e';//将'l'变成‘e’

ptr[10]='s';//将‘d’变成‘s’

//现在缓冲器的内容为“Hello Wales”

 5、堆缓冲区描述符

      堆描述符HBufC封装了存储在堆上的、属于该描述符所拥有的数据。由于这些数据是动态分配的，因此通过重新分配堆缓冲器，可以在运行时对描述符的最大长度进行设置很改变。

      BufC是基于TDesC，并且提供了方法来改变所存储数据的长度（HBufC::ReAlloc()和HBufC::ReAllocL()）,以及赋值 操作来设置数据的内容（受限于最大长度，不能超过最大长度）。可以通过使用HBufC::Des()获取可修改指针描述符来修改描述符的内容，下面是一个 小例子：

_LIT(KHelloWorld,"Hello World!");

HBufC *heapBuf=HBufC::NewL(KelloWorld().Length());//声明一个长度为KHelloWorld长的堆描述符

*heapBuf=KHelloWorld;

delete heapBuf;

 

转换

描述符之间的转换，如TDesC8和TDesC16之间的转换有两种方式：

1、使用Copy

_LIT8(KTestStr, "This is a string");
TBufC8<50> buf(KTestStr);

TBuf<100> newBuf;
newBuf.Copy(buf);

TBuf8<50> newBuf1;
newBuf1.Copy(newBuf);

 

2、使用CCnvCharacterSetConverter类

 _LIT8(KTestStr, "This is a String"n");
TBufC8<50> buf(KTestStr);

CCnvCharacterSetConverter* conv = CCnvCharacterSetConverter::NewL();

CleanupStack::PushL(conv);

RFs fs;
User::LeaveIfError(fs.Connect());

if (conv->PrepareToConvertToOrFromL(KCharacterSetIdentifierAscii, fs) != CCnvCharacterSetConverter::EAvailable)
{
User::Leave(KErrNotSupported);
}

HBufC* str = HBufC::NewL(buf.Length());
CleanupStack::PushL(str);

TPtr ptr = str->Des();
TInt state = CCnvCharacterSetConverter::KStateDefault;

if (conv->ConvertToUnicode(ptr, buf, state) == CCnvCharacterSetConverter::EErrorIllFormedInput)
{
User::Leave(KErrArgument);
}

fs.Close();
console->Write(ptr);

CleanupStack::PopAndDestroy(2); 

 

方法

1、描述符都有的方法：

   Locate():    定位指定字符的位置；

   Compare(): 按字节比较两个描述符大小

   Match():     搜索指定描述符的位置，可使用？ *等通配符

   Find():       搜索指定描述符在当前描述符中第一次出现的位置

   Left():       提取描述符最左边的数据

   Right():     提取描述符最右边的数据

   Mid():        提取描述符中间的位置

 2、只有TPtr和TBuf才有的函数：

   Append():    在描述符后面添加一个字符；

   LowerCase():将描述符转为小写字母

   UpperCase():将描述符转为大写字母

   Insert():在指定位置插入新的描述符

   Delete():在指定位置删除指定长度个数据项

 3、描述符的典型用法：

    1、TBuf/TBufC:栈上的小数据量存储

    2、TPtrC：常量字符串或数据

    3、TPtr：指向常量字符串或数据，通过Des()方法进行数据修改

    4、HBufC：大数据量时的处理

 

 

 

 

 

如何将HBuf转化为TBuf?

 

LIT(KSomeText, "Symbian");

HBufC* heapBuffer=HBufC::NewLC(15);

*heapBuffer = KSomeText;

TBuf<15> buffer(*heapBuffer);

CleanupStack::PopAndDestroy( heapBuffer );