The rules at
http://community.topcoder.com/tc?module=Static&d1=help&d2=ratedEvent
specify that Library import statements (#include, imports, using, Imports) are exempted.
But in C++, using statement is not for importing a library.
Can anybody please confirm that is using namespace std; exempted from the Excessive / Extra Code Rule, or not?
It can be disputed if using namespace std; would be excessive; it fulfils a function, but rather a syntactical one than a functional one.
Using it, though, is never such a good idea anyway (since it pollutes the current namespace), therefore I would recommend not to use it in any case. There's nothing wrong with a few std:: prefixes in your code, it's not that much to write and then at least one sees easily what comes from std namespace!
Related
Recently i've noticed that if I don't include the 'using namespace std' in my program and just use 'std::cout' or 'std::endl' then my program still compiles just fine? Therefore if I use the 'std::' prefix is it even necessary to include the 'using namespace std'? Does the 'std::' prefix call the using namespace std? If someone can clear this up for me it would be greatly appreciated.
In C++, :: is called the "scope resolution operator", so std::cout means "The variable cout, which can be found inside std".
The using namespace std; directive means "For any name you can't find, also try looking it up in std". Thus, if you explicitly say std::cout (and equivalent for everything else in the std namespace), then you don't need using namespace std.
As others have said, it's usually considered bad style to use using namespace std;, because a lot of the names in std are things you might want to use elsewhere, for example std::count. A compromise option is to instead say using std::cout;, which will tell the compiler to look for cout in std but not anything else.
There's debate about whether to say using std::cout or just write std::cout everywhere you need it in your main C++ file, but most people believe that you should rarely if ever use using namespace. If you're writing a header file, though, you should never use a using directive at the top level because then every file which includes yours will get it, and they might want to use different names.
When you use:
using namespace std;
You're telling the program that anything that it can't find should be in the namespace std. For larger programs, this is a problem because you might be using multiple namespaces with functions that have the same name, so it's best to use std::cout for larger programs.
I searched but I could not find related question.
Please correct me if I'm wrong.
In my project I use the following:
using namespace std;
using namespace sf;
I want it to be like below.
using namespace std, sf;
Thanks in advance!
This syntax is not supported, so you'll have to keep declaring multiple using statements.
In general, though, it's considered best practice to avoid declaring using namespace at all - definitely not in headers, and preferably in the inner-most scope possible (as to not pollute too much scope with unwanted symbols.
I want it to be like below.
using namespace std, sf;
The syntax you're after is simply not supported by the current c++ standard.
Besides it is discouraged to import whole namespaces (at least not in header files), you may sent a request to the c++ standards committee, and see if they like to support that.
The general advice is that you should only
either specify exact classes you're using in your translation unit (to save typing) like using std::cout = co;
or to make everything clear by explicitly using fully qualified identifiers everywhere like std::cout, std::endl, etc.
The latter way is the most readable and best IMO.
I have seen codes with using namespace std;. Does it mean that if we use this then we don't have to include header files in the code or if we don't use namespaces, does it mean that we have to use std:: before every function, class?
You have to include header files and use namespaces.
The namespaces are contained in the header files, io streams like cin,cout are contained in the namespaces.So, only if you include the header file, namespace can be used. Without using namespace std, You have to use scope resolution operator every time you use those functions.
using namespace std; means that all names from std namespace can be used without specifying their namespace explicitly (with std:: prefix). That is, after using namespace std;, both string and std::string are valid. Without using namespace std;, only std::string would work.
Header files still must be included.
Note that usage of using namespace is often discouraged as it populates your code with all names from that namespace, and conflicts may occur.
using namespace std;
Is not really an ideal practice I would apply in a professional code base. The reason is that it practically "opens up" std namespace (packages in Java if you like) where you are probably doing "Hello world"ish programming i.e. not so severe as RT Embedded, Mission Critical, or Safety Critical. For example, I work in Interservice/Industry Training and Simulation where things are often safety/mission critical; people will propbably have a quiet word with me if I was using multiple namespaces so openly. It's not really about the size of your program, it is more about Good practice. Yes, if you have so many things to use from std namespace, then probably you can simply use it. A compromise, and also what I sometimes do, is:
using std::endl;
using std::string;
using std::cout;
using std::cin;
// And something like that
This "exposes" the ones that you will need for this scope and still lets you use:
string myStr;
cout << "Some cout" << endl;
Like what you mentioned in your question. Why not try that?
A "Good bit" of all is that if you follow the approach I mentioned, it also "Upgrade" your level of knowlege in C++ namespaces and possible STLs.
I know some people will say "Well that is stil hard work" but to me it is a good compromise, up to a point. :)
DON'T FORGET TO ADD THE NECESSARY HEADER FILES PLEASE :-)
This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
Why is 'using namespace std;' considered a bad practice in C++?
The other day when I asked a question someone replied saying if someone asks a question, show them the right way to do it instead of using namespace std; which I thought was a bit weird, as using namespace std; is way easier, But I guess I'm failing right now as I am a 'beginner' coder and you guys know better.
So I guess my question is:
Why std:: instead of using namespace std;?
Thanks.
From C++ FAQ:
Should I use using namespace std in my code?
Probably not.
People don't like typing std:: over
and over, and they discover that
using namespace std lets the compiler see
any std name, even if unqualified. The
fly in that ointment is that it lets
the compiler see any std name, even
the ones you didn't think about. In
other words, it can create name
conflicts and ambiguities.
https://isocpp.org/wiki/faq/coding-standards#using-namespace-std
Simply put, you are less likely to use the wrong types or functions by mistake, or name conflicts. Say you are using your own math library, plus std, and declare using both of them, in some arbitrary order. Now, they both define function pow. Which pow are you using when you invoke pow? I think it is worth the extra typing.
I don't think it's the case that more experienced programmers use explicit namespaces, see e.g. Do you prefer explicit namespaces or 'using' in C++?
Note however that you should never import namespaces in header files and that in some cases explicit namespaces are clearer, for example with the functions std::min() and std::max()
I think it is some what a preference thing. Some people like to see the explicit namespaces when using the classes.
One exception is I never to use a using namespace std in a header file. As this can unexpectedly change the behaviour of a class that is using this header file.
Experienced programmers use whatever solves their problems and avoid whatever creates new problems.
Thus they avoid header-file-level using-directives for obvious reason.
And they try to avoid full qualification of names inside their source files.
Minor point is that it's not elegant to write more code when less code suffice without good reason. Major point is turning off ADL.
What are these good reasons? Sometimes you explicitly want turning off ADL. Sometime you want to disambiguate.
So following are ok: 1) function-level using-directives and using-declarations inside functions' implementations; 2) source-file-level using-declarations inside source files; 3) (sometimes) source-file-level using-directives.
Namespace(s) are additional qualifiers for our variables. Lets say we have 'string' defined in std and now if we define a 'string' in mynamespacealso.
Now, if I write using namespace std;at the top of a file, then from there onwards a string becomes ambiguous for a compiler.
One can however take a middle approach, of strictly not having using namespace std;in a header(.h) file, since others might want to use your class and can get conflicts. While for an implementation (.cxx) file, you can be careful to use it if you are sure there won't be any conflicts.
This question already has answers here:
Closed 12 years ago.
Possible Duplicate:
Why is 'using namespace std;' considered a bad practice in C++?
Every time I use using namespace std I always get that "thats a terrible programming habit".
Now I'm graduating this December with my B.S. in C.S. but I don't claim to know everything, but no one has ever explained why this is so bad. I understand what it does but I honestly don't see a huge deal with it.
Anyone care to explain? In my mind it just makes typing cout a whole lot more bearable than std::cout.
I can understand why you wouldn't want to put it in a header file, but just in a normal implementation file... I dont see why it would be a problem.
There is no problem using using namespace std in your source file when you make heavy use of the stl and know for sure that nothing will collide.
However, very often you don't need to use using namespace std or not in the entire file:
Did you know you can:
void somefunction()
{
// Use it in a particular scope
using namespace std;
cout << "test" << endl;
}
found this useful post elsewhere:
Namespaces separate and organize functionality. You can have a xander333::sort() function and it won't conflict with std::sort() or boost::sort() or any other sort(). Without namespaces there can be only one sort().
Now let's say you've put "using namespace std;" in all your source files and you've implemented a simple templated function called fill() in the global namespace of one of your files. This file also depends on a header from libFoo -- foo.hpp. Version 2.1 of libFoo comes out and all of a sudden your program no longer compiles. You version of fill() suddenly conflicts with another fill()! What happened?
It turns out that the folks implementing libFoo included in the new version of foo.hpp when they didn't before. Now you have all of the standard algorithms being included in your source file, and your using namespace std; has pulled them all into the global namespace. std::fill() now directly conflicts with your fill().
More insidious, you've gotten your code to compile by renaming your fill() to xander333_fill(), but something's not working right -- your report numbers are off. It turns out that your custom divides() function, which does fixed precision math, is no longer being called because the templated function from (also newly included by foo.hpp) makes for a better match because you're calling types did not exactly match the declared types.
Thread with relevant discussion is here:
http://www.cplusplus.com/forum/unices/27805/
a "good practice" that I am aware of is not to put using namespace in include files, but be free to use it to your taste in your private .cpp files. I know people who like everything to be fully qualified, and some (like me) who assume that string is an std::string unless stated otherwise.
The reason for this is that if/when others use your include file (and this happens always), they are forced to accept your programming style.
Good luck!
My preference is to:
never put a using directive in a header file (the things that include your header may not like the fact that you forced them to have the using directive).
always do things like using std::cout; at the top of the implementation files so I don't have to do std::cout everywhere in my code.
It's primarily about good housekeeping. If you're not really going to use more than a few identifiers in a namespace, why clutter up your own namespace by dumping all of the identifiers from that namespace into yours? It's preferable to use using std::cout. However, if you use a namespace very heavily and it doesn't cause any collisions, go ahead and use using namespace.
Another reason to not use using other than avoiding potential naming collisions is to speed up your IDE and possibly compiles.
If you're using Visual Studio, using namespace std and/or using namespace boost can kill intellisense entirely. There are a lot of symbols in these namespaces that you may not realize and dumping them into the global namespace can be ludicrous.
Avoiding using statements for entire namespaces helps prevent unintentional conflicts between libraries. Supposed you made your own class that had the same name as something in std, then unless you explicitly use std:: you will have name conflicts.
It's probably best to try to avoid conflicts like this in the first place, but if you specify the namespace for each member in your code it will be less ambiguous.
If you get tired of typing std::cout all the time, you can use a using statement for just that member.