当前位置: 动力学知识库 > 问答 > 编程问答 >

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

问题描述:

I am trying to study the examples of GNU C Library Code,to be specific, the usage of Argp and try it, but when I try

Argp-Example-3

Gcc hints me there is an error, but I do just copy the code from the web site. Here's the message?

 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 is the file name.

It seems that I am converting 'void' to 'arguments'??

Thank you!

Heres the souce code

 /* 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 =

"<[email protected]>";

/* 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);

}

网友答案:

You should use a lowercase "c" for c files, i.e. argex.c, not argex.C. The uppercase C indicates a c++ file, and the implicit void* to anything conversion doesn't work in c++.

You could also add -x c to the command line (before the file name), but you really should use the correct extension.

网友答案:

I am using the wrong file name. I should use ".c" but I missed using ".C".

分享给朋友:
您可能感兴趣的文章:
随机阅读: