convert argv to something and back

Hi Iain,

The simplest is to keep your args in a permanent std::vector<std::string>, can be a static member of a class or a global variable as:

std::vector<std::string> _arguments;

int main(int argc, char * argv[])
{
    _arguments = std::vector<std::string>(argv, argv + argc);
    // ...

Added after Emilio's comment:

Indeed it starts to migrate your code from C to C++, next step will rewrite your foo() function to accept a std::vector<std::string>&

In between, as Emilio's comment points, you would need an adaptor to use your existing foo(), for instance using (VC2010 or gcc 4.5) C++0x lambdas:

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>

std::vector<std::string> _arguments;

void foo(int argc, char* argv[])
{
    std::copy_n(argv, argc, std::ostream_iterator<char*>(std::cout, " "));
    std::cout << std::endl;
}

void CallFoo(std::vector<std::string>& args)
{
    std::vector<const char *> argv(args.size());
    std::transform(args.begin(), args.end(), argv.begin(), [](std::string& str){
        return str.c_str();});
    foo(argv.size(), const_cast<char**>(argv.data()));
}

int main(int argc, char * argv[])
{
    _arguments = std::vector<std::string>(argv, argv + argc);
    CallFoo(_arguments);
    return 0;
}

cheers,
AR

What about (please note error checking left to the reader):

class Args
{
  int _argc;
  char ** _argv;
public:
  Args(int argc, char * argv[])
  {
    _argc = argc;
    if (_argc > 0)
    {
      _argv = new char *[argc];
    }
    for (int n = 0; n < argc; n++)
    {
      _argv[n] = new char[strlen(argv[n])+1];
      strcpy(_argv[n], argv[n]);
    }
  }
  ~Args()
  {
    if (_argc > 0)
    {
      for (int n = 0; n < _argc; n++)
        delete [] _argv[n];
      delete [] _argv;
    }
  }
  int get_argc(){ return _argc;}
  char ** get_argv(){ return _argv;}
};

This is one of the case C++ STL is not a good help: using std::string literally means to copy the argv constant C strings on the process stack into the (dynamically allocated) memory of the std::string variables (may be even placed into a dynamically allocated memory of a vector).

What you need is store the int and char** coming from main into two globals and make those globals available to your foo function upon calling.
The function itself expects an array of C strings, (that has a precise memory layout). passing a C++ string vector completely mess-up such layout.

If yopu don't want two globals around, group them into a struct or make a class that let you able to access its members, store it globally (or store it locally to main and store a global pointer to it you initialize during main)

There is also no need to the "copy" and "delete" boililerplate proposed by CPallini: argc and argv (and the related char arrays)will exist for all the life of your program (they sits in the stack just under it). You don't need to create new copies nor to delete them.