>>> execv( argv[1], argv + sizeof( argv[1] ) );
>> Could you explain this? Why would this line be *more* correct than the
precedent?
> The second version makes the pointer arithmetic explicit and has the
> correct type for the second argument. The first involves an implicit
> cast from char* to char**.
Correct.
[snip]
> cast takes place from char* to char**. Now it so happens that argv[2]
> is the beginning of an array pointers which is just argv with the
> first two items in it cut off, which is the array of arguments I want
> the pass to execv. I could make the cast explicit, but gcc is happy
> to do it implicitly, so I let it.
gcc -Wall -ansi -pedantic rules :)
execv (argv[1], (char**) argv[2]);
> Moreover, argv + sizeof (argv[1]) is equal to argv[4] (as sizeof (char*) =
4) ...
> No. If that were so then you could not access the list of arguments
> to a main function as argv[0], argv[1], argv[2] etc. The compiler
> knows that the type of argv is char**, or char*[], an array of
> pointers to chars, and it knows that sizeof( char* ) is 4 (on the
> platforms we're talking about). It is almost an axiom that
> argv[1] == argv[0] + sizeof( argv[0] ), since this is the address of
> the next element in the array. So argv[4] = argv + 4*sizeof( argv[1]).
Wrong. We are talking about pointers, not about integers nor unsigned.
When you write
argv + 1, the compiler will understand : compute the address
of argv, and add one time the size of the type which is pointed by argv.
I remember to you that argv[1] = argv + 1. Brackets are only syntactic
sugar, which allows us not seeing we are dealing with pointer arithmetic.
Examples :
--
[EMAIL PROTECTED]:/tmp/test$ cat main.cc
#include <iostream>
int
main (int argc, char** argv)
{
std::cout << "argv = " << argv << std::endl
<< "sizeof (argv[1]) = " << sizeof (argv[1]) << std::endl
<< "content = " << *(argv + sizeof (argv[1])) << std::endl;
return 0;
}
[1]+ Done emacs main.cc
[EMAIL PROTECTED]:/tmp/test$ g++ -Wall -ansi -pedantic --static main.cc
[EMAIL PROTECTED]:/tmp/test$ ./a.out "first" "second" "third" "lost"
argv = 0xbffffd04
sizeof (argv[1]) = 4
content = lost
[EMAIL PROTECTED]:/tmp/test$
--
leslie% cat test2.cc
#include <iostream>
int
main (int argc, char** argv)
{
std::cout << "argv = " << argv << std::endl
<< "argv[1] = " << &(argv[1]) << std::endl
<< "argv + 1 = " << argv + 1 << std:: endl
<< "argv + sizeof (char*) = " << argv + sizeof (char*) <<
std::endl;
return 0;
}
leslie% g++ -Wall -ansi -pedantic test2.cc
leslie% ./a.out "one"
argv = 0xbffffbe4
argv[1] = 0xbffffbe8
argv + 1 = 0xbffffbe8
argv + sizeof (char*) = 0xbffffbf4
leslie%
--
That's why Nicos Gollan was perfectly right, if we were on a 64 bits
architecture,
we would have argv + sizeof (char*) = argv + 8 = argv[8]
Regards,
Perceval.
--
To UNSUBSCRIBE, email to [EMAIL PROTECTED]
with a subject of "unsubscribe". Trouble? Contact [EMAIL PROTECTED]
