Which way is better ?

I was just wondering is

Code:

---

using namespace std;

---

A good idea or just program without it?

That's a question for debate, really. There is no right or wrong answer, but rather it is a "it depends".

My personal view is that it is fine to use "using namespace std" at the beginning of a C file. Or "using namespace X" for that matter.

--
Mats

if you know there aren't and won't be any name conflicts, go for it. if you aren't sure, don't take the risk. simple.

My opinion is to use it if you have to, otherwise save yourself the keystrokes.

It is generally bad form to put the std using directive in header files or above other header #includes. So except for simple programs I'd stay away from doing that.

As for using it in source files, that is up to you. I prefer not to do so but there are valid arguments on both sides.

Quote:

---

Originally Posted by Daved

It is generally bad form to put the std using directive in header files or above other header #includes. So except for simple programs I'd stay away from doing that.

---

Indeed & completely agreed - using directives (std or otherwise) should never[1] be found in header-files, because it "messes" with what happens in code that includes that header file beyond what you can expect.

[1] I would consider exceptions to this that you may for example implement some sort of replacement functions for some standard functions, and thus do something like:

Code:

---

// mydebug.h

using MyDebug::somefunc;
...

---

So if you include "mydebug.h" you get some debugging version of the standard function, otherwise you get the normal version. But that is a very special case.

--
Mats

I would encourage you to use 'using' directives.
I would even encourage you to use 'using namespace' directives.
I'll even tell you that you will eventually have to use a 'using' directive.

The problems come from putting such a directive in a header or at the top of source files from global scope. It is evil. If you have ambiguities, collisions, you must fully qualify the name. Any 'using' directive can cause these ambiguities. If you must fully qualify the name there is no point to namespaces. If it comes to that, you may as well just be using the C style 'long_name_prefix'.

I've always used the 'local' or '<anonymous>::local' "trick" to get just what I need to implement the source for a particular translation unit.

[Edit]

Quote:

---

using directives (std or otherwise) should never[1] be found in header-files

---

This is silly. Or maybe you just don't mean what you said. If the directive is enclosed in some private scope it shouldn't cause any problems.

If you are dealing with templates and you need a function symbol to resolve to non-standard overloads you have no choice.
[/Edit]

Soma

Code:

---

namespace
{
  namespace local
  {
      using foo1::bar1;
      using foo1::bar2;
      using foo2::bar3;
      using foo2::bar4;
      using namespace foox::barx;
  }
}

fully::qualified::type some::other::name()
{
  using namespace local;
  // ...
  bar1 b1;
  bar2 b2;
  bar3 b3;
  bar4 b4;
  // ...
  barx1 bx1;
  // ...
}

---

Quote:

---

Originally Posted by phantomotap

If you are dealing with templates and you need a function symbol to resolve to non-standard overloads you have no choice.

---

Would you care to elaborate on that? I've never seen any situation where you couldn't just fully qualify the name to get it working.

I'm pro-using directives too, but putting them before #include directives or in the global space of a header file is evil.

Quote:

---

Would you care to elaborate on that? I've never seen any situation where you couldn't just fully qualify the name to get it working.

---

Code:

---

namespace foo {
  class MyComplexObject { ... };
  inline void swap(MyComplexObject &l, MyComplexObject &r) { /* fast swap */ }
}

namespace bar {
  template <typename T>
  void MyTContainer<T>::swap_with_back(T& t) {
    std::swap(t, this->back()); // Oops, doesn't use the fast swap for MyComplexObject.
  }

  template <typename T>
  void MyTContainer<T>::swap_with_back(T& t) {
    using std::swap;
    swap(t, this->back()); // Ah, ADL finds and uses the fast swap.
  }
}

---

Of course, that doesn't justify putting them in the global namespace, but phantomatap didn't say that.

I personally prefer to only "using" the things I need.

Code:

---

using std::cin;
using std::cout;
using std::vector;
... etc

---

Less pollution, and no possibility of someone introducing something into the std namespace in a later standard and break my code.

Quote:

---

Originally Posted by phantomotap

I would encourage you to use 'using' directives.
I would even encourage you to use 'using namespace' directives.

---

You can just call the former using declarations and the latter using directives.

My preferred example of when a using declaration would be appropriate in a restricted scope in a header file would be to bring in names from a base class hidden by overloads in a derived class.

Quote:

---

Originally Posted by phantomotap

I would encourage you to use 'using' directives.
I would even encourage you to use 'using namespace' directives.
I'll even tell you that you will eventually have to use a 'using' directive.

The problems come from putting such a directive in a header or at the top of source files from global scope. It is evil. If you have ambiguities, collisions, you must fully qualify the name. Any 'using' directive can cause these ambiguities. If you must fully qualify the name there is no point to namespaces. If it comes to that, you may as well just be using the C style 'long_name_prefix'.

---

I am typically against using directives, since I like to use them as categories. If I put functions inside a namespace String, I won't have to prefix those functions "Str" or such.
So I have this:

Code:

---

namespace String
{
    std::string Cut(std::string&, std::string&);
}

---

And then do...

Code:

---

using namespace Strings;
Cut(...);

---

...instead of...

Code:

---

String::Cut(...);

---

Which is more readable?
It can get worse with other functions such as if you have functions named "Load" or similar.
But using isn't evil. Oh no. There is a time where it can be applied that gives more readability. I'm just saying one should be careful in doing so, and that fully expressing them isn't so bad as it sounds, and we're not back in the C era.

The thing with using namespaces as categories is that it wouldn't really avoid conflicts, would it? If your library puts math-related functions into a namespace called Math and my library does the same since that's the most logical thing to do in order to categorize things, there would still be naming conflicts?

On the other hand (top-level) namespaces like std or boost don't categorize things and just try to be library-specific...

But you can do both.

Code:

---

namespace MyLibrary { namespace Math { ... } }

---

So, if you wanted, you could do using namespace MyLibrary, but not namespace Math.
This is typically what I do.

Well, yes.

But since I don't really care that it is YourLibrary that I'm using (because the only math library I am using is yours, whereas I might care more that it is the math module of YourLibrary) why shouldn't I do this in source files?

Code:

---

namespace my_library
{
namespace math
{
    void sqrt() {}
}
}

using namespace my_library;

int main()
{
    math::sqrt();
}

---

That is fine. I am merely pointing out that you shouldn't blindly put using namespace statements for every namespace you encounter.
Especially phantomotap seemed to think that explicitly specifying namespaces was like the old C days when you had to spell it all out. Or at least it seemed that way.
I didn't agree, because I use namespaces for categorizing. And the using isn't evil; there are places where it helps, like in your example, and others where it does not.
Myself, if it is not too long, I do prefer to type it out explicitly.

Quote:

---

I'm just saying one [...] not back in the C era.

---

O_o

You are confusing "may" with "must".

If one "may" fully qualify names, for whatever reason, it isn't bad at all.

If one "must" fully qualify names, the namespaces are being used solely as a prefix. All the advantages of namespaces are lost. There is no difference between one prefix notation and the other. The source may only use ':' instead of '_'.

Which is more readable?

Code:

---

std__copy(std__istream_iterator<std__string>(std__cin), std__istream_iterator<std__string>(), std__ostream_iterator<std__string>(std__cout, " "));

---

Code:

---

// using directives
copy(istream_iterator<string>(cin), istream_iterator<string>(), ostream_iterator<string>(cout, " "));

---

Soma

Quote:

---

Originally Posted by whiteflags

Namespaces are there to resolve things when the same identifier has been used multiple times, and the above communicates to me that namespaces somehow lose their value when they fulfill their purpose.

---

I think you have made a strawman argument since phantomotap compared namespaces to name prefixes, and it is in that context that he stated that "all the advantages of namespaces are lost" (emphasis mine).

*shrug* I deleted my comment because it occurred to me that Soma was probably saying what I was saying, in so many words. That happens. I'd ignore him so that I don't bug him but he's actually smart, says great advice, and that's mean.

Quote:

---

Originally Posted by phantomotap

O_o

You are confusing "may" with "must".

If one "may" fully qualify names, for whatever reason, it isn't bad at all.

If one "must" fully qualify names, the namespaces are being used solely as a prefix. All the advantages of namespaces are lost. There is no difference between one prefix notation and the other. The source may only use ':' instead of '_'.

Which is more readable?

Code:

---

std__copy(std__istream_iterator<std__string>(std__cin), std__istream_iterator<std__string>(), std__ostream_iterator<std__string>(std__cout, " "));

---

Code:

---

// using directives
copy(istream_iterator<string>(cin), istream_iterator<string>(), ostream_iterator<string>(cout, " "));

---

Soma

---

Ah, yes. You are right. Still, I prefer

Code:

---

std::copy(std::istream_iterator<std::string>(std::cin), std::istream_iterator<std::string>(), std::ostream_iterator<std::string>(std::cout, " "));

---

Not only do they avoid collisions (which is pretty irrelevant in this example, but still), but I can see where they come from, and I do like to prefix this explicitly, unless too long.
Now, those are good arguments to ponder. When to use using namespace directories and when not to?

Quote:

---

I'd ignore him so that I don't bug

---

^_^

You shouldn't bother about that; everyone bugs me anyway.

Quote:

---

When to use using namespace directories and when not to?

---

Beyond rules that prevent pollution or allow overload resolution, this seems to fall under the realm of style.

Soma