conversion from Char * to CString , mfc, release mode

Thanks for the reply!

No, I am not deriving from CString , so I don't have any idea of PXSTR too..

Basically the actual code is the below.

CoverageType = ems[i]->coverageType;

I have a requirement where I have to get values from web service response. Now I want to take the response (ems[i]->coverageType) and assign it to a CString varibale and show in an application list box.

So when I run my application in release mode and try to debug, the application is unable to go furthur than this line
CoverageType = ems[i]->coverageType;

So I get an "unhandled exception" dialog error box and when I click on debug to see where the application is failing , it goes  to" PXSTR pszBuffer = GetBuffer( nLength );" present in atlsimpstr.cpp (which is an mfc file)

Let me know if the description is clear.

The GetBuffer is a member function of CString (respectively an internal string class implementing CString) which returns a pointer to a writeable character buffer managed as the internal buffer of a CString. If that statement blows up the nLength probably is negative or a huge number.

Is your app a UNICODE application or MULTIBYTE? Check the properties if you don't know (Release mode configuration).



 

>>>> CoverageType = ems[i]->coverageType;
You could try

  CoverageType = CString(ems[i]->coverageType);


That would cal CString constructor rather than CString::operator= what be give a difference.

My app in MULTIBYTE.. I tried  CoverageType = CString(ems[i]->coverageType) in release mode

but it is giving different error. I have attached the snaphot of the error:

In debug mode the application just hangs on this line
CoverageType = CString(ems[i]->coverageType)

The code which works in DEBUG mode is like this:
-----------------------------------------------------------------
                  CoverageType.GetBuffer(40);
                  CoverageType = ems[i]->coverageType ;
-------------------------------------------------------------------------

I tried like this but that is also not working
CoverageType = CString(ems[i]->coverageType).GetBuffer(40)

Just an aside, I think the PXSTR is what microsoft uses internally in the CString.

Just a guess - is it a multi-threaded application? Do you have a call-back functions that may access this CString variable from different threads?

The code which works in DEBUG mode is like this:
-----------------------------------------------------------------
                 CoverageType.GetBuffer(40);
                 CoverageType = ems[i]->coverageType ;
-------------------------------------------------------------------------


Why do you need the call to GetBuffer, you are reassigning the complete string with the next line.

(I suspect you have another problem elsewhere in your code that is causing this in RELEASE mode)

From question:
Error shown in the line "PXSTR pszBuffer = GetBuffer( nLength );" present in atlsimpstr.cpp

That is happening in the CoverageType.GetBuffer(40)

>>>> That is happening in the CoverageType.GetBuffer(40)

Don't think so.  The asker told it would crash in

    CoverageType = ems[i]->coverageType ;

Here the internal CSimpleString would call GetBuffer to allocating the space needed for the assignment. I think there is a corruption somehow regarding ems[i]->coverageType. Then, the GetLength on thsi variable would return some negative or huge value what causes the crash. Or the CoverageType is corrupted.

Ahhh, I see what you mean.  You think the GetBuffer(40) call succeeds (even though it is redundant).


As you said, probably something like variable 'i' not being initialised is the problem.

I am trying to use following code

char* p = _T(ems[i]->coverageType);
char* p1 = "Amount ";
int i = strlen(p);
int j = strlen(p1);

But here i is coming as some junk value (0x00000b)
j is coming as 0x0000007 which is correct

If I put AfxMessageBox(p) I do see the value as "Amount" but  why I am unable to calculate the strlen of *p?

Do you see
"Amount"
or do you see
"Amount           "


Difficult to test with a message box display !

I see like "Amount           "

OK, now get back onto topic with your problem.  

So how do I transfer the  values in "ems[i]->coverageType" which will come as "Amount   " or "Text   "

into CSTring variable??

If I use char *p = ems[i]->coverageType , I need to Trim the variable P in later stages.

what solutions do you suggest?

I tried as attached in the code snippet and the application worked fine.
 
CoverageType  is not the only variable I am using , there are other variables too which are char* and  I am assign them to CString . All those variable does not fail.
e.g
emsName = ems[i]-> emsName ;
emsName = ems[i]-> emsType;
coverageText = ems[i]->coverageText.



Let me if the solution looks OK.

char * enhCoverage = NULL;
enhCoverage = enhancement[i]->coverageType;
CoverageType = CoverageType.GetBuffer(1024);
CoverageType =enhCoverage;
 
delete enhCoverage

                                              

1:
2:
3:
4:
5:
6:

this line 3 is not required:  CoverageType = CoverageType.GetBuffer(1024);
line 6 - probably very dangerous, that is effectively    delete enhancement[i]->coverageType;

>>>> But here i is coming as some junk value (0x00000b)
>>>> j is coming as 0x0000007 which is correct
None of those are junk. You might switch of the hex display (right-click at the watch window and uncheck hexidecimal display) and would see that 0x000000b is 11 and 0x00000007 is 7 what both seems fairly correct.

>>>> CoverageType = CoverageType.GetBuffer(1024);
As told a few times by me and Andy the GetBuffer is not needed here. It would reserve an internal buffer of 1024 chars which would be freed with the next assignment.

The purpose of GetBuffer is to provide a writeable buffer (char*) with a CString in case you were calling a function which needs such pointer as an argument. That isn't the case here.

>>>> enhCoverage = enhancement[i]->coverageType;
That shouldn't compile. The right-hand is a CString which could be automatically casted to 'const char*'. If you have a left-hand char* and a right-hand 'const char*' the compiler should deny to compile the assignment statement.

>>>> delete enhCoverage

NEVER DELETE POINTERS YOU DON'T HAVE ALLOCATED.

I don't know what you were trying to do. If using string classes you don't must and need play with pointers. It is not only dangerous as Andy told you but simply a sure method to make your app crash.

I did the stupidiest thing. I never initialized the variable, thinking the code is already there !!. once I assign
 CString CoverageType  = _T("") in the constructor, I was able to assign char * to CString,

Thanks everyone for participating.

>>>> I did the stupidiest thing. I never initialized the variable
I am glad that it works now, but the problem is not solved but only 'moved'. A CString variable don't need to be initialized as it has a default constructor which does the job. If you do

   CString CoverageType  = _T("");

you were only using a different constructor (that which takes a right-hand const char* - or const wchar_t* - literal). If taht solves a problem, it only means that the corruption which happened somewhere between CString construction and CString assignment now was not spoiling the internal pointer of CoverageType. But surely it could spoil any other variable - if not now it could be later. I don't want to confuse you but keep it in mind if some strange things happen later.