NewLC - conversion between char* and Descriptors - Comments

Re: conversion between char* and Descriptors

gmsk19 — Mon, 09 Jun 2008 07:47:19 +0200

i think u can try this code:

//if this is character string
char * info = new [ELeave] char[32];
//Use Mem::Copy(..) to copy data to char string
TBuf buffer((unsigned char*)info);//buffer has copied info's contents

Re: conversion between char* and Descriptors

Kerrigan — Wed, 04 Jun 2008 07:38:54 +0200

try my first reply...

Re: conversion between char* and Descriptors

praveen.nitdgp@gmail.com — Tue, 03 Jun 2008 13:22:18 +0200

simple
char * hexParams = (char*) malloc(100);
TInt aLength = strlen(hexParams); ;
//Convert to Symbian TPtr8 from C Char * array
TPtr8 msg2(reinterpret_cast(hexParams),aLength,aLength);

Re: conversion between char* and Descriptors

alh — Wed, 28 May 2008 10:06:47 +0200

If you want to copy your literal string to a new buffer, and send it in as a char* I'd recommend this pattern:

_LIT(KTestData,"test source data");

RBuf8 buf;
buf.CreateL(KTestData().Length() + 1);

char* charptr = buf.PtrZ();

myfunction(charptr); // ... or whatever...

buf.Close();

Then its easy to follow symbian standards in the symbian part of your code.

If your function is supposed to take over ownership of the char buffer, only then would I recommend using malloc...

But in that case, I'd recommend simply this:

_LIT(KTestData,"test source data");

myfunction(KTestData().Ptr()); // ... or whatever...

And let the non-symbian code do the malloc.

Much better to keep such things collected, and not pollute any file with using dual coding standards in it.

Re: conversion between char* and Descriptors

prajwal.r.m — Tue, 27 May 2008 15:19:18 +0200

I have a way to do it
Just try this

TPtrC& pBody = _L("test source data"); 
TInt len = pBody .Lenght();

char*  srcData = (char*) malloc(sizeof(char)*len);

TUint8* ptr = pBody.Ptr();

for(i=0;i<=len+1;i++)
{
srcData[i] = ptr[i];
}

I think srcData ll contain the desired result

Re: conversion between char* and Descriptors

prajwal.r.m — Tue, 27 May 2008 15:08:49 +0200

Hi Nikolas,

If you are asking to ve a default constructor for TPtr() it means two things

1] You just want a pointer which ll point to some data.No memory allocation is needed (you are not owning it)
2] And this descriptor is modifiable.

Now let us take your example.

void method (TPtr& aPtr)
{
   aPtr = _L("blob") ;//where the memory is allocated ??
                                  //and it is modifiable check whether it is supposed to modifiable??
}

TPtr ptr ;
method(ptr) ;
// now ptr points to "blob"

The memory for _L("blob") is allocated on constant data segment which is not supposed to be modified but what is your intension here??
got it ??
thats exactly the reason why it is not there

Re: conversion between char* and Descriptors

alh — Tue, 27 May 2008 14:31:41 +0200

If the descriptor is pointing to a string defined in a _LIT(), then the string will already be Zero-terminated.

If you have in any way copied the string around in descriptor buffers, the zero will have been lost, and you MUST have space in the descriptor buffer and use PtrZ() to write a new Zero at the end of the buffer.

This is because the descriptors only copy the number of bytes specified by its Length() and that is specified without the Zero (since descriptors don't use zero-termination)
The Zero is already there in the case of _LIT():s because of how C++ work, they will be left there because writing "somestring" in C++ always imply a Zero at the end, but the Zero will in fact be "outside" of space pointet out by the Literal descriptor.

Re: conversion between char* and Descriptors

er.khalid — Sat, 17 May 2008 23:24:44 +0200

Hi RajaRK

from descriptor to char*::

char *q = (char *) ptrC8.Ptr();

It seems that char* q will not be a null terminated string??
So it won't be a C-string.?

Re: conversion between char* and Descriptors

RajaRK — Sat, 17 May 2008 08:41:35 +0200

from char* to descriptor::

char *p = "c string";

TPtrC8 ptrC8(p, p->strlen());

from descriptor to char*::

char *q = (char *) ptrC8.Ptr();

Re: conversion between char* and Descriptors

Fructose — Thu, 15 Feb 2007 17:22:05 +0100

strlen() is a C function, not C++, not Symbian -> therefore what must you do to the end of the data in the string to turn it into a C string? That's your answer.

Re: conversion between char* and Descriptors

bharatuppal — Thu, 15 Feb 2007 13:05:46 +0100

Hi all

ihave a small question

how to get the length of the unsigned char array?

I am doing something like this

typedef unsigned char hs_uchar
typedef char hs_char

hs_uchar readbuf[960];
hs_char* temp_string;

Now I have one buffer of size 320 by the name iBufferList[index]
I am doing as follows
temp_string = (hs_char*)read_buf;
memcpy(temp_string, iBufferList.Ptr(),320);

every time I checked the length I got some other numbers but I am expecting a length of 320 because iBufferList is of size 320

I even tried this method

Mem::Copy(readbuf,iBufferList.Ptr(),320);
TInt len = strlen(readbuf);

but stilll the same result every time the length is less than 320 sometimes its gives 960 sometimes it gives exact 320

can any one gives any comments or just tell me how exactly to fine the length of unsigned char array (filled length)

With Regards

Re: conversion between char* and Descriptors

bharatuppal — Fri, 02 Feb 2007 06:41:44 +0100

Hey Numpty thanks

Actually I solved the problem
When I was using the Mem::Copy function

The address was copied to recdata I debugged the application to check that

the char string which was passed to my mediarecord function already got that data

in other words recdata was the reference

Anyways Thanks

Re: conversion between char* and Descriptors

NumptyAlert — Thu, 01 Feb 2007 18:18:08 +0100

Have you looked at the contents of recdata? What if the 2nd character is already '\0'?

I presume tempdata.ptr is a typo?

How do you know tempdata definatly contains 256 bytes of data?

Re: conversion between char* and Descriptors

bharatuppal — Thu, 01 Feb 2007 15:52:11 +0100

following is my scenario

readmedia(char* recdata, int length)
{
TBuf8<260> tempdata;

readfrommic(tempdata); // readfrommic(TDes8& data)

}

so now tempdata gets 256 bytes of data from readfrommic()

now my problem is I want to give this data to recdata which i character string

after doing what waas told above

Mem::Copy(recdata,tempdata.ptr,256);
recdata[257] = 0;

I called strlen(recdata);

I got the value as 1

What is the reason I want the entire tempdata content to be copied to recdata how can I do that

With Regards

Re: conversion between char* and Descriptors

zasdfaaa — Mon, 06 Nov 2006 02:31:11 +0100

standby mark.

conversion between char* and Descriptors

jiangzhu20 — Wed, 10 Aug 2005 11:04:37 +0200