As I understand it, __argv returns a 'char**'. Based on that, it makes since that the below code works.
I would expect the below code to also work but it doesn't.Code:char** argv = __argv; //works
I was googling and found the below code. It works. I would very much appreciate and explanation of why this works. What does '(const char**)' do?Code:const char** argv = __argv; //fails
ThanksCode:const char** argv = (const char**) __argv; //works
Here's what I 've found in the Standard and it explains your problem:
The first assignment is unsafe because it would allow theCode:const char **cpp; char *p; const char c = 'A'; cpp = &p; // constraint violation *cpp = &c; // valid *p = 0; // valid
following valid code to attempt to change the value of the
const object c.
As you can see your program could inadvertently modify a const object.
That is why you're getting that error.
This construction is not familiar with me.As I understand it, __argv returns a 'char**'.
What is exactly __argv
is it form
int main(int argc char** argv)
or it is some global constant?
I must admit that __argv is strange to me.
Ah...that makes some sense. I knew that the following was illegal:After all, you wouldn't want a non-const pointer pointing to something that you'd already declared as const. The other way was just a little backwards, but still made sense once I'd looked at it:Code:const char **pConst = 0; char **pNotConst = pConst;The reason why (const char**) will work is because you are casting the pointer to say that it is const. However, I wouldn't use casts to get around const compiler errors. That could make for some bad bugs.Code:char **pNotConst = 0; const char **pConst = pNotConst;
If I did your homework for you, then you might pass your class without learning how to write a program like this. Then you might graduate and get your degree without learning how to write a program like this. You might become a professional programmer without knowing how to write a program like this. Someday you might work on a project with me without knowing how to write a program like this. Then I would have to do you serious bodily harm. - Jack Klein
Originally Posted by Micko
I wasn't familiar with it myself until I looked it up. It apparently is a char** that points to the command-line arguments. I tried it out with a sample program:
Note I did not specify the typical int main(int argc,char**argv) when one usually needs access to the command-line args. Running the sample program and specifying an additional argument of "1024" I got this as output:Code:#include <iostream> int main() { int indx = 0; std::cout << "The command-line arguments are as follows: " << std::endl; while( __argv[indx] ) { std::cout << "__argv[" << indx << "] is: " << __argv[indx] << std::endl; ++indx; } return 0; }
Seems you can use int main() and still access the command-line arguments. Cool, I learned something new today!Code:The command-line arguments are as follows: __argv[0] is: C:\MiscSrc\Test5\Release\Test5.exe __argv[1] is: 1024
Last edited by hk_mp5kpdw; 03-10-2005 at 10:19 AM.
"Owners of dogs will have noticed that, if you provide them with food and water and shelter and affection, they will think you are god. Whereas owners of cats are compelled to realize that, if you provide them with food and water and shelter and affection, they draw the conclusion that they are gods."
-Christopher Hitchens
And thanks to you, me too!
Sorry for the late reply and thanks for the responses.
Micko’s explanation clearly explained why the code didn’t work as I expected. I must admit it took a few minutes for me to rap my brain around it. The pointer to pointer thing really screws it up in my mind. I’m very new to C++. I hope I grasp things quicker in the near future.
Thanks so much. I have read about old-style casts but I dumped the info.The reason why (const char**) will work is because you are casting the pointer to say that it is const. However, I wouldn't use casts to get around const compiler errors. That could make for some bad bugs.
I learned about __argv when I was converting a console application to a Win32 application. By using ‘__argv’ you don’t have to parse ‘char* cmdLine’ passed by the WinMain function. Since the console application already handled ‘char** argv’ passed by the Main function, I found ‘__argv’ especially useful. I found out about ‘__argv’ when I saw it used in code. I couldn’t find any documentation about it. I think its Microsoft Visual C++ thing.What is exactly __argv
is it form
int main(int argc char** argv)
or it is some global constant?
I must admit that __argv is strange to me.
Well its not standard thats for sureWhat is exactly __argv
Yes, Thantos, you're right. It's not standard, that's for sure. It seems that __argv is available whenWell its not standard thats for sure
include iostream header. So it is defined somewhere but hard to find where. I tested it with Visual C++.net and Dev-C++ and it works, so it's not Microsoft specific only.
__argv is specific to the MS C runtime library - which Dev-C++ uses.
gg
Thanks for correcting me Codeplug!
