如何使用memcpy将指针复制到数组的元素

Question

After executing this code:

char **argv_p;
char *argv[20] = { NULL };

memcpy(&argv_p, &argv, sizeof(argv_p));

argv_p ends up being NULL.

This is because &argv is decomposing into a pointer to the first pointer in the argv array. Using &argv[0] yields identical results (as expected).

Question is, whether there's syntax in C that would allow a char *** to be passed to memcpy, without resorting to something hacky like

char **argv_p;
char *argv[20] = { NULL }, **argv_start = argv;

memcpy(&argv_p, &argv_start, sizeof(argv_p));

Which I have tested and produces the correct result.

Edit: I know you can do straight assignment, but this is for working around const issues. Bonus internet points if anyone knows why execve takes a char * const * instead of a char const ** as its second argument.

Edit Edit: To clarify, the difference between the consts:

char * const * - makes the contents of the array immutable char const ** - makes the contents of the string buffers pointed to by the array immutable.

Const always constifies the thing to the left, unless it appears first (the ANSI C guys need shooting for that) in which case it constifies the thing on the right. Although many people write const char * , it's considered best practice by some, to write char const * because then application of the const is consistent.

You can't cast away a const without receiving a warning from the C compiler. memcpy is the only way to work around this without warnings.

Many older libraries don't correctly mark arguments to their functions as const, and if you have applied const correctly to types in your code, the compiler will emit warnings. That is why using memcpy is occasionally acceptable.

Answer 1

Do not try to work around const by copying a pointer.

Instead it may be necessary to copy the data the pointer points to, and then you can point to the non-const data with a non-const pointer and all will be well with the compiler and optimizer.

Aliasing a pointer to avoid qualifiers is never really acceptable, no matter how it is done, ie copying a pointer to a variable with different qualifiers is even not good practice, and in some cases may even cause runtime errors or other undefined behaviour (eg in the case where a const qualifier causes the referenced storage to be read-only, and the alias is (ab)used to try to actually modify the storage).

Where possible qualifiers should be removed "upstream" to avoid causing unnecessary clashes with system libraries that may not accept parameters with qualifiers (C of course does not always allow for this possibility).

Where absolutely necessary, and where it can be shown to not cause problems, it is acceptable to use an __UNCONST() macro. If the compiler for the target platform does not offer one then the best solution is to define __UNCONST() as a no-op and to document the potential warning that may result as acceptable (and show why).

Answer 2

In execve, argv can be declared as char *const argv[] and reading this backwards it is an array of constant strings, but the array is mutable and can be changed to include different constant strings. In old-fashioned Unix systems, the C main function could take 3 arguments, the third argument is the environment array just like execve. In main(), if you modified argv properly (eg, setting elements to "" until you run into the terminating NULL) you could prevent the ps command from displaying the command line parameters that had been passed to your program. By setting argv[0]="foo" , the command would show up as if "foo" were the name of the executable. For example, if your command took a password as a command line parameter, it would be prudent to hide it from ps or maybe /proc/PID/cmdline on newfangled Linux systems. See http://netsplit.com/hiding-arguments-from-ps for how to do the equivalent thing in a newfangled Linux system.