vector<string> to char*[]

[Andrew Wingorodov]

i have std::vector<stringarg; for dynamic program configuration.
i need get const char* argv[]; for execv(3).

how i can make its simple?
there may be ready solutions?

--
www.andr.ca

[Joel Yliluoma]

On Tue, 2 Oct 2007 06:09:22 +0000 (UTC), Andrew Wingorodov wrote:

i have std::vector<stringarg; for dynamic program configuration.
i need get const char* argv[]; for execv(3).

how i can make its simple?
there may be ready solutions?

I assume you are talking about some POSIX system (indicated by execv).
Since execv replaces the current running program with the executed
one, worries of memory leaks do not apply (except when an error happens).
So you can do this:

const char** argv = new const char*[ arg.size() ];
for(size_t a=0; a<arg.size(); ++a) argv[a] = arg[a].c_str();
execv(... argv ...);
// cleanup when error happened
delete[] argv;

--
Joel Yliluoma - http://bisqwit.iki.fi/
: comprehension = 1 / (2 ^ precision)

[Andrew Wingorodov]

Joel Yliluoma <bi*****@iki.fiwrote:

const char** argv = new const char*[ arg.size() ];
for(size_t a=0; a<arg.size(); ++a) argv[a] = arg[a].c_str();
execv(... argv ...);
// cleanup when error happened
delete[] argv;

i do correct?

//
const char**
args::constchar (const std::vector<std::string>& arg_)
{
static std::auto_ptr<const char*v;
v = (std::auto_ptr<const char*>) new const char* [arg_.size()+1];

std::vector<std::string>::const_iterator i = arg_.begin();
size_t j;

for (; i != arg_.end (); ++i)
{
v.get()[j++] = (*i).c_str() ;
}

v.get()[j] = NULL;
return v.get();
}

--
www.andr.ca

[Andrew Wingorodov]

Alf P. Steinbach <al***@start.nowrote:

auto_ptr calls delete, whereas you need delete[]. Not that it matters
much in practice for a char array. But formally UB.

When the function returns, the auto_ptr calls delete. As mentioned

Try what I posted earlier, it's safe:

i got it, 10x
but i'm afraid that the vector isn't equiv to the array of poiter to chars

may be this is a better way?

//--code--

class constchar
{
private:
const char** v;

public:
constchar (const std::vector<std::string>& arg_);

inline virtual ~constchar () { delete [] v; }

inline operator const char** () const { return v; }

}; //!class constchar

//
constchar::constchar (const std::vector<std::string>& arg_)
{
v = new const char* [arg_.size()+1];
std::vector<std::string>::const_iterator i = arg_.begin();
size_t j;

for (j^=j; i != arg_.end (); ++i)
{
v[j++] = (*i).c_str() ;
}

v[j] = NULL;
}

int
main ()
//////.......

vector<stringargv;
vector<stringenvp;
....
::execve (..., constchar (argv), constchar (envp));
::spawnve (..., constchar (argv), constchar (envp));

//--code--

--
www.andr.ca

[Chris ( Val )]

On Oct 2, 4:33 pm, "Alf P. Steinbach" <[e-mail]:

* Andrew Wingorodov:

i have std::vector<stringarg; for dynamic program configuration.
i need get const char* argv[]; for execv(3).

how i can make its simple?
there may be ready solutions?

std::vector<stringarg;
...

std::vector<char const*v( arg.size() );
for( size_t i = 0; i < v.size(); ++i ) { v[i] = arg[i].c_str(); }
blahblah( &v[0] );

Whay go through all that when he already has what he wants
in his original vector?

const char* tmp = arg.at( n ).c_str();

Cheers,
Chris Val

[Andrew Wingorodov]

Alf P. Steinbach <al***@start.nowrote:

>
Why not write just j=0 (far more readable), and why not declare j right
there, in the innermost scope it can be declared?

And why keep incrementing both an index and and an interator?

the best is the enemy of the rest (c) ;-)
my code are works, thanks for all advise

--
www.andr.ca

[Chris ( Val )]

On Oct 3, 12:52 am, "Alf P. Steinbach" <[e-mail]:

* Chris ( Val ):

On Oct 2, 4:33 pm, "Alf P. Steinbach" <[e-mail]:

* Andrew Wingorodov:

>i have std::vector<stringarg; for dynamic program configuration.
i need get const char* argv[]; for execv(3).
how i can make its simple?
there may be ready solutions?
std::vector<stringarg;
...

std::vector<char const*v( arg.size() );
for( size_t i = 0; i < v.size(); ++i ) { v[i] = arg[i].c_str(); }
blahblah( &v[0] );

Whay go through all that when he already has what he wants
in his original vector?

const char* tmp = arg.at( n ).c_str();

Andrew wants an array of pointers to C-strings, for use as execv
argument (later down the thread I checked execv's signature and found
that there's also a const issue, and that the array should be
null-terminated, but those are just technicalities).

I see.

What you have is one pointer to a C-string.

Yes.

I thought that would be sufficient for the OP's needs,
and didn't see the necessity of an additional vector :-)

--
Chris Val