C / C++ / MFC

Re: char * - returning address of local variable or temporary

8-Nov-10 5:50

The problem is that you are returning a pointer to a buffer that will go out of scope after your function exit: then then returned pointer is no longer valid and what you find there is going to be pseudo-random.
To fix the problem you can:

allocate the output buffer out from the function
allocate the output buffer using new or malloc (but you should remember to deallocate it when it is no more needed)

However, as Alan said, the very best way is to stop using C-style strings and use std::string instead: the STL is one of the better solutions because all its classes are inlined and highly optimized. This will give you very good performances with a minimal footprint (the unused classes and methods simply are not compiled and don't affect the executable size).

«_Superman_»8-Nov-10 7:03

«_Superman_»

8-Nov-10 7:03

You should look up to the signature of strcpy as a reference.
The first parameter to strcpy is the out parameter and the second is the in parameter.
So change your function to be something similar even though it really doesn't make sense in this context -

int Func(char* sRet, const char* sT)
{
    return strcpy(sRet, sT);
}

Also, if you're not able to use std::string, at least use the secure versions of the C runtime functions like strcpy_s.

«_Superman_»
I love work. It gives me something to do between weekends.

Microsoft MVP (Visual C++) Polymorphism in C

Re: char * - returning address of local variable or temporary

tom144312-Nov-10 2:26

tom1443

12-Nov-10 2:26

sRet is a local variable allocated on the stack and as such the memory it uses will be reclaimed when Func returns. That means the stuff it points to will probably not contain what you think it does at some point in the future.

So you have essentially 2 choices:

1. Use void Func (char * sT, char * sRet) as you suggest. Func would then copy the string into the memory supplied by the caller. That memory of course has its own lifecycle.

2. Allocate memory in Func(). For example in C++:

char * Func (char * sT)
{
char * sRet = NULL;

sRet = new char[MAX_STR_SIZE];

if (sRet)
strcpy (sRet, sT);

return sRet;
}

In this case someone has to deallocate the newed up memory later. So for example:
void Foo(void)
{
char *mystr = Func("test");

DoSomethingInteresting(mystr);

delete mystr [];
}

edit control not responding in a dialog created within an activex control

lakshman rao8-Nov-10 2:59

Re: edit control not responding in a dialog created within an activex control

8-Nov-10 2:59

Hi,

I've created a dialog box from within the activex control and it contained a edit control.
But that edit control doesn't accept text when it is displayed..What might be the prob?

David Crow8-Nov-10 3:36

David Crow

8-Nov-10 3:36

lakshman rao wrote:
But that edit control doesn't accept text...

You can't type into it? You can't paste into it? You can't set its text via code? Confused | :confused:

Re: edit control not responding in a dialog created within an activex control

lakshman rao8-Nov-10 3:48

Re: edit control not responding in a dialog created within an activex control

8-Nov-10 3:48

DavidCrow wrote:
You can't type into it? You can't paste into it? You can't set its text via code?

I can't type into it.

David Crow8-Nov-10 3:51

David Crow

8-Nov-10 3:51

Has it been disabled or set to read-only?

Re: edit control not responding in a dialog created within an activex control

lakshman rao8-Nov-10 3:55

Re: edit control not responding in a dialog created within an activex control

8-Nov-10 3:55

DavidCrow wrote:
Has it been disabled or set to read-only?

Nope, both properties are set to false

lakshman rao18-Nov-10 23:47

Translate C-Code to Csharp

18-Nov-10 23:47

does anybody know reason fot this?

djfresh8-Nov-10 2:16

8-Nov-10 2:16

Can sb. translate following code to C# pls:

<br />
/***********************************************************************<br />
* Function Name: UuDecodeLength<br />
*<br />
* Description: Determines the length of the raw data given the<br />
* length of the UU-Encoded data<br />
*<br />
* Arguments:<br />
* nSrcLen Length of the UU-Encoded data<br />
*<br />
* Returns<br />
* Number of bytes of data<br />
**********************************************************************/<br />
<br />
INT32U UuDecodeLength(INT32U nSrcLen)<br />
{<br />
INT32U uDestLen;<br />
uDestLen = (nSrcLen * 3) / 4;<br />
return uDestLen;<br />
}<br />
/***********************************************************************<br />
* Function Name: UuEncodeLength<br />
*<br />
* Description: Determines the length of the UU-Encoded data given<br />
* the length of the raw data<br />
*<br />
* Arguments:<br />
* nSrcLen Length of the raw data<br />
*<br />
* Returns<br />
* Number of bytes of UU-Encoded data<br />
**********************************************************************/<br />
<br />
INT32U UuEncodeLength(INT32U nSrcLen)<br />
{<br />
INT32U uDestLen;<br />
uDestLen = (nSrcLen * 4) / 3;<br />
if ( ((nSrcLen * 4) % 3) != 0 )<br />
{ // we need a partial byte, add one...<br />
uDestLen++;<br />
}<br />
return uDestLen;<br />
}<br />
<br />
/***********************************************************************<br />
* Function Name: UuDecode<br />
*<br />
* Description: UU-Decodes the given ASCII data<br />
*<br />
*<br />
* Arguments:<br />
* pSrc Pointer to the source data (UU-Encoded data)<br />
* pDst Pointer to the destination data (binary data)<br />
* nSrcLen Length of the source buffer<br />
*<br />
* Returns<br />
* Number of bytes in the pDst array<br />
**********************************************************************/<br />
<br />
INT32U UuDecode(INT8U* pDst,const INT8U* pSrc,INT32U nSrcLen)<br />
{<br />
unsigned int nDstIndex;<br />
unsigned int nSrcIndex;<br />
nDstIndex = 0;<br />
nSrcIndex = 0;<br />
while(nSrcIndex < nSrcLen)<br />
{<br />
// Decode A // Bits Src Offset<br />
pDst[nDstIndex] = ((pSrc[nSrcIndex++] - 0x20) << 2 ) & 0xFC; // A7:2 0<br />
pDst[nDstIndex++] |= ((pSrc[nSrcIndex] - 0x20) >> 4 ) & 0x03; // A1:0 1<br />
if ( (nSrcIndex + 1) >= nSrcLen )<br />
{ // we need one more byte to decode B<br />
break;<br />
}<br />
// Decode B<br />
pDst[nDstIndex] = ((pSrc[nSrcIndex++] - 0x20) << 4 ) & 0xF0; // B7:4 1<br />
pDst[nDstIndex++] |= ((pSrc[nSrcIndex] - 0x20) >> 2 ) & 0x0F; // B3:0 2<br />
if ( (nSrcIndex + 1) >= nSrcLen )<br />
{ // we need one more byte to decode C<br />
break;<br />
}<br />
// Decode C<br />
pDst[nDstIndex] = ((pSrc[nSrcIndex++] - 0x20) << 6 ) & 0xC0; // C7:6 2<br />
pDst[nDstIndex++] |= ((pSrc[nSrcIndex] - 0x20) ) & 0x3F; // C5:0 3<br />
nSrcIndex++;<br />
}<br />
return nDstIndex;<br />
}<br />
<br />
/***********************************************************************<br />
* Function Name: UuEncode<br />
*<br />
* Description: UU-Encodes binary data<br />
*<br />
* Arguments:<br />
* pSrc Pointer to the source data (binary)<br />
* pDst Pointer to the destination data (UU-Encoded data)<br />
* nSrcLen Length of the source buffer<br />
*<br />
* Returns<br />
* Number of bytes in the pDst array<br />
**********************************************************************/<br />
<br />
INT32U UuEncode(INT8U* pDst,const INT8U* pSrc,INT32U nSrcLen)<br />
{<br />
unsigned int nDstIndex;<br />
unsigned int nSrcIndex;<br />
nDstIndex = 0;<br />
nSrcIndex = 0;<br />
while(nSrcIndex < nSrcLen)<br />
{<br />
// Encode A<br />
pDst[nDstIndex++] = ((pSrc[nSrcIndex] >> 2) & 0x3F) + 0x20;<br />
pDst[nDstIndex] = (pSrc[nSrcIndex++] << 4) & 0x3F;<br />
if ( nSrcIndex >= nSrcLen )<br />
{ // this is the last byte<br />
pDst[nDstIndex] += 0x20;<br />
nDstIndex++;<br />
break;<br />
}<br />
// Encode B<br />
pDst[nDstIndex] |= (pSrc[nSrcIndex] >> 4) & 0x3F;<br />
pDst[nDstIndex++] += 0x20;<br />
pDst[nDstIndex] = (pSrc[nSrcIndex++] << 2) & 0x3F;<br />
if ( nSrcIndex >= nSrcLen )<br />
{ // this is the last byte<br />
pDst[nDstIndex] += 0x20;<br />
nDstIndex++;<br />
break;<br />
}<br />
// Encode C<br />
pDst[nDstIndex] |= (pSrc[nSrcIndex] >> 6) & 0x3F;<br />
pDst[nDstIndex++] += 0x20;<br />
pDst[nDstIndex] = (pSrc[nSrcIndex++] & 0x3F) + 0x20;<br />
nDstIndex++;<br />
}<br />
return nDstIndex;<br />
}<br />

Sauro Viti8-Nov-10 2:24

8-Nov-10 2:24

No! No one will do your job for you! Please make an effort and came back with questions about specific issues, showing what have you already done, explaining why it doesn't work as you expected and possibly adding a code snippet of the relevant code!

djfresh8-Nov-10 2:51

8-Nov-10 2:51

ok I've made the job only just...

but can somebody explain to me the UU-Encoding,
because i.e. the UuEncode method returns an unsigned integer.
I thought UU-Encoding converts Unicode to ASCII.
So what should I do with this "uint"?

The method "UuEncodeLength" returns me the same length...

So I don't see there any differences in their functions...

Sauro Viti8-Nov-10 3:31

8-Nov-10 3:31

djfresh wrote:
The method "UuEncodeLength" returns me the same length...

This is not true; look at its code:

C++

INT32U UuEncodeLength(INT32U nSrcLen)
{
INT32U uDestLen;
uDestLen = (nSrcLen * 4) / 3;
if ( ((nSrcLen * 4) % 3) != 0 )
{ // we need a partial byte, add one...
uDestLen++;
}
return uDestLen;
}

Now let's look at what happen:

if nSrcLen = 1 then the function returns 2;
if nSrcLen = 2 then the function returns 3;
if nSrcLen = 3 then the function returns 4;
if nSrcLen = 4 then the function returns 6;
and so on...

djfresh8-Nov-10 3:47

8-Nov-10 3:47

sorry my english is not so good...

I've meant that the methods UuEncodeLength and UuEncode are returning the same value...
i.e. if you enter 2 characters they both returns 3.

Example:

12 returns 3...

but real UUencoding must return:

,3(@

Sauro Viti8-Nov-10 4:07

8-Nov-10 4:07

You have misunderstood the code:

The UuDecodeLength and UuEncodeLength functions get the length of a string as parameter and return the required length of the correspondant decoded/encoded string.
The UuDecode and UuEncode functions get three parameters: an output buffer, an input string and the length of the input string. They return the number of bytes written to the output buffer, and put on the output buffer the decoded/encoded version of the input string.

I tried this on my PC:

C++

int main(int argc, char* argv[])
{
   INT8U in = "12";
   INT8U* out = (INT8U*)malloc(UuEncodeLength(2));
   INT32U n = UuEncode(out, in, 2);

   // Put a breakpoint here and look what happened
   // Now n is 3 and inside out you find ",3(" i.e.:
   // out[0] = ','
   // out[1] = '3'
   // out[2] = '('

   free(out);
}

djfresh9-Nov-10 2:12

9-Nov-10 2:12

Thanks now I understand the Code,

I've to translate the "out" (in my case byte-array) into ASCII (string-array), then it is working.

"12" =(UuEncoding)= ",3)"

thanks Sauro Viti for this dump...