Why ‘using namespace std' is a bad practice?

In C++, the line ‘using namespace std’ brings all the identifiers of the standard namespace into the global namespace, which can result in conflicts if some other part of the code has also declared any identifier in the same scope.

These conflicts can either cause compilation errors or make it very difficult to fix the code. The simplest way out of these issues is always to use std:: prefix in the code. In this article, we’ll explore why this simple line can lead to issues and what better alternatives exist.

Table of Contents:

• Issues with using namespace std in C++
  • Handling Namespace Conflicts
  • Clarity Issues
  • Encapsulation and Scope
  • Issues with Code Maintainability
• How to Solve ‘using namespace std’ Issue
• Conclusion

Issues with using namespace std in C++

Following are some of the issues with using the namespace std:

1. Handling Namespace Conflicts 

The use of the ‘using namespace std’ expression in C++ programming language, imports all the identifiers from the std namespace into the global namespace. This may give rise to the problem of name conflicts if the same identifier is also defined in another part of the user’s code.

Example: 

Output: 

When using namespace std, importing all the identifiers from the standard namespace to the global namespace, however,  if the user defines the function name with the same name(e.g.: int cout = 42)  it leads to an error.

2. Clarity Issues

The large programs or codebases with a lot of libraries could be a task to find where exactly a function or a class has come from. This can reduce code readability, which is most especially the case if it’s for a person new to the code reading it or if a new feature is being inserted into the program. 

Example: 

Output: 

The program defines a vector that is initialized to hold three integers using the std::vector container. The output does not need std:: to be the prefix of cout as using namespace std; is given. The program uses std::cout to display a ‘Hello’ on the screen. 

3. Encapsulation and Scope

By bringing all the components into the global namespace using namespace std, you might lose the ability to separate the code into different sections, it may be unclear to differentiate between the standard library code and your code

Example:

Output: 

In the above example, we have a function printMessage which is in MyLib namespace and uses std::cout explicitly. This does not clash with user-defined cout functions in the namespace. In this case, we can always specify std::cout and resolve these conflicts as they arise. For example, the MyLib namespace has a function printMessage that uses std::cout directly. This ensures there is no possible conflict with user-defined cout functions in the namespace. When we always mention std::cout, we don’t confuse the standard output stream with something else.

4. Issues with Code Maintainability

Maintainability is the utmost important description for a large code base. Code parts with ‘using namespace std;’ are the ones that are hard to maintain because it is not only hard to tell where names come from but also which namespace a name belongs to. In the case of an extension of ‘using namespace std;’ will cause a problem whenever newer codes or libraries are added.

How to Solve ‘using namespace std’ Issue

To overcome the issues caused by using namespace std, consider these points:

1. Always use ‘std::’ as a prefix for standard library components that you are using to avoid conflicts of namespaces.
2. Prefer using ‘using namespace std;’ in blocks or functions rather than in the global scope to prevent name conflicts.
3. The ‘using namespace std;’ statement does not apply to the header file because it will be included in any source file that depends on it and this may introduce the name conflicts in the codebase.

Conclusion

The use of the namespace std; appears commonly in small/basic examples. Such behavior brings several inconveniences – for example, the unclear presentation and the name conflicts. As a result, it turns the process of maintenance into a complicated one. The new and common way to avoid such conflicts is by prefixing with ‘std::’ in selected declarations of specific names, which are primarily the safest and most maintainable solutions.

FAQs