A Good Way to Store C++ CLI Arguments? (W/O using libraries)

So, I'm writting a CLI application in C++ which will accept a bunch of arguments. The syntax is pretty typical, -tag arg1 arg2 -tag2 arg1 ...

Right now, I take the char** argv and parse them into an

std::map< std::string, std::list<**std::string** > > >

The key is the tag, and the list holds each token behind that tag but before the next one. I don't want to store my args as just std::strings; but I need to make it more interactive.

By interactive, I mean when a user types './myprog -help' a list of all available commands comes up with descriptions.

Currently, my class to facilitate开发者_JS百科 this is:

class Argument
{
public:
   Argument(std::string flag, std::string desc);
   std::string getFlag();
   std::string getDesc(); 
   std:;list<std::string> > getArgs();
   void setArgs(std::list<std::string> > args); 
   bool validSyntax()=0;
   std::string getSyntaxErrorDesc()=0; 
};

The std::map structure is in a class ProgramCommands which goes about handling the these Arguments.

Now that the problem description is over, my 4 questions are:

1. How do I give the rest of the program access to the data in ProgramCommands? I Don't want to make a singleton, at all; and I'd prefer to not have to pass ProgramCommands as an arg to almost every function in the program.
2. Do you have better ideas about storing how I'm doing this?
3. How best can I add arguments to the program, without hardcoding them into the ProgramCommands, or main?
4. std::string only allows for 1 line descriptions, does anyone have an elegant solution to this besides using a list of strings or boost?

EDIT I don't really want to use libraries because this is a school project (sniffing & interpreting packets). I could, if I wanted to, but I'd rather not.

Your choices on storing the command line arguments are either: Make them a global or pass them around to the functions that need them. Which way is best depends on the sorts of options you have.

If MANY places in your program need the options (for instance a 'verbose' option), then I'd just make the structure a global and get on with my life. It doesn't need to be a singleton (you'll still only have one of them, but that's OK).

If you only need the options at startup time (i.e. # of threads to start initially or port # to connect on), then you can keep the parsing local to 'main' and just pass the parameters needed to the appropriate functions.

I tend to just parse options with the venerable getopt library (yes, that's a leftover from C - and it works just fine) and I stuff the option info (flags, values) into a global structure or a series of global variables. I give usage instructions by having a function 'print_usage' that just prints out the basic usage info as a single block of text. I find it works, it's quick, it's simple, and it gets the job done.

I dont understand your objection to using a singleton to - this is the sort of thing they are made for. If you want them accessible to every object but not pass them as arguments or use a singlton - there are only a couple of tricks I can think of:

-put the parsed arguments them into shared memory and then read them from every function that needs them -write the parsed arguments out to a binary file and then read them from every function that needs them -global variables

None of these solutions are nearly as elegant as a singleton, are MUCH more labor intensive and are well... sort of silly compared to a singleton... why hamstring yourself?