Printable View
I have seen some various things around the forum and was wondering if 'using namespace std' should be avoided. I have seen some people claim that this is bad practice that it is better to preface your statements with std:: Would someome please explain this and which option is better?
You should avoid any using directive (e.g., using namespace std; ) or using declaration (e.g., using std::cout; ) in a header file, unless it is within some restricted scope, e.g., within the body of a function.
Other than this, it is a matter of style: there are pros and cons, e.g., the presence of the using directive may increase the chance of a name collision even when used in a local scope, but then it also makes the code easier to type and read. On the other hand, fully qualifying the name might also make it easier to identify exactly which name it is, i.e., it makes the code easier to read in another way.
It's an easy kludge to get pre-ANSI C++ up to standard.
- remove the .h from all the standard C++ header files (iostream.h -> iostream)
- prepend 'c' to the start of standard C header files (stdio.h -> cstdio)
- add "using namespace std;"
Job is nearly done.
For any new code, a bit more finesse should be used.
This is especially true if this is going to be a large project with multiple namespaces to begin with.
Thanks a lot for the information. Apparently I had misunderstood some of stuff that I read previously. Seems like the using statement is OK to use as long as it is not in a header file, then extra caution should be used.
Not quite.Quote:
Originally Posted by pikuchan
It is generally inadvisable to have a using statement in a header file (except in restricted scopes, as mentioned by laserlight). It can be used with care in other contexts.
That's a little different to your conclusion, IMHO.
Personally, in real code, I never employ any using directive, unless it is the only option available. In practice, that means never employing "using namespace" and only rarely (eg in a class definition) even having a using directive.
(Note that I don't view code I post in forums as "real code" - it's for illustrative purposes only ;) )
so if it is not really a good idea - sounds to me like it isn't a good idea at allQuote:
Originally Posted by grumpy
why was it made then?
I find it easier to declare using directive..reduces how much i use to type.
The using directive was made in order to bring the millions of lines of existing code up to the new standard. What's a little extra typing if it helps produce clean code.
Jim
cool. I still have a lot to learn!
That is the core of the argument that Sutter and Alexandrescu make for recommending the liberal use of using directives and using declarations in source files (but not in header files, or before #include directives). The problem with liberal use is really that name collisions become more likely, and you might make a mistake in assuming that a name is from one namespace when actually it is from another (e.g., because a certain header was not included).Quote:
Originally Posted by Eman
My preference is to use a single using directive in a local scope when many names from that namespace would otherwise need to be fully qualified in that scope. If there are names from more than one namespace that would qualify, I pick the namespace for which the using directive would increase the readability the most. This way, the possibility of collision is more or less limited to names local to that scope (e.g., local and member variables), names from the global namespace (which should be rare), and names from that namespace for which the using directive applies.
If a specific name is used many times in a local scope, I tend to change the using directive to a using declaration. Using declarations see slightly more use though, e.g., to enable overloads of std::swap to be utilised, or to bring in names from a base class that would otherwise be hidden by overloaded names from the derived class.
That's one thing that annoys me when I read Java code examples online. People never fully qualify Java classes and their examples don't even have the import statements, so you're left guessing which class their code uses. But it certainly makes code a lot more readable by not fully qualifying everything. It's a double edged sword I guess.
I completely agree with laserlight. It should by no means be considered a faux-pas, but it should be understood properly and used only when needed. And indeed, the use of using declarations is always a good idea, if only because it limits the possible collision space.
I avoid the 'using' statement as much as possible, but to make my code more readable (not to make it easier to type!) I use it in some cases. I also use to add a special highlight to those 'used' identifiers.
In one of my projects, made of several stand-alone apps and a common static library, I also spliced the common library namespace to the local ones, improving code's readibility.Code:using std::time_t;
using std::make_pair;
using kmlib::make_shared;
using kmlib::make_intrusive;
These special cases were introduced because of the 80-column rule I stick to.
And yet another good side of the using declaration:
If I decide to move and use boost's make_shared function, I don't need to change every single statement in my program.
Because C++ is a language that gives you the tools, but gives you the choice of where to put them to use. It doesn't stop you from shooting yourself in the leg, so to speak, unlike some languages like Java.Quote:
Originally Posted by Eman
uh, what is difference between using declaration and using directive?
do they not all mean
using namespace std; ?
So i should only use namespace std, in some .cpp and not header files?
>>uh, what is difference between using declaration and using directive?
>>do they not all mean
>>using namespace std; ?
They could mean the same thing at the end of the day, assuming you only ever use std objects or classes. The difference is application. A using declaration will resolve one thing for you, until the directive is out of scope:
using std::vector;
using std::auto_ptr;
using std::cout;
using std::cin;
using std::endl;
A using directive will resolve everything in an entire namespace until it is out of scope. Now assume the scope is file scope. Namespaces become pointless if you want to ignore them all the time, in an entire file, and it leads to the problems everyone has tried to communicate to you.
After all if the only way to distinguish an identifier is through its namespace, and you've assumed a particular namespace is being used either way, the compiler will not know which definition applies to the identifier. So you have options: Assume namespace foo is being used and resolve bar explicitly because it is used less often:
using namespace std;
boost::shared_ptr<object> pthing;
Or resolve things all the time. Or painstakingly use only one namespace, ever. The last option will be hard, and not something you will always have the option to do.
>>So i should only use namespace std, in some .cpp and not header files?
Just think for a minute. You and another person implement some useful libraries that *I* want, but you share identifiers for a class. If you put a using directive in your header file, you're assuming, if I want to write code without namespace resolutions in it, that I'm going to be using your object instead of some other object. (You're making the directive before I can, because #include is processed before the source.) That might not make complete sense, but if I'm only linking your library for part of its code, and using another implementation for something else that you wrote, for some reason (maybe that particular class has security flaws or is otherwise FUBAR), all of a sudden I can't compile my code. I could easily be gracious and change my resolutions, but isn't that kind of rude? The source of the problem is between the two libraries.
In some cases, you may find that you want to use a using directive because the namespace name is just too long. In such cases, you should consider a namespace alias instead, e.g.,
Code:namespace jimblumberg
{
void foo()
{
// ...
}
}
// ...
namespace jbb = jimblumberg;
jbb::foo();
Or you may have some nested namespaces that are too long. Then you can also use an alias to shorten it up.
Code:namespace jimblumberg
{
void foo();
{
}
namespace laserlight
{
void bar()
{
}
}
}
namespace jimblumberg::laserlight = jbll;
jbll::bar();
Jim
I always make my namespaces up to 6 characters long (the global one is usually the same as the target binary, e.g. for target 'prog32.exe' I use namespace 'prog' etc.) so there is no need to prefix names with long scope names.
And maybe someone has already mentioned about it:
If you place a 'using' declaration with a namespace you will be able to access all of the namespaces that are used within the specified namespace.
If 'first' is using 'std' and 'second' is using 'first', then 'second' is using 'std' too.
I prefer to fully qualify my namespaces.
I have had problems with the using directive in the past, the same function defined in the global namespace and in namespace std. It took me several hours to find the problem, and thanks to forum members I finally was able to fix the problem.Code:std::cout << "Hello World" << std::endl;
Jim