Thread: Thoughts about using namespace std?

It will tell you that the object is from the standard library. But since it is standard it kind of loses its usefullness.

You are forgetting a namespace is a non-trivial matter and that it has scope implications. That is, this is not only a matter of preference. It needs to be weighted with the consequences. EDIT: and master5001 just named one example.

But even still, I can assume that whatever has no :: is standard.

You can't actually, because any name you define yourself outside of a namespace is not "standard". Consequently, when reading code the original programmer is making no distinction between his own names and those of the std.

What will the std:: help you?

Me the reader? Little probably. Depends on my knowledge of the language and how easily I can identify standard names at a glance and how much information I can retain while reading the code. Me the coder? Depends on several factors, but for the most part I can conceded to the fact it won't have any practical benefit in the short term.

Question is if that is a reason to not write it. I tried to reason why it should be written on most circumstances. There's others I didn't find the need to repeat -- like Daved's call for consistency which is equally important.

However the strong point I try to make on that post is that we tend to look at readability as only a matter of form. It isn't. For me, the presence of std:: doesn't make the code less readable. It in fact makes it more readable. So there is also the issue as to exactly how many find std:: invasive.

Code readability on the other hand is much more about expressiveness, and while you can still make a case of std::, it will be a weaker one.

I gather you didn't actually read the thread or it's a matter of readability. Either:

a) we didn't make very readable posts, or
b) you didn't make an effort to understand what is being said

I put my money on b.

Hungarian is fine, in my opinion. I know the reasons people give for not liking it... and I'm not sure if they have enough bite to really make it an issue. Any naming convention is good, as far as I'm concerned. Be it in how you name variables or how you call functions I think consistency is good. With using namespaces ... I don't do it. I always feel better knowing exactly from where something is being called, function names, objects etc can't always be unique. Sometimes it's nearly obvious. But with programs interfacing to many libraries, namespaces for many different uses... it could be messy, but I prefer clarity. Anon's example above shows how messy it can be, but with a quick glance what type is the 'twomers_or_std' variable? Without referring to the top.

Code:

namespace twomers {
  template<typename _Ty,typename _Ax = allocator<_Ty> >
  class vector{};
}

using namespace std;
using namespace twomers;


int main( void ) {
  vector<int> twomers_or_std; // ?

  // No confusion
  twomers::vector<int> twomers_vector;
  std::vector<int> std_vector;

  return 0;
}

Originally Posted by twomers

but at a quick glange what type is the 'twomers_or_std' variable? Without referring to the top.

At a quick glance, the program would not compile even if the ambiguous statement was removed

But what your example shows is that having two using directives in the same scope can make things confusing. It does not show that using directives necessarily introduce confusion, and even then confusion can always be avoided by explicitly qualifying names in conflict, or by switching to using declarations.

>> At a quick glance, the program would not compile even if the ambiguous statement was removed
It compiles fine on MSVC '03. I don't think it matters that my simple test case isn't an exact replica of the problem at hand, but it shows that using them globally can.

>> But what your example shows is that having two using directives in the same scope can make things confusing.
So take out the twomers namespace and make a class called vector and retain using namespace std.

Code:

template<typename _Ty,typename _Ax = allocator<_Ty> >
  class vector{};

using namespace std;

int main( void ) {
  vector<int> local_or_std; // ?

  return 0;
}

Same problem. Which vector is it?

Edit: I'm not saying this is a good example or anything. It's a lousy one, in my opinion. But it does highlight potential issues with the problem, especially if you're attempting to do something 'standard' with a good name and are in the habit of using namespaces. Just showing potential for confusion.

Originally Posted by twomers

It compiles fine on MSVC '03. I don't think it matters that my simple test case isn't an exact replica of the problem at hand, but it shows that using them globally can.

I just found it surprising that you used allocator without fully qualifying it, despite claiming that "With using namespaces ... I don't do it." Of course, there is also the missing header inclusion, but that's forgivable.

Originally Posted by twomers

So take out the twomers namespace and make a class called vector and retain using namespace std.

You still have two using directives in the same scope, except that one is implicit since it concerns the global namespace.

EDIT:

Originally Posted by twomers

Edit: I'm not saying this is a good example or anything. It's a lousy one, in my opinion. But it does highlight potential issues with the problem, especially if you're attempting to do something 'standard' with a good name and are in the habit of using namespaces. Just showing potential for confusion.

I agree, though I think that by "using namespaces" you actually mean "using using directives or using declarations"

My opinion is that if the using directive is within some restricted scope, there would generally be less of a problem since the fact that there is a using directive at work would be more obvious to the reader. On the other hand, I find that the opportunity to use using directives and using declarations is not that common, since I only use them when necessary, or to make a piece of code that uses the namespace name far too often more readable.