Why shouldn't "using namespace std" be used?

Is there any specific reason why "using namespace std" must not be used?

Does it cause interference with other functions for example? I only know that std is used for cout, cin and endl. So using namespace std must only affect these functions right? (Also what else needs to be specified as std::?)

-> I'm asking because if I were to convert code from Quincy (a much older compiler that doesn't have namespace), I would have to change each and every cout which could be tedious.

So if it has no short-term disadvantages then I would not bother editing the code from Quincy to suit Visual C++ I would instead just write "using namespace std;"

Cheers. ;)

Using "using namespace std" in a header file will result in weird and hard to find problems in code that people will curse you for in the future.

If it is a .cpp file I would just add the "using namespace std".

Tim S.

You can also usually place all your code within an anonymous namespace inside of a header file and then declare "using namespace std" from there. That way you can write your header code without namespace resolution without affecting the users of your library.

Quote:

---

Originally Posted by Sir Galahad

You can also usually place all your code within an anonymous namespace inside of a header file and then declare "using namespace std" from there.

---

I don't think that's wise: the unnamed namespace makes any names declared within it have internal linkage, but typically in header files you intend the names declared to have external linkage. What could be done is to use the using directive in a local scope, typically in the scope of an inline function defined in the header. Another possibility is to have the using directive within a named namespace instead, and one would probably have one's own namespace for one's own header, but that's not as foolproof as an unnamed namespace since a using directive for that namespace would then bring the using directive for the std namespace (or whatever other namespaces were involved in using directives in the custom named namespace) into scope.

> I would have to change each and every cout which could be tedious.
That's why editors have global search and replace features :p


Rather than dragging in the whole of the std namespace, you have some options.

Bite the bullet and do a global search/replace.

Code:

---

#include <iostream>
#include <iomanip>
int main ( ) {
    int var;
    std::cout << "Type some int" << std::endl;
    std::cin >> var;
    std::cout << "You typed " << var << std::endl;
}

---

Only mention the parts of the std namespace you're interested in (or use the most)

Code:

---

#include <iostream>
#include <iomanip>
using std::cout;  // we do this a lot.
int main ( ) {
    int var;
    cout << "Type some int" << std::endl;
    std::cin >> var;
    cout << "You typed " << var << std::endl;
}

---

When you start writing much larger programs, you'll come across libraries which have their own namespaces as well (random example).

In short, "using namespace std;" will get you out of the immediate porting hole you're in, but you shouldn't be using it as a way of being lazy in new code.

Quote:

---

Originally Posted by laserlight

I don't think that's wise: the unnamed namespace makes any names declared within it have internal linkage, but typically in header files you intend the names declared to have external linkage. What could be done is to use the using directive in a local scope, typically in the scope of an inline function defined in the header. Another possibility is to have the using directive within a named namespace instead, and one would probably have one's own namespace for one's own header, but that's not as foolproof as an unnamed namespace since a using directive for that namespace would then bring the using directive for the std namespace (or whatever other namespaces were involved in using directives in the custom named namespace) into scope.

---

I see what you mean. You could still use the construct within header-only includes:

Code:

---

#ifndef DEMO_HPP_

#include <string>
#include <iostream>

namespace demo {

namespace {   
   
using namespace std;   
   
void fun(const string& arg)
{
    cout << arg << endl;
}

} // namespace

} // namespace "demo"

#endif // DEMO_HPP_ not defined

---

Code:

---

#include "demo.hpp"
#include <string>

using namespace std;

int main()
{
    string arg = "Hello World!";
    demo::fun(arg);
}

---

But of course if the user then decides to import the entire "demo" namespace:

Code:

---

#include "demo.hpp"
#include <string>

using namespace demo;

int main()
{
    string arg = "Hello World!"; // Yikes, no complaint from the compiler here!
    fun(arg);
}

---

Side effect being that the entire std namespace gets imported along with it!

So yeah, maybe not the best approach.

Umgh okay.. but I still didn't understand why using namespace shouldn't be used exactly? I don't even know why it even exists..

Quote:

---

Originally Posted by Salem

>That's why editors have global search and replace features

---

And we all know that a world without search and replace features would rightly be called HELL. :o

Quote:

---

Originally Posted by Nwb

Umgh okay.. but I still didn't understand why using namespace shouldn't be used exactly? I don't even know why it even exists..

---

Suppose there were two libraries you'd like to use in your code which both have a function called "reverse". If they didn't use namespaces then you'd obviously get a bunch of compile errors. So namespaces basically prevent name collisions. And it's entirely possible that the libraries just happen to choose the same name for their namespace of course, which is why the name chosen should ideally be as unique as possible.

So writing "using namespace std" would search std for every function in my program? Since the command is not interfering with the functions I defined, I assume everything (that is defined by the user) is assumed to be in std namespace?

So every library function belongs to std right?

Oh and thanks to everybody who replied! ;)

So in short, I must not use using namespace std because it's not good if I want to have more than one namespace. I still can't think of why I would use more than one namespace but it kinda makes sense.

Quote:

---

Originally Posted by Nwb

So writing "using namespace std" would search std for every function in my program? Since the command is not interfering with the functions I defined, I assume everything (that is defined by the user) is assumed to be in std namespace?

So every library function belongs to std right?

Oh and thanks to everybody who replied! ;)

So in short, I must not use using namespace std because it's not good if I want to have more than one namespace. I still can't think of why I would use more than one namespace but it kinda makes sense.

---

Basically yes, when you declare "using namespace X" it imports everything from X into the current namespace (which is often enough the global namespace/scope).

Quote:

---

So writing "using namespace std" would search std for every function in my program? Since the command is not interfering with the functions I defined, I assume everything (that is defined by the user) is assumed to be in std namespace?

---

No, things defined by the user are in the global namespace by default. In fact a user should never try to add something to the std namespace.

Quote:

---

So every library function belongs to std right?

---

No, the only libraries that should use the std namespace are the standard libraries to implement the functions required by the C++ standard.

Quote:

---

So in short, I must not use using namespace std because it's not good if I want to have more than one namespace.

---

Using or not using the "using namespace std;" has nothing to do with having more than one namespace. The "using namespace std;" line was really designed to make porting pre-standard C++ code to standard C++ easier. And realize that you always have at least two namespaces, the std namespace and the global namespace.

Quote:

---

I still can't think of why I would use more than one namespace but it kinda makes sense.

---

You would use more than one namespace when you start developing real world applications that are more than just one or two user defined classes in more than one or two different files. And you will also start using namespaces when your functions and variables have similar/identical names in multiple libraries. Plus while many instructors allow indiscriminate use of using statements (and many other bad practices) most employers will be very disappointed to see these statements anywhere, except in very limited scope.

Quote:

---

You could still use the construct within header-only includes:

---

But remember that headers should rarely, if ever, have executable code within the headers unless you are dealing with templates or inline functions.

Quote:

---

Suppose there were two libraries you'd like to use in your code which both have a function called "reverse". If they didn't use namespaces then you'd obviously get a bunch of compile errors.

---

No, you will not always get a bunch of compile or even linker errors. This is what makes name collisions so hard to find and what makes proper use of namespaces extremely important. It is possible to have functions with the same name as long as each function has a different signature and if you mix up the parameters you may call an unexpected function producing unexpected results.

Quote:

---

Originally Posted by jimblumberg

No, you will not always get a bunch of compile or even linker errors. This is what makes name collisions so hard to find and what makes proper use of namespaces extremely important. It is possible to have functions with the same name as long as each function has a different signature and if you mix up the parameters you may call an unexpected function producing unexpected results.

---

I'd like to take this moment to blame my poor explanation on the lack of any tea or coffee in my system. :p

For future readers, using "using std::cout" or likewise for any other function (ex: using std::endl) is also an option.
Cheers :D

Right, and you can do this at function or block scope as well, instead of the whole file:

Code:

---

void fn1()
{
    using std::vector;
    vector<int> std_vec;
}

void fn2()
{
    // vector<int> std_vec; // error
    std::vector<int> std_vec; // ok

    xyz::vector<int> xyz_vec;
}

---