Re: standard namespace
* blargg:
Alf P. Steinbach wrote:
* blargg:
Alf P. Steinbach wrote:
[...]
I'd agree if the above were the reasoning, but the <c*> headers DO
reliably put those names IN namespace std, so that one can consistently
refer to standard names with std:: in one's own code.
Puzzling.
What advantage do you see in that?
* It's an advantage for you to write std::printf instead of just printf?
It's an advantage to be ABLE to write std::whatever when whatever is a
name from the standard library, rather than having to write
std::whatever for some names, and whatever for others.
Your "whatever" being no qualification or "::" qualification, which is less to
write, and less to read -- in short, less work and more clear. :-)
In most header
files, you don't want a using directive, so the consistency is a
benefit:
// foo.hpp
#include <vector>
#include <cmath>
// using namespace std; // NO, we don't want this in a header
class Foo {
std::vector<double> v;
public:
Foo();
double bar() const { return std::sqrt( v.front() ); }
void f();
// ...
};
Compare that to writing "::sqrt" wherever (seldom occurs) qualification is
necessary.
Perhaps "std::sqrt" could help an utter novice. Aha, dang!, that "sqrt" comes
from the "std" library, probably the standard library, and it's probably -- a
square root function, I think! But should such a novice maintain the C++ code?
And you cannot qualify all names from the standard library.
So there is no full consistency to maintain: even if that, for some obscure
reason, should be desirable, it is not possible.
And having dismissed those 2 silly cases, what on Earth is the advantage you see
in the more verbose code?
* It's an advantage for you to make the compiler unable to diagnose writing
just printf, or size_t, in code where that name isn't formally available?
I didn't say this, and above I explicitly agreed with your reasoning
that this aspect is bad. Don't act so puzzled.
* The coding guidelines require qualification of the names from the
standard library that *can* be qualified (conforming to a verbosity
requirement)?
Only in a header file where you don't want a using directive; in a
source file, you'd rather drop std:: entirely:
// foo.cpp
#include "foo.hpp"
#include <algorithm>
using namespace std;
Foo::Foo()
{
v.push_back( exp( 1 ) );
}
void Foo::f()
{
transform( v.begin(), v.end(), v.begin(), sqrt );
}
Again, this allows consistency.
(I really don't want to start skipping your posts again, but your
discussion style is very abrasive, the way you re-frame things to try
to make others look unreasonable. It had seemed like you changed
somewhat recently...)
Hm, I can't help others posting unreasonable stuff.
At least, I haven't yet figured out a way to stop them from doing so.
As an example, it's extremely rude of you to resort to an ad hominem attack like
above, and very few if any reading that will let it reflect negatively on the
person you attacked that way. :-)
Cheers & hth.,
- Alf
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!