is the statment legal?

Is the following legal?

std::string sString = "lalalala";
const char* pszStr = sString.c_str();

or should I do:

std::string sString = "lalalala";
const char* pszStr = new char[sString .length() +1];
strcpy(pszStr, sString.c_str());
.
.
delete pszStr;

thanks
avi123

The second example is not quite right. It should char* pszStr instead of const char* pszStr. If you use const char* pszStr, You're not suppose to modify it, like using strcpy().

you are right

but what I care more is the first option ok?
will pszStr from the first 1 is valid for use?
I mean can I do for example printf(pszStr) without worry?
can I copy it to another char * (non const one) and modify it (the other one?)

I mean can I do that:

std::string sString = "lalalala";
const char* pszConstStr = sString.c_str();

printf( pszConstStr );
char * pszStr = pszConstStr;

??

thanks

It should be alright for the printf() and you should copy it before modifying.

As long as your are not adding data or changing the data which the pointer adresses, there should be no problem. But it is not defined what the string class will retun to you, if you call "c_str()". It depends on the stl. E.g. some will return you a copy of there data, some will return you a copy on write of there data, some will return you a real copy.
But as far as i know, in most cases it will be the current adressspace of the coresponding string class. This is because someone have to take care about freeing the memory etc. So be aware if you change the string himself afterwoods. It is possible that your pointer will be no longer point to a valid adress due to reallocations in the string class.
To get sure, don't use char pointers in conjunction with strings. That means, if you have to, try to minimize it and use the semantic of the stl and c++.

RalfGriggel

If I understand correctly you are against option 1 but what about option 2:


std::string sString = "lalalala";
char* pszStr = new char[sString .length() +1];
strcpy(pszStr, sString.c_str());
.
.
.
delete pszStr

It will work, as long as your are also too take care about freeing the memory. But for a simpler solution, or to get raw, try strdup, because it will allocate the memory for your (but it uses malloc, not new) and will work in this case, because c_str() will return a "C-String" which is ending by a "Zero".

This is a case of creating a copy of the stl-string and working with it. I can't see any improvement, because you won't be able to add something here. You can change it, but for this the stl-string class is much better. So, using it as a "read only" pointer, you don't have to make a copy of the string.

If it had to, i would only use a pointer to c_str(), but would not create a copy. As long as it is possible i would use the stl-string.

RalfGriggel

I need this std::string as char* (non const) so I could use it as parameter to the function CryptEncrypt

Quote:

---

Originally posted by avi123
Is the following legal?
const char* pszStr = new char[sString .length() +1];
.
delete pszStr;

---

Undefined behavior.

Code:

---

// Correction
delete [] pszStr;

---

Regards,

Paul McKenzie

Quote:

---

Originally posted by avi123
RalfGriggel

I need this std::string as char* (non const) so I could use it as parameter to the function CryptEncrypt

---

Use std::vector<char>. No need to new[] and delete[].

Code:

---

#include <vector>
#include <string>
#include <algorithm>

void foo()
{
  std::string s;
  //...
  std::vector<char> SomeString(s.length() + 1, 0 );
  std::copy(s.begin(), s.end(), SomeString.begin());
  CryptEncrypt( &SomeString[0] );
}

---

Regards,

Paul McKenzie

paul


what's wrong with that code?

string sString = "Hello World";
char* pszStr = new char[sString .length() +1];
.
delete pszStr;

Quote:

---

Originally posted by avi123
paul


what's wrong with that code?

string sString = "Hello World";
char* pszStr = new char[sString .length() +1];
.
delete pszStr;

---

See the correction that I posted. You use new[], you deallocate with delete[], not delete.

Regards,

Paul McKenzie

Just a comment to Ralf´s proposal of working directly with c_str...

It will work, but take care that the other parameters of the string are not modified, so it can cause some problems...

For instance... You have a string of size 5 bytes...

You use c_str to add another byte... If you use the string, it continues thinking that the size is 5 and not 6.

paul

I guess that this is ok:


string sString = "Hello World";
char* pszStr = new char[sString .length() +1];
strcpy(pszStr,sString.c_str());
.
.
.
.
delete[] pszStr;
--------------------------------------------------------------------------------

Quote:

---

Originally posted by Caronte
For instance... You have a string of size 5 bytes...

You use c_str to add another byte... If you use the string, it continues thinking that the size is 5 and not 6.

---

Yes. That is why std::string.c_str() returns a const char* to indicate that we shouldn't modify the string.

That´s why I wouldn´t recommend to use the data inside an string that way.

Yes, avi, the second method (with the corrections suggested) is much better.

Hi avi;

If you already have STL string available then just create a second string - or vector as Paul suggests. Let STL take core of deleting the string for you instead of calling new[]/delete[].

Wondering: how does CryptEncrypt know the length of the string?

-rick