assign arguments array to class property (array) defined in header file

Question

I'm new to C++ and want to achieve something extremely simple, but it will not let me. I've read a bunch of ways to "assign" or "link" or "copy" arrays, but NONE of these seem to work at all.

Consider the following:

in file: header.h:

using namespace std;

Class Proc
{
    public: static char args;
};

in file: main.cpp:

using namespace std;

#include <cstdlib>
#include <memory>
#include "header.h"

int main(int argc, char* argv[])
{
    Proc::args = argv;                // yea i know this won't work :(
    // Proc::args[argc] = argv;       // not working either
    // memcpy(argv, Proc::args, sizeof(argv));   // nope
    // copy(begin(argv), end(argv), begin(Proc.args));   // nope
}

In fact I don't really want to "copy" it at all, linking it is just fine, but the g++ compiler keeps throwing up in my face about undefined reference to 'Proc::args' and who knows what else.

I'm about to put a drill to my ear, can anyone please make an example?

It is different from undefined reference to'Proc::args'because I also get:error: invalid use of qualified-name 'Proc::args'and also that it complains aboutchar**&char*not being the same... - and when I add an asterisk to Proc'schar* args` then it throws some more.

Answer 1

If I understand correctly, you want to copy command-line arguments into some variable.

Here is one way to do that, that does the copy. It is also possible to save a pointer on original data, but it's usually no worth the effort.

struct Proc
{
   std::vector<std::string> args;
   Proc( int argc, char* argv[] )
   {
      for( size_t i=0; i<(size_t)argc; ++i )
         args.push_back( argv[i] );
   }
};

int main(int argc, char* argv[])
{
    Proc cla( argc, argv ); // saves cl args into variable
    for( const auto& c: cla.args ) // print out
      std::cout << c << "\n";
}

Live here

Side comment: I disagree with @Sri.U 's answer, usage of memcpy is not recommended with modern C++. Similarly, usage of raw arrays is also discouraged as the library provides safer containers (string and vector).

Answer 2

I think there are two problems in the sample code you have shown:-

1. Static should be initialized after declaration, outside of the class like -

char Proc::args = '\0';

int main(int argc, char* argv[]) 
{
  //Proc::args = argv; /* invalid conversion */

  return 0;
}

This will resolve your undefined reference problem.

2. You are doing invalid conversion from char** to char by doing Proc::args = argv; you can use static char **args instead.

Answer 3

You can have:

public: static char args[NUM_ARGS][STRING_LENGTH];

Then you can do memcpy for each of the arguments like this:

for (i=0; i < argc; i++) {
    memcpy (argv[i], args[i], sizeof(argv[i])):
}

The argument in main function argv is array of char pointers. So you have argc number of strings.

So instead of

public: static char args[NUM_ARGS][STRING_LENGTH];

you can also have array of pointers and allocate it in main like below:

public: static char *args[STRING_LENGTH];

Edit based on OPs comment: If you just want to assign it to args, then you need to have

public: static char **args;

Answer 4

Thanks so much to all for your input!

Using what you taught me I "frankensteined" the answers & comments together and came up with a working solution (below)

I hope this helps someone, and again thanks very much for all your effort. Please feel free to shorten the code, or make it more elegant.

in file: header.h:

using namespace std;

class Proc
{
    public: static char** args;

    public: static void init(char* args[])
    {
        Proc::args = args;
    };
};

char **Proc::args;   // important!

in file: main.cpp:

using namespace std;

#include <iostream>

int main(int argc, char* argv[])
{
    Proc::init(argv);
    cout << Proc::args[0];    // works !!
}