A quick question
When I start Geany and choose New>C++ Source, it starts with a pre-defined basic code like this:
Code:#include<iostream> using namespace std; int main(int argc, char** argv) { return 0; }
What I've seen in books and tutorials is
What's the difference b/w the two formats?Code:int main(int argc, char* argv[])
There is no difference. A array decays to a pointer to its first element when passed as an argument. The only "difference" is that the C++ standard gives the latter, not the former, as the "canonical" example.
Look up a C++ Reference and learn How To Ask Questions The Smart WayOriginally Posted by Bjarne Stroustrup (2000-10-14)
Well, unfortunately, main is different from the rest. If you pass a 2D-array to a function, only a pointer is created. But to main, a pointer-to-pointer is passed, or pointer to an array, if you will.
Therefore, both are syntactically correct.
It's a dynamically allocated 2D array, and thus needs to be a pointer to pointer.
I do not think the global main function is different at all, in this case, but rather that argv is not a two dimensional array, but an array of pointers to the initial characters of null terminated strings, including a terminating null pointer.Well, unfortunately, main is different from the rest. If you pass a 2D-array to a function, only a pointer is created. But to main, a pointer-to-pointer is passed, or pointer to an array, if you will.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Which is exactly why I said it was different.
No, you stated that it was different because argv is a two dimensional array, yet a pointer to a pointer, not just a pointer, was created. This is false, since argv is not a two dimensional array to begin with.Which is exactly why I said it was different.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Delete the "using namespace std;" and only use it in more limited scopes, if at all.
That is not necessary.
That's preference. Mostly it's OK unless if working in large projects, where you might want to look out.
Yes, for toy programs it's not a big deal, but it's distrubing that an IDE would use such a practice when generating code. It teaches bad habits and there's enough of that going around.
The IDE does not generate such code to my knowledge.
Didn't the OP say that was the template program it created?
In this case, whether it is a bad habit or not is debatable. The author of that editor template could cite C++ Coding Standards item #59, where Sutter and Alexandrescu state that: "In implementation files after all #includes, you can and should write namespace using declarations and directives liberally. This is the right way to reconcile brevity with modularity."Yes, for toy programs it's not a big deal, but it's distrubing that an IDE would use such a practice when generating code. It teaches bad habits and there's enough of that going around.
That using directive in that editor template certainly comes in an implementation file after the lone #include.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
I was thinking of something else... Another program that did not.
The OP did say so... You were right, I had the wrong application in mind.
Yes, it's a toy program. It doesn't matter in this case. In larger programs, it can cause problems down the road. Cline, Lomow, and Girou discuss this in FAQ 15.07 of their "C++ FAQs" book:
"The using directive is less desirable than the using declaration because it pollutes the global namespace unnecessarily and opens the door for later code breakage. This is because compiler writers and class library providers can add names to the standard namespace, which means that programs that utilize 'using namespace std'; can suddenly fail to compile even though the user has not changed anything."
It's a bigger problem with 3rd party libs that usually change more often than the standard library.
By "in this case" I was referring to the placement of the using directive, not the fact this this is merely an editor template.Yes, it's a toy program. It doesn't matter in this case.
I agree, but I am also persuaded by Sutter and Alexandrescu's argument that "the vast majority of the time there is no ambiguity".In larger programs, it can cause problems down the road.
I think that they have a point, but this is mitigated by the fact that such names can be fully qualified on the off chance that a name collision occurs.This is because compiler writers and class library providers can add names to the standard namespace, which means that programs that utilize 'using namespace std'; can suddenly fail to compile even though the user has not changed anything.
Incidentally, Sutter and Alexandrescu argue that using declarations at namespace level are not necessarily better than using directives at namespace level. Their counterexample is:
EDIT:Code:// snippet 1 namespace A { int f(double); } // snippet 2 namespace B { using A::f; void g(); } // snippet 3 namespace A { int f(int); } // snippet 4 void B::g() { f(1); // which overload is called? }
This may be much ado about nothing: Geany 0.11's C++ source template does not come with a using directive.
Last edited by laserlight; 04-20-2008 at 10:11 AM.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
