C++ Namespaces Explained — Scope, Conflicts and Real-World Patterns

#include <iostream>
#include <string>

// --- Defining two separate namespaces that both have a 'greet' function ---
// Without namespaces, the compiler would refuse to compile this — two functions
// with identical signatures in the same scope is an error.

namespace english {
    std::string greet(const std::string& name) {
        return "Hello, " + name + "!";
    }
}

namespace spanish {
    std::string greet(const std::string& name) {
        return "Hola, " + name + "!";
    }
}

int main() {
    std::string visitorName = "Maria";

    // Scope resolution tells the compiler exactly which 'greet' to call.
    // Remove the namespace prefix and the compiler will complain about ambiguity.
    std::cout << english::greet(visitorName) << "\n";  // calls english version
    std::cout << spanish::greet(visitorName) << "\n";  // calls spanish version

    return 0;
}

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

// DANGER: This brings ALL of std into scope — thousands of names
// using namespace std;  // <-- never do this in real code

// BETTER: Targeted using-declarations — bring in only what you need
using std::cout;
using std::endl;

// Imagine this function exists in your codebase
int count(const std::vector<int>& numbers) {
    int total = 0;
    for (int n : numbers) total += n;
    return total;  // This 'count' sums values
}

int main() {
    std::vector<int> scores = {10, 20, 30, 40, 50};

    // With 'using namespace std' active, calling count() here becomes ambiguous:
    // is it YOUR count() or std::count() from <algorithm>?
    // The compiler may pick the wrong one or error out.

    // With targeted using-declarations, YOUR count() is unambiguous.
    cout << "Sum of scores: " << count(scores) << endl;

    // The std:: prefix makes intent crystal clear — no guessing needed.
    auto howMany = std::count(scores.begin(), scores.end(), 30);
    cout << "Number of scores equal to 30: " << howMany << endl;

    return 0;
}

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

// --- Simulating a small project with two logical modules ---
// In a real project these would live in separate header/source files.
// The namespace structure mirrors the project's directory structure.

// payments/validation.h + payments/validation.cpp
namespace payments::validation {  // C++17 nested namespace syntax

    bool isAmountValid(double amount) {
        return amount > 0.0 && amount < 1'000'000.0;  // digit separator for readability
    }

    bool isCardNumberLength(const std::string& cardNumber) {
        return cardNumber.length() == 16;
    }
}

// payments/gateway.h + payments/gateway.cpp
namespace payments::gateway {

    struct TransactionResult {
        bool approved;
        std::string transactionId;
        std::string message;
    };

    // This function lives in gateway but calls into validation — clean dependency.
    TransactionResult processPayment(const std::string& cardNumber, double amount) {
        // Cross-namespace call: fully qualified to make the dependency explicit
        if (!payments::validation::isAmountValid(amount)) {
            return {false, "", "Invalid amount: must be between 0 and 1,000,000"};
        }
        if (!payments::validation::isCardNumberLength(cardNumber)) {
            return {false, "", "Card number must be exactly 16 digits"};
        }

        // Simulate a successful transaction
        return {true, "TXN-20240517-001", "Payment approved"};
    }
}

int main() {
    // Using a namespace alias to avoid repeating 'payments::gateway' everywhere.
    // This is the CORRECT way to reduce verbosity without polluting the global scope.
    namespace gateway = payments::gateway;

    auto result = gateway::processPayment("4111111111111111", 99.99);

    std::cout << "Approved: " << (result.approved ? "Yes" : "No") << "\n";
    std::cout << "Transaction ID: " << result.transactionId << "\n";
    std::cout << "Message: " << result.message << "\n";

    std::cout << "\n--- Testing invalid inputs ---\n";

    auto badAmount = gateway::processPayment("4111111111111111", -50.0);
    std::cout << "Message: " << badAmount.message << "\n";

    auto badCard = gateway::processPayment("12345", 99.99);
    std::cout << "Message: " << badCard.message << "\n";

    return 0;
}

#include <iostream>
#include <string>
#include <cctype>

// --- Anonymous namespace: everything here is invisible outside this .cpp file ---
// Other translation units cannot link to these symbols, even if they know the names.
// This is the C++ way to say 'this is an implementation detail, keep out.'
namespace {

    // This helper struct is truly private to this file.
    // You cannot do this with the 'static' keyword — static doesn't apply to types.
    struct ParsedEmail {
        std::string localPart;   // the bit before '@'
        std::string domain;      // the bit after '@'
        bool isValid;
    };

    // Internal helper: not part of any public API
    ParsedEmail parseEmailAddress(const std::string& email) {
        auto atPosition = email.find('@');

        if (atPosition == std::string::npos || atPosition == 0) {
            return {"", "", false};
        }

        std::string local = email.substr(0, atPosition);
        std::string domain = email.substr(atPosition + 1);

        bool domainHasDot = domain.find('.') != std::string::npos;

        return {local, domain, !domain.empty() && domainHasDot};
    }

    // Another internal helper — also invisible outside this file
    std::string toLowercase(std::string input) {
        for (char& character : input) {
            character = static_cast<char>(std::tolower(character));
        }
        return input;
    }
}

// This IS the public function — no namespace, intended to be called from outside
bool isValidEmail(const std::string& rawEmail) {
    // Internally calls our private helpers from the anonymous namespace
    std::string normalised = toLowercase(rawEmail);
    ParsedEmail parsed = parseEmailAddress(normalised);

    if (!parsed.isValid) return false;

    // Additional rule: local part can't be empty
    return !parsed.localPart.empty();
}

int main() {
    // These calls go through the public 'isValidEmail' function.
    // parseEmailAddress and toLowercase are completely inaccessible from here.
    std::cout << std::boolalpha;  // print 'true'/'false' instead of 1/0

    std::cout << "USER@EXAMPLE.COM is valid: " << isValidEmail("USER@EXAMPLE.COM") << "\n";
    std::cout << "notanemail is valid:        " << isValidEmail("notanemail") << "\n";
    std::cout << "@nodomain.com is valid:     " << isValidEmail("@nodomain.com") << "\n";
    std::cout << "hi@there.io is valid:       " << isValidEmail("hi@there.io") << "\n";

    return 0;
}