a pointer about *argv[]

Question

This is my main.c

......
int main(int argc, char **argv)
{
    init_arg(&argc, &argv);
    ......
}

This is my init_arg.c

......
void init_arg(int *argc, char ***argv)
{
    printf("%s\n", *argv[1]);
    ......
}

I compiler it with no error and warning.

I run it:

./a.out include

It get Segmentation fault

When I debug it， I found step printf("%s\n", *argv[1]);

get wrong, It show:

print *argv[1]

Cannot access memory at address 0x300402bfd

I want to know, How to print argv[1] in init_arg() function.

In GDB when your code crashes run the command bt to see the stack trace leading up to your crash. Read crasseux.com/books/ctutorial/argc-and-argv.html for example C program code that handles program arguments. — Rob Kielty
– Rob Kielty, Commented Apr 29, 2012 at 1:18

Sergey Kalinichenko · Accepted Answer · 2012-04-29 01:18:52Z

19

You need to add a pair of parentheses around (*argv) to change the order of evaluation. The way you currently have it, the [1] is evaluated first, yielding an invalid pointer, which then gets dereferenced, causing undefined behavior.

printf("%s\n", (*argv)[1]);

edited Apr 29, 2012 at 1:18

answered Apr 29, 2012 at 1:13

Sergey Kalinichenko

729k85 gold badges1.2k silver badges1.6k bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

torek Over a year ago

Or, equivalently, you can use argv[0][1] (just as long to type, but perhaps slightly more readable).

Sergey Kalinichenko Over a year ago

@torek I would refrain from using argv[0] in place of (*argv), because what's passed in is a "scalar" pointer (i.e a pointer to a single array), rather than an array of pointers to arrays. I think that the (*argv) syntax underscores the notion that we're looking at a pointer to a scalar.

torek Over a year ago

apparently you fall into the group of people who like to maintain a distinction that C drops. I sympathize! In the early 1980s, I had a colleague who liked to mix pointer and array notation all the time depending on what was convenient. In particular he'd do things like: time_t now[1]; time(now); ... instead of time_t now; time(&now); .... :-)

Sergey Kalinichenko Over a year ago

"[...] maintain a distinction that C drops" That's a common misconception driven primarily by arrays decaying into pointers when passed into functions. The example that you show is a good and perfectly legitimate one: there is a big difference between treating an array of one item as a pointer and treating a pointer as an array of one item.

torek Over a year ago

My point is that the C language does not provide any way (in the callee, e.g., function fn) to discover whether some pointer argument T *p points to a single item (T var; fn(&var);) or to the first of N sequential items (T var[N]; fn(var);). It helps programmers to distinguish them, but the language itself does not do that for you. Compare with, e.g., Pascal and Go, which do.

|

alf · Accepted Answer · 2012-04-29 01:22:05Z

13

Argv is already a pointer. Just pass it like this:

init_arg(&argc, argv);

And init_arg should look like this:

void init_arg(int *argc, char **argv) {
    printf("%s\n", argv[1]);
}

answered Apr 29, 2012 at 1:22

alf

6811 gold badge8 silver badges19 bronze badges

2 Comments

torek Over a year ago

This answer is correct, but then he could also just pass argc rather than &argc. Presumably the point to passing both &argc and &argv is to allow init_arg to modify them.

alf Over a year ago

You can modify them both like this.

torek · Accepted Answer · 2012-04-29 02:25:57Z

2

I'm assuming that the reason for passing &argc and &argv in the first place is so that you can update them inside init_arg. Here's how I prefer to write such functions, in general:

/*
 * init_arg: do something useful with argc and argv, and update argc and argv
 * before returning so that the caller can do something else useful that's
 * not shared with all the other callers of init_arg().
 * (this comment of course needs updating to describe the useful things)
 */
void init_arg(int *argc0, char ***argv0) {
    int argc = *argc0;
    char **argv = *argv0;
    ... all the operative code goes here, and then ...
    *argc0 = argc;
    *argv0 = argv;
}

Of course this means you must not do early returns inside init_arg, so there are some tradeoffs, but it sure is a lot easier to work with the same regular old argc and argv inside init_arg.

answered Apr 29, 2012 at 2:25

torek

499k71 gold badges763 silver badges888 bronze badges

1 Comment

hugomg Over a year ago

Just use a goto if you miss the early return :)

Collectives™ on Stack Overflow

a pointer about *argv[]

3 Answers 3

7 Comments

2 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

7 Comments

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related