C++ Namespaces

Overview

Namespaces are a mechanism provided by C++ to avoid name conflicts. They divide the global scope into several named scopes, allowing the same identifiers to exist in different namespaces without conflict. Namespaces improve code organization and maintainability.

🏷️ Namespace Basics

Defining and Using Namespaces

#include <iostream>
#include <string>

// Define namespace
namespace Math {
    const double PI = 3.14159;
    
    double add(double a, double b) {
        return a + b;
    }
    
    double multiply(double a, double b) {
        return a * b;
    }
    
    namespace Advanced {
        double power(double base, double exp) {
            return std::pow(base, exp);
        }
        
        double factorial(int n) {
            return (n <= 1) ? 1 : n * factorial(n - 1);
        }
    }
}

namespace Graphics {
    struct Point {
        double x, y;
        Point(double x = 0, double y = 0) : x(x), y(y) {}
    };
    
    double distance(const Point& p1, const Point& p2) {
        double dx = p1.x - p2.x;
        double dy = p1.y - p2.y;
        return std::sqrt(dx * dx + dy * dy);
    }
    
    void print(const Point& p) {
        std::cout << "Point(" << p.x << ", " << p.y << ")" << std::endl;
    }
}

int main() {
    std::cout << "=== Namespace Basics ===" << std::endl;
    
    // Use fully qualified name
    double result = Math::add(5.0, 3.0);
    std::cout << "Math::add(5.0, 3.0) = " << result << std::endl;
    
    result = Math::multiply(4.0, Math::PI);
    std::cout << "4.0 * PI = " << result << std::endl;
    
    // Nested namespace
    double power_result = Math::Advanced::power(2.0, 3.0);
    std::cout << "2^3 = " << power_result << std::endl;
    
    // Same name in different namespaces
    Graphics::Point p1(3, 4);
    Graphics::Point p2(0, 0);
    Graphics::print(p1);
    
    double dist = Graphics::distance(p1, p2);
    std::cout << "Distance: " << dist << std::endl;
    
    return 0;
}

using Declarations and using Directives

#include <iostream>
#include <vector>
#include <string>

namespace Library {
    class Book {
    private:
        std::string title_;
        std::string author_;
        
    public:
        Book(const std::string& title, const std::string& author)
            : title_(title), author_(author) {}
        
        void display() const {
            std::cout << "《" << title_ << "》 - " << author_ << std::endl;
        }
        
        const std::string& getTitle() const { return title_; }
        const std::string& getAuthor() const { return author_; }
    };
    
    void printBook(const Book& book) {
        std::cout << "Book information: ";
        book.display();
    }
    
    std::vector<Book> createLibrary() {
        return {
            Book("C++ Programming", "Bjarne Stroustrup"),
            Book("Introduction to Algorithms", "Thomas Cormen"),
            Book("Design Patterns", "Gang of Four")
        };
    }
}

int main() {
    std::cout << "=== using Declarations and Directives ===" << std::endl;
    
    // 1. using declaration: import specific names
    using Library::Book;
    using Library::printBook;
    
    Book book1("Effective C++", "Scott Meyers");
    printBook(book1);
    
    // 2. using directive: import entire namespace
    {
        using namespace Library;
        
        auto library = createLibrary();
        std::cout << "\nLibrary collection:" << std::endl;
        
        for (const auto& book : library) {
            printBook(book);
        }
    }
    
    // 3. Local using declaration
    {
        std::cout << "\nLocal using example:" << std::endl;
        using std::cout;
        using std::endl;
        
        cout << "Using local using declaration" << endl;
        // Here std::cout becomes cout
    }
    
    return 0;
}

🔧 Advanced Namespace Features

Namespace Aliases

#include <iostream>
#include <string>

namespace VeryLongNamespaceForDemonstration {
    namespace Graphics {
        namespace TwoDimensional {
            struct Point {
                double x, y;
                Point(double x = 0, double y = 0) : x(x), y(y) {}
                
                void print() const {
                    std::cout << "2D Point(" << x << ", " << y << ")" << std::endl;
                }
            };
            
            struct Line {
                Point start, end;
                Line(const Point& s, const Point& e) : start(s), end(e) {}
                
                void print() const {
                    std::cout << "Line from ";
                    start.print();
                    std::cout << " to ";
                    end.print();
                }
            };
        }
        
        namespace ThreeDimensional {
            struct Point {
                double x, y, z;
                Point(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
                
                void print() const {
                    std::cout << "3D Point(" << x << ", " << y << ", " << z << ")" << std::endl;
                }
            };
        }
    }
}

int main() {
    std::cout << "=== Namespace Aliases ===" << std::endl;
    
    // Create alias for long namespace
    namespace G2D = VeryLongNamespaceForDemonstration::Graphics::TwoDimensional;
    namespace G3D = VeryLongNamespaceForDemonstration::Graphics::ThreeDimensional;
    
    // Use alias
    G2D::Point p1(1, 2);
    G2D::Point p2(3, 4);
    G2D::Line line(p1, p2);
    
    std::cout << "2D Graphics:" << std::endl;
    line.print();
    
    G3D::Point p3(1, 2, 3);
    std::cout << "\n3D Graphics:" << std::endl;
    p3.print();
    
    // Can also create aliases for types
    using Point2D = G2D::Point;
    using Point3D = G3D::Point;
    
    Point2D point2d(5, 6);
    Point3D point3d(7, 8, 9);
    
    std::cout << "\nUsing type aliases:" << std::endl;
    point2d.print();
    point3d.print();
    
    return 0;
}

Anonymous Namespaces

#include <iostream>
#include <string>

// Anonymous namespace: has internal linkage
namespace {
    int internalCounter = 0;
    
    void incrementCounter() {
        ++internalCounter;
        std::cout << "Internal counter: " << internalCounter << std::endl;
    }
    
    class InternalHelper {
    public:
        static void doWork() {
            std::cout << "Internal helper class working..." << std::endl;
        }
    };
}

// Global function
void globalFunction() {
    std::cout << "This is a global function" << std::endl;
}

// Function in namespace
namespace Utilities {
    void utilityFunction() {
        std::cout << "This is a utility function" << std::endl;
        
        // Can access anonymous namespace contents
        incrementCounter();
        InternalHelper::doWork();
    }
    
    namespace {
        // Nested anonymous namespace
        std::string secretMessage = "This is a secret message";
        
        void showSecret() {
            std::cout << "Secret: " << secretMessage << std::endl;
        }
    }
    
    void revealSecret() {
        showSecret();  // Can access nested anonymous namespace
    }
}

int main() {
    std::cout << "=== Anonymous Namespace ===" << std::endl;
    
    // Directly access anonymous namespace contents
    incrementCounter();
    InternalHelper::doWork();
    
    // Indirectly access through namespace function
    Utilities::utilityFunction();
    Utilities::revealSecret();
    
    // Global function
    globalFunction();
    
    std::cout << "\nPurpose of anonymous namespaces:" << std::endl;
    std::cout << "1. Provides file-level privacy" << std::endl;
    std::cout << "2. Replaces static global variables and functions" << std::endl;
    std::cout << "3. Avoids name conflicts" << std::endl;
    
    return 0;
}

🌐 std Namespace

Using the Standard Library Namespace

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

// Not recommended: global using namespace std
// using namespace std;  // Pollutes global namespace

void demonstrateStdNamespace() {
    std::cout << "=== std namespace usage ===" << std::endl;
    
    // Method 1: Fully qualified name (recommended)
    std::vector<std::string> words = {"hello", "world", "cpp", "namespace"};
    
    std::cout << "Original words: ";
    for (const std::string& word : words) {
        std::cout << word << " ";
    }
    std::cout << std::endl;
    
    // Method 2: Local using declaration (recommended)
    using std::sort;
    using std::cout;
    using std::endl;
    
    sort(words.begin(), words.end());
    
    cout << "Sorted: ";
    for (const auto& word : words) {
        cout << word << " ";
    }
    cout << endl;
}

// Function-level using declaration
void processData() {
    using std::vector;
    using std::string;
    using std::cout;
    using std::endl;
    
    vector<string> data = {"C++", "is", "awesome"};
    
    cout << "Processing data: ";
    for (const auto& item : data) {
        cout << item << " ";
    }
    cout << endl;
}

// Custom namespace interaction with std
namespace MyLibrary {
    // Avoid conflicting names with std
    class string {  // Different from std::string
    private:
        std::string data_;
        
    public:
        string(const std::string& s) : data_(s) {}
        
        void print() const {
            std::cout << "MyLibrary::string: " << data_ << std::endl;
        }
        
        std::string toStdString() const {
            return data_;
        }
    };
    
    // Use ADL (Argument Dependent Lookup)
    void print(const string& s) {
        std::cout << "Called via ADL: ";
        s.print();
    }
}

int main() {
    demonstrateStdNamespace();
    
    std::cout << "\n--- Function-level using ---" << std::endl;
    processData();
    
    std::cout << "\n--- Custom vs Standard Library ---" << std::endl;
    
    // Standard library string
    std::string stdStr = "Standard library string";
    std::cout << "std::string: " << stdStr << std::endl;
    
    // Custom string
    MyLibrary::string myStr("Custom string");
    myStr.print();
    
    // ADL call
    print(myStr);  // Find MyLibrary::print via ADL
    
    std::cout << "\n=== std namespace best practices ===" << std::endl;
    std::cout << "✓ Prefer fully qualified names" << std::endl;
    std::cout << "✓ Use local using declarations for specific names" << std::endl;
    std::cout << "✗ Avoid global using namespace std" << std::endl;
    std::cout << "✓ Don't use using directives in header files" << std::endl;
    
    return 0;
}

📋 Namespace Design Patterns

Organizing Large Projects

#include <iostream>
#include <string>
#include <memory>

// Project's main namespace
namespace MyProject {
    // Version information
    namespace Version {
        const int MAJOR = 1;
        const int MINOR = 2;
        const int PATCH = 3;
        
        std::string getVersionString() {
            return std::to_string(MAJOR) + "." + 
                   std::to_string(MINOR) + "." + 
                   std::to_string(PATCH);
        }
    }
    
    // Core functionality module
    namespace Core {
        class Engine {
        public:
            void start() {
                std::cout << "Engine started (version " << Version::getVersionString() << ")" << std::endl;
            }
            
            void stop() {
                std::cout << "Engine stopped" << std::endl;
            }
        };
    }
    
    // User interface module
    namespace UI {
        class Window {
        private:
            std::string title_;
            
        public:
            Window(const std::string& title) : title_(title) {}
            
            void show() {
                std::cout << "Show window: " << title_ << std::endl;
            }
            
            void hide() {
                std::cout << "Hide window: " << title_ << std::endl;
            }
        };
        
        namespace Controls {
            class Button {
            private:
                std::string text_;
                
            public:
                Button(const std::string& text) : text_(text) {}
                
                void click() {
                    std::cout << "Button '" << text_ << "' clicked" << std::endl;
                }
            };
        }
    }
    
    // Utilities module
    namespace Utils {
        namespace String {
            std::string toUpper(const std::string& str) {
                std::string result = str;
                std::transform(result.begin(), result.end(), result.begin(), ::toupper);
                return result;
            }
            
            std::string toLower(const std::string& str) {
                std::string result = str;
                std::transform(result.begin(), result.end(), result.begin(), ::tolower);
                return result;
            }
        }
        
        namespace Math {
            double clamp(double value, double min, double max) {
                return std::max(min, std::min(max, value));
            }
        }
    }
}

// Aliases to simplify access
namespace MP = MyProject;
namespace Core = MyProject::Core;
namespace UI = MyProject::UI;

int main() {
    std::cout << "=== Namespace Design Patterns ===" << std::endl;
    
    // Use complete namespace
    std::cout << "Project version: " << MyProject::Version::getVersionString() << std::endl;
    
    // Use alias
    Core::Engine engine;
    engine.start();
    
    UI::Window mainWindow("Main Window");
    mainWindow.show();
    
    UI::Controls::Button okButton("OK");
    okButton.click();
    
    // Utility functions
    using namespace MyProject::Utils;
    
    std::string text = "Hello World";
    std::cout << "Original: " << text << std::endl;
    std::cout << "Uppercase: " << String::toUpper(text) << std::endl;
    std::cout << "Lowercase: " << String::toLower(text) << std::endl;
    
    double value = Math::clamp(15.5, 10.0, 20.0);
    std::cout << "Clamped value: " << value << std::endl;
    
    engine.stop();
    mainWindow.hide();
    
    return 0;
}

---

Summary

Namespaces are an important mechanism in C++ for managing large projects and avoiding name conflicts:

Namespace Types

• Named namespace: Explicitly named scope
• Anonymous namespace: File-level private scope
• Nested namespace: Hierarchical organization
• std namespace: Standard library namespace

Usage Methods

Method	Syntax	Use Case
Fully qualified name	std::cout	Generally recommended
using declaration	using std::cout;	Frequently use specific names
using directive	using namespace std;	Local scope
namespace alias	namespace ns = LongName;	Simplify long names

Best Practices

• Avoid using directives in header files
• Prefer fully qualified names
• Reasonably organize project namespace hierarchy
• Use anonymous namespaces to replace static
• Create aliases for long namespaces

Design Principles

• Hierarchical organization: Divide by functional modules
• Avoid conflicts: Use unique top-level namespace
• Clear and concise: Namespace names should be clear
• Version management: Can include version information

Namespaces make C++ projects have good structure and maintainability, and are indispensable tools for modern C++ development.