c - 错误 : invalid conversion from ‘void*’ to ‘arguments*’ [-fpermissive]

Question

我正在尝试研究 GNU C 库代码的示例，具体来说，Argp 的用法并尝试它，但是当我尝试 Argp-Example-3

Gcc 提示我有错误，但我只是从网站上复制代码。这是消息？

 argex.C: In function ‘error_t parse_opt(int, char*, argp_state*)’:
 argex.C:92:45: error: invalid conversion from ‘void*’ to ‘arguments*’ [-fpermissive]
    struct arguments *arguments = state->input;
                                         ^
  argex.C: In function ‘int main(int, char**)’:
  argex.C:138:30: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    arguments.output_file = "-";
                          ^

argex.C 为文件名。

看来我正在将“void”转换为“arguments”？？

谢谢!

这是源代码

  /* This program uses the same features as example 2, and uses options and
    arguments.

    We now use the first four fields in ARGP, so here's a description of them:
      OPTIONS  -- A pointer to a vector of struct argp_option (see below)
      PARSER   -- A function to parse a single option, called by argp
      ARGS_DOC -- A string describing how the non-option arguments should look
      DOC      -- A descriptive string about this program; if it contains a
                  vertical tab character (\v), the part after it will be
                  printed *following* the options

    The function PARSER takes the following arguments:
      KEY  -- An integer specifying which option this is (taken
              from the KEY field in each struct argp_option), or
              a special key specifying something else; the only
              special keys we use here are ARGP_KEY_ARG, meaning
              a non-option argument, and ARGP_KEY_END, meaning
              that all arguments have been parsed
      ARG  -- For an option KEY, the string value of its
              argument, or NULL if it has none
      STATE-- A pointer to a struct argp_state, containing
              various useful information about the parsing state; used here
              are the INPUT field, which reflects the INPUT argument to
              argp_parse, and the ARG_NUM field, which is the number of the
              current non-option argument being parsed
    It should return either 0, meaning success, ARGP_ERR_UNKNOWN, meaning the
    given KEY wasn't recognized, or an errno value indicating some other
    error.

    Note that in this example, main uses a structure to communicate with the
    parse_opt function, a pointer to which it passes in the INPUT argument to
    argp_parse.  Of course, it's also possible to use global variables
    instead, but this is somewhat more flexible.

    The OPTIONS field contains a pointer to a vector of struct argp_option's;
    that structure has the following fields (if you assign your option
    structures using array initialization like this example, unspecified
    fields will be defaulted to 0, and need not be specified):
      NAME   -- The name of this option's long option (may be zero)
      KEY    -- The KEY to pass to the PARSER function when parsing this option,
                *and* the name of this option's short option, if it is a
                printable ascii character
      ARG    -- The name of this option's argument, if any
      FLAGS  -- Flags describing this option; some of them are:
                  OPTION_ARG_OPTIONAL -- The argument to this option is optional
                  OPTION_ALIAS        -- This option is an alias for the
                                         previous option
                  OPTION_HIDDEN       -- Don't show this option in --help output
      DOC    -- A documentation string for this option, shown in --help output

    An options vector should be terminated by an option with all fields zero. */

 #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);
 }

Answer 1

对于 c 文件，您应该使用小写的“c”，即 argex.c，而不是 argex.C。大写 C 表示一个 c++ 文件，隐式 void* 到任何转换在 c++ 中不起作用。

您也可以将 -x c 添加到命令行(在文件名之前)，但您确实应该使用正确的扩展名。