在C++中最简单的方法是：

int main(int argc, char** argv)
{
    if(argc == 2 && strcmp(argv[1], "--help")==0)
    {..print help here..}
    return 0;
}

字符串

对于C++，您有Boost.Program_options
http://www.boost.org/doc/libs/1_55_0/doc/html/program_options.html
但是你必须带上整个boost库（第一次这样做可能会很乏味）。

沿着这方面...

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

    for(auto& arg : cmdLineArgs)
    {
        if(arg == "--help" || arg == "-help")
        {
            std::cout << "Helpful stuff here\n";
        }
        else if(arg == "whatever")
        {
            std::cout << "whatever?!\n";
        }
    }
}

字符串
当然，也有一些库可以处理cmd行参数。但是对于简单的事情，自己做真的不难。

getopt_long是你的朋友。对于单字符选项，getopt就足够了。

我想你应该看看这个图书馆：Getopt是GNU C库的一部分。它允许您高效地解析-like参数。

你可以用多种方法来做，这取决于你想怎么做。
你可以使用strcmp（）并解析argv[1]：

if(strcmp(argv[1],"--help") == 0)

字符串
或者如果你运行的是linux，你可以使用getopt：
http://www.gnu.org/software/libc/manual/html_node/Getopt.html

Argp自动生成“--help”选项的输出，除非指定不这样做。它是GNU库的一部分，它使您更容易保持帮助选项的更新。下面是一个示例程序及其输出：

#include <stdlib.h>
#include <argp.h>

const char *argp_program_version =
  "argp-ex3 1.0";
const char *argp_program_bug_address =
  "<bug-gnu-utils@gnu.org>";

/* Program documentation. */
static char doc[] =
  "Argp example #3 -- a program with options and arguments using argp";

/* A description of the arguments we accept. */
static char args_doc[] = "ARG1 ARG2";

/* The options we understand. */
static struct argp_option options[] = {
  {"verbose",  'v', 0,      0,  "Produce verbose output" },
  {"quiet",    'q', 0,      0,  "Don't produce any output" },
  {"silent",   's', 0,      OPTION_ALIAS },
  {"output",   'o', "FILE", 0,
   "Output to FILE instead of standard output" },
  { 0 }
};

/* Used by main to communicate with parse_opt. */
struct arguments
{
  char *args[2];                /* arg1 & arg2 */
  int silent, verbose;
  char *output_file;
};

/* Parse a single option. */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
  /* Get the input argument from argp_parse, which we
     know is a pointer to our arguments structure. */
  struct arguments *arguments = state->input;

  switch (key)
    {
    case 'q': case 's':
      arguments->silent = 1;
      break;
    case 'v':
      arguments->verbose = 1;
      break;
    case 'o':
      arguments->output_file = arg;
      break;

    case ARGP_KEY_ARG:
      if (state->arg_num >= 2)
        /* Too many arguments. */
        argp_usage (state);

      arguments->args[state->arg_num] = arg;

      break;

    case ARGP_KEY_END:
      if (state->arg_num < 2)
        /* Not enough arguments. */
        argp_usage (state);
      break;

    default:
      return ARGP_ERR_UNKNOWN;
    }
  return 0;
}

/* Our argp parser. */
static struct argp argp = { options, parse_opt, args_doc, doc };

int
main (int argc, char **argv)
{
  struct arguments arguments;

  /* Default values. */
  arguments.silent = 0;
  arguments.verbose = 0;
  arguments.output_file = "-";

  /* Parse our arguments; every option seen by parse_opt will
     be reflected in arguments. */
  argp_parse (&argp, argc, argv, 0, 0, &arguments);

  printf ("ARG1 = %s\nARG2 = %s\nOUTPUT_FILE = %s\n"
          "VERBOSE = %s\nSILENT = %s\n",
          arguments.args[0], arguments.args[1],
          arguments.output_file,
          arguments.verbose ? "yes" : "no",
          arguments.silent ? "yes" : "no");

  exit (0);
}

个字符