Why Is Namespace Important for Using cout in C++?

[JonnyG]

Let's take the count function for example. That's included in the iostream library (is library the correct word here?) which is why I type #include <iostream> at the beginning of my program. Now when I want to use the count function, I either have to type std::count or I can just type count but have to write using namespace std or using std::count before my main() function.

I was told that the reason why we have namespaces is because what if we use another library that also has a count function for example? The compiler won't know which count function to use. But why do we associate count with std? Isn't count a function in the iostream library? So wouldn't it make more sense to type iostream.count or iostream::count when we want to use the count function that specifically belongs to the iostream library?

What is the purpose of the namespace in this sense and what is the relationship between the namespace std and the library iostream?

 

[jedishrfu]

The std namespace is reserved for important io methods called often in C++ programs. However to be fair, you have to specify if you’re using it to eliminate the std prefix.

if you recall in C programs, there is the stdio.h header file that is needed to get the various print functions.

edit: fixed studio.h to stdio.h

 

[Mark44]

if you recall in C programs, there is the studio.h header file

Minor point, but it's stdio.h, not studio.h.

Let's take the count function for example.

count is not a function -- it's an output stream, similar to cin, which is an input stream. The actual function that is typically used with count is <<, or more precisely operator<<(), the overloaded << operator.

What is the purpose of the namespace in this sense and what is the relationship between the namespace std and the library iostream?

Dividing function names and such into namespaces helps to prevent name collision. For example, you could have your own variable named count, and as long as you didn't include iostream.h (and didn't include the line using namespace std;) your use of count would not conflict with how the count stream is normally used.
I don't recommend you do this, though, since it would be much more difficult to have your program do output to the monitor.

The idea of namespaces is a little like how local variables (variables defined inside functions) work. Two functions funcA() and funcB() could have a variable named temp. The two temp variables are completely separate -- setting one of them to some value inside funcA() would have no effect on the variable of the same name in the other function. The concept of namespaces takes this idea a step farther.

 

[jedishrfu]

Yes you’re right, the spellcheck changed the spelling to studio as I posted it and I didn’t notice.

 

[FactChecker]

What is the purpose of the namespace in this sense and what is the relationship between the namespace std and the library iostream?

Using namespace is just a convenient shortcut in the syntax. Using it is never necessary. In fact, it is often discouraged and sometimes disallowed by programming standards.

 

[Vanadium 50]

I think the question is less "why use namespaces?" and more "why is all of STL under a single namespace, std?"

That's probably more history than computer science. One factor is that people who adopted STL usually adopted all of it. Another is that it is probably easier to have developed STL under a single namespace. A third is that the advantages to splitting into a dozen smaller namespaces are small, and the cost of remembering what namespace gives you what function is usually larger than the benefit. But there's no technical reason why they couldn't have done it differently.

 

[JonnyG]

I read all of the answers but I still do not understand. I think I may have done a poor job of explaining my confusion. Let me try again:

When we write #include <iostream> we are importing the iostream library. This is necessary for us to use count and cin. If there were another count for example, then we could uniquely identify the count from iostream by writing iostream.count (I know this is not proper syntax, I am just using it as a demonstration). Why is std used to refer to the count that belongs to iostream? Wouldn't iostream be enough to uniquely identify which count we are talking about?

Adding to my confusion, if we want to use vectors then we write #include <vector>, but then we again have to somehow use std to reference vector when declaring a vector. Why wouldn't the vector class be enough to uniquely identify the vector we are talking about?

 

[Vanadium 50]

Why is std used to refer to the count that belongs to iostream?

Because "std" refers to the Standard Template Library (or STL) which was originally an add-on. That add-on included count, vector and a lot of other things.

 

[JonnyG]

Because "std" refers to the Standard Template Library (or STL) which was originally an add-on. That add-on included count, vector and a lot of other things.

Thank you. Your comment about it being more history than computer science makes more sense now.

 

[FactChecker]

You might include many libraries with the same named functions, each with a different use. You might use "use namespace" to make one of them the default, but that might not be reasonable unless the one you choose is the one you want the vast majority of the time. Otherwise, it is best to just indicate clearly, which function you want each time by prefixing it with the correct library name.

 

[Mark44]

Yes you’re right, the spellcheck changed the spelling

Spellcheckers seem to me to more the problem than the solution.

 

[jtbell]

When we write #include <iostream> we are importing the iostream library.

More precisely, we are telling the compiler to (in effect) "paste" the text of a particular "include file" into your program code at the location of the #include directive. It contains the definitions of types such as istream, ostream, fstream; the declaration of specific objects such as count (which is of type ostream) and cin (which is of type istream); etc.

Without the namespace mechanism, if you were to #include another header file that also defines a type named istream and an object named count, I don't think there would be any way for the compiler to distinguish between them. It would give you error messages complaining about the duplicate names. You would get the same or a similar error message if you were to declare the same variable name twice within one of your own functions.

This is why the namespace mechanism exists. In general, you have to specify the namespace of all names that you use, that are defined at the global level (outside any function), either explicitly (e.g. by writing std::count whenever you use count), or implicitly (e.g. by writing using namespace std or using std::count at the beginning of your program).

When you define a class, variable, or function at the global level, it is by default in the "global namespace" which has no name. I found this example while reading up about namespaces:

#include <iostream>

int a = 100;

main () {
    int a = 200;

    std::count << "local a is: " << a << std::endl;
    std::count << "global a is: " << ::a << std::endl;

    return 0;
}

Here, in order to use the global a inside the function, you have to refer to it as ::a because otherwise it's "hidden" by the existence of the local a. If there's no local a, then you can refer to the global a as simply a.

(I hope I got these details right. I had to spend some time reading up about namespaces because my memory was rusty and probably incomplete.)