Omitting Namespace
Using std:: Prefix
Instead of writing `using namespace std;`, explicitly prefix standard library components with `std::`. This makes the code clearer and avoids potential naming conflicts. There is no runtime cost—this is purely a compile-time name-lookup choice.
#include <iostream>
#include <string>
int main() {
std::string greeting = "Hello";
std::cout << greeting;
return 0;
}Hello
Pros and Cons
Advantages of omitting `using namespace std;`:
- Prevents accidental name collisions with other libraries or user-defined identifiers
- Makes it clear which components come from the C++ standard library
- Recommended for large or shared projects and libraries
Disadvantages:
- More verbose code (every standard name requires `std::`)
- Can reduce readability in very small programs or quick examples
Selective using Declarations
You can import only the specific names you need instead of the whole namespace. Prefer limiting these to local scopes (e.g., inside a function). Avoid placing `using std::name;` in a public header's global namespace, as it leaks names to all includers.
#include <iostream>
#include <string>
int main() {
using std::cout;
using std::string;
string name = "Alice";
cout << name;
return 0;
}Alice
Namespace Aliases
If a qualifier is long, create a short alias for the namespace. This improves readability without importing everything.
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem; // C++17
int main() {
fs::path p = "data.txt";
std::cout << p.filename().string();
return 0;
}data.txt
Alias for Other Standard Subnamespaces
You can also shorten newer standard sub-namespaces. This keeps call sites short while still being explicit about origin.
#include <ranges> // C++20
#include <vector>
#include <iostream>
namespace rng = std::ranges;
int main() {
std::vector<int> v{1,2,3,4};
if (rng::all_of(v, [](int x){ return x > 0; })) {
std::cout << "all positive";
}
return 0;
}all positive
ADL-Friendly Patterns (Generic Code)
In templates and generic code, enable Argument-Dependent Lookup (ADL) by pulling in a few names with `using` inside a small scope, then calling them unqualified. This lets user-defined overloads be found while still falling back to the standard version.
#include <utility>
template <class T>
void my_swap(T& a, T& b) {
using std::swap; // enable ADL
swap(a, b); // calls T-specific swap if available, else std::swap
}
Literal Suffix Namespaces
For standard literal operators (e.g., string or string_view suffixes), prefer importing only the literal namespace—and only in a narrow scope.
#include <string>
#include <string_view>
int main() {
using namespace std::string_literals; // C++14
using namespace std::string_view_literals; // C++17
auto s = "hi"s; // std::string
auto sv = "hi"sv; // std::string_view
(void)s; (void)sv;
return 0;
}Best Practices
- **Never** write `using namespace std;` in header files—doing so pollutes every translation unit that includes the header.
- If you use a using-directive at all, limit it to **small local scopes** (e.g., inside a function) in implementation files, not headers.
- Prefer selective `using std::name;` declarations or a namespace alias for readability.
- In public headers, avoid global-scope `using std::name;`. If shortening names is necessary, put `using` declarations inside **your own namespace**, not the global namespace.
- Keep a consistent style across the project.