Conversion from std::string to char *, is there a better way?

[Julie]

I'm re-evaluating the way that I convert from a std::string to char *.
(Requirement: the source is a std::string, the usable contents are char *)

Here is what I've come up with:

#include <string>
#include <vector>
#include <cstring>

// presume s from somewhere, such as:
std::string s = "<initial value>";

std::vector<cha r> v(s.length() + 1);
std::strcpy(&v[0], s.c_str());
char * c = &v[0];
// use c, where a char * is _specifically_ required
s = c;

The above:
- doesn't use any pointers that must be manually deallocated
- is 100% portable(?)
- is 100% conformant(?)

I've seen Bjarne's similar implementation, but it uses new char * instead of
vector (obviously written before the STL was adopted).

auto_ptr<char> in place of vector<char> doesn't work because it doesn't handle
arrays.

Does anyone have comments on the above, specifically as to its suitability for
the requirements defined?

[Julie]

Julie wrote:

I'm re-evaluating the way that I convert from a std::string to char *.
(Requirement: the source is a std::string, the usable contents are char *)

Here is what I've come up with:

#include <string>
#include <vector>
#include <cstring>

// presume s from somewhere, such as:
std::string s = "<initial value>";

std::vector<cha r> v(s.length() + 1);
std::strcpy(&v[0], s.c_str());
char * c = &v[0];
// use c, where a char * is _specifically_ required
s = c;

So then, under the presumption that this is about as 'clean' as it can get,
does anyone have a comment on why a method for direct access wasn't provided in
the std::string implementation? I'd have presumed that something like that
would have been requisite to be more compatible w/ C and C-style strings and
interfaces.

Something like:

class string
{
private:
char * _accessbuf; // NULL initialized in constructor
public:

char * string::access( const size_t num_chars)
{
delete [] _accessbuf;
_accessbuf = new char[num_chars+1];
copy(_accessbuf , num_chars, 0);
_accessbuf[num_chars] = '\0';
return _accessbuf;
}

void string::commit( const bool commit=true)
{
if (_accessbuf)
{
if (commit)
{
*this = _accessbuf;
}
delete [] _accessbuf;
_accessbuf = NULL;
}
}
// etc.
};

Then, accessing C-style interfaces would resolve to:

GetFileName(str .access(_MAX_PA TH), _MAX_PATH);
str.commit();

instead of the cumbersome method in my original post.

Comments?

(Note: the names access and commit are completely arbitrary, more appropriate
names probably exist.)

[Chris Gordon-Smith]

Julie wrote:

Julie wrote:

I'm re-evaluating the way that I convert from a std::string to char *.

Maybe I misunderstood your post, by I find string::c_str() works well for
me.

--
Chris Gordon-Smith
London
Homepage: http://graffiti.virgin.net/c.gordon-smith/
Email Address: Please see my Home Page

[Julie]

Chris Gordon-Smith wrote:

Julie wrote:

Julie wrote:

I'm re-evaluating the way that I convert from a std::string to char *.

Maybe I misunderstood your post, by I find string::c_str() works well for
me.

c_str() returns a const pointer, so you can't directly modify the contents.

My proposal is for something that would encapsulate my original code into two
methods that would return a non-const pointer so that the contents can be
directly modified.

[Owen Jacobson]

On Sat, 26 Jun 2004 09:25:59 -0700, Julie wrote:

Chris Gordon-Smith wrote:

Julie wrote:

Julie wrote:

I'm re-evaluating the way that I convert from a std::string to char *.

Maybe I misunderstood your post, by I find string::c_str() works well for
me.

c_str() returns a const pointer, so you can't directly modify the contents.

My proposal is for something that would encapsulate my original code into two
methods that would return a non-const pointer so that the contents can be
directly modified.

Why, exactly, do you want to do this?

--
Some say the Wired doesn't have political borders like the real world,
but there are far too many nonsense-spouting anarchists or idiots who
think that pranks are a revolution.

[Julie]

Owen Jacobson wrote:

On Sat, 26 Jun 2004 09:25:59 -0700, Julie wrote:

Chris Gordon-Smith wrote:

Julie wrote:
Julie wrote:
>
> I'm re-evaluating the way that I convert from a std::string to char *.

Maybe I misunderstood your post, by I find string::c_str() works well for
me.
c_str() returns a const pointer, so you can't directly modify the contents.

My proposal is for something that would encapsulate my original code into two
methods that would return a non-const pointer so that the contents can be
directly modified.

Why, exactly, do you want to do this?

From my previous post:
... to be more compatible w/ C and C-style strings and interfaces.