C++ Namespaces — Global Namespace Collision Linker Errors

#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 {\n    std::string greet(const std::string& name) {\n        return \"Hello, \" + name + \"!\";\n    }\n}\n\nnamespace spanish {\n    std::string greet(const std::string& name) {\n        return \"Hola, \" + name + \"!\";\n    }\n}\n\nint main() {\n    std::string visitorName = \"Maria\";\n\n    // Scope resolution tells the compiler exactly which 'greet' to call.\n    // Remove the namespace prefix and the compiler will complain about ambiguity.\n    std::cout << english::greet(visitorName) << \"\\n\";  // calls english version\n    std::cout << spanish::greet(visitorName) << \"\\n\";  // calls spanish version\n\n    return 0;\n}",
        "output": "Hello, Maria!\nHola, Maria!"
      }

#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;
}

// --- Example: Using namespace std (DANGEROUS) ---
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;  // Dumps everything

int count(vector<int>& v) {  // Oops: collides with std::count
    int sum = 0;
    for (int x : v) sum += x;
    return sum;
}

int main() {
    vector<int> data = {1,2,3};
    cout << count(data) << endl;     // Which count? Compiler error!
    return 0;
}

// --- Example: Targeted using declarations (SAFE) ---
#include <iostream>
#include <vector>
#include <algorithm>

using std::cout;
using std::endl;
using std::vector;

int sumElements(const vector<int>& v) {  // No ambiguity
    int total = 0;
    for (int x : v) total += x;
    return total;
}

int main() {
    vector<int> data = {1,2,3};
    auto howMany = std::count(data.begin(), data.end(), 2);  // explicit std::
    cout << "Sum: " << sumElements(data) << endl;
    return 0;
}

#include <iostream>
#include <string>

namespace mylib {
    void output(const std::string& msg) {
        std::cout << "[mylib] " << msg << std::endl;
    }
}

// Using-declaration: brings only mylib::output into scope
using mylib::output;

// Using-directive: brings everything from mylib into scope (commented out for safety)
// using namespace mylib;

int main() {
    // Fully qualified: explicit, always safe
    mylib::output("Fully qualified call");

    // Using-declaration: works because we explicitly imported output
    output("Using-declaration call");

    // Attempting to call an unimported name without qualification would fail
    // output2("test");  // error if not in scope

    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) {\n        // Cross-namespace call: fully qualified to make the dependency explicit\n        if (!payments::validation::isAmountValid(amount)) {\n            return {false, \"\", \"Invalid amount: must be between 0 and 1,000,000\"};\n        }\n        if (!payments::validation::isCardNumberLength(cardNumber)) {\n            return {false, \"\", \"Card number must be exactly 16 digits\"};\n        }\n\n        // Simulate a successful transaction\n        return {true, \"TXN-20240517-001\", \"Payment approved\"};\n    }\n}\n\nint main() {\n    // Using a namespace alias to avoid repeating 'payments::gateway' everywhere.\n    // This is the CORRECT way to reduce verbosity without polluting the global scope.\n    namespace gateway = payments::gateway;\n\n    auto result = gateway::processPayment(\"4111111111111111\", 99.99);\n\n    std::cout << \"Approved: \" << (result.approved ? \"Yes\" : \"No\") << \"\\n\";\n    std::cout << \"Transaction ID: \" << result.transactionId << \"\\n\";\n    std::cout << \"Message: \" << result.message << \"\\n\";\n\n    std::cout << \"\\n--- Testing invalid inputs ---\\n\";\n\n    auto badAmount = gateway::processPayment(\"4111111111111111\", -50.0);\n    std::cout << \"Message: \" << badAmount.message << \"\\n\";\n\n    auto badCard = gateway::processPayment(\"12345\", 99.99);\n    std::cout << \"Message: \" << badCard.message << \"\\n\";\n\n    return 0;\n}",
        "output": "Approved: Yes\nTransaction ID: TXN-20240517-001\nMessage: Payment approved\n\n--- Testing invalid inputs ---\nMessage: Invalid amount: must be between 0 and 1,000,000\nMessage: Card number must be exactly 16 digits"
      }

#include <iostream>
#include <string>

// Deeply nested namespace from a hypothetical library
namespace org::thecodeforge::payments::gateway {
    void process(const std::string& transaction) {
        std::cout << "Processing: " << transaction << std::endl;
    }
}

// Another nested namespace for reporting
namespace org::thecodeforge::payments::reporting {
    void generateReport(const std::string& date) {
        std::cout << "Report for " << date << std::endl;
    }
}

int main() {
    // Without alias: painful verbosity
    org::thecodeforge::payments::gateway::process("TXN-001");

    // With alias: clean and readable
    namespace gw = org::thecodeforge::payments::gateway;
    namespace rpt = org::thecodeforge::payments::reporting;

    gw::process("TXN-002");
    rpt::generateReport("2026-05-12");

    // Alias is local to main(); other functions in this file don't see it.
    return 0;
}

// --- database.h (Header) ---
#ifndef DATABASE_H
#define DATABASE_H

#include <string>

namespace app::database {

    // Forward declarations (public API)
    bool connect(const std::string& connectionString);
    void disconnect();
    int executeQuery(const std::string& sql);

} // namespace app::database

#endif

// --- database.cpp (Source) ---
#include "database.h"
#include <iostream>

// Open the same namespace
namespace app::database {

    bool connect(const std::string& connectionString) {
        std::cout << "Connecting to: " << connectionString << std::endl;
        return true; // simplified
    }

    void disconnect() {
        std::cout << "Disconnected." << std::endl;
    }

    int executeQuery(const std::string& sql) {
        std::cout << "Executing: " << sql << std::endl;
        return 42; // dummy row count
    }

} // namespace app::database

// --- main.cpp (Consumer) ---
#include "database.h"

int main() {
    app::database::connect("server=tcp:prod.database.com");
    int rows = app::database::executeQuery("SELECT * FROM users");
    app::database::disconnect();
    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;
}

#include <iostream>

// Library mylib: versioning with inline namespace
namespace mylib {

    // v1 is the old version, still available for explicit use
    namespace v1 {\n        void configure(int timeout) {\n            std::cout << \"v1 configure with \" << timeout << \"s\\n\";\n        }\n    }\n\n    // v2 is the new version, marked inline -> becomes default\n    inline namespace v2 {\n        void configure(int timeout, bool retry = true) {\n            std::cout << \"v2 configure with \" << timeout << \"s, retry=\" << retry << \"\\n\";\n        }\n    }\n}\n\nint main() {\n    // Unqualified call uses v2 (inline)\n    mylib::configure(30);                // prints v2 version\n\n    // Explicit old-version call still works\n    mylib::v1::configure(30);            // prints v1 version\n\n    return 0;\n}",
        "output": "v2 configure with 30s, retry=1\nv1 configure with 30s"
      }

#include <iostream>
#include <string>

namespace io::thecodeforge {
    struct MyFile {
        int fd;
    };

    // This function should be found by ADL when the argument is MyFile
    void write(const MyFile& f, const std::string& data) {\n        std::cout << \"Writing: \" << data << \" to fd \" << f.fd << \"\\n\";\n    }\n}\n\n// A global 'write' that could interfere (simulate POSIX-like)\nvoid write(const char*, size_t) {\n    std::cout << \"Pretend POSIX write called\\n\";\n}\n\nint main() {\n    io::thecodeforge::MyFile file{42};\n\n    // This call uses ADL: the compiler finds io::thecodeforge::write\n    // because the argument is in that namespace. It does NOT call the global write.\n    write(file, \"hello world\");\n\n    // If you want to be explicit (and avoid any confusion):\n    io::thecodeforge::write(file, \"explicit call\");\n\n    return 0;\n}",
        "output": "Writing: hello world to fd 42\nWriting: explicit call to fd 42"
      }

#include <iostream>
#include <string>

namespace format {
    void print(const std::string& s) {
        std::cout << "[format] " << s << std::endl;
    }
}

namespace debug {
    void print(const std::string& s) {
        std::cout << "[debug] " << s << std::endl;
    }

    void print(int x) {
        std::cout << "[debug] int: " << x << std::endl;
    }
}

// Bring both print(int) and print(const string&) from debug into scope
using debug::print;

int main() {
    // Qualified calls select exactly which overload
    format::print("Hello from format");
    debug::print("Hello from debug");

    // Unqualified: the compiler finds the best match among visible overloads
    print(42);              // calls debug::print(int)
    print("unqualified");  // calls debug::print(const string&) 

    // If we also had `using format::print;` here, the call print("test") would be ambiguous
    return 0;
}

// Example solution for Exercise 1
namespace liba {
    void start() { /* ... */ }
}

// libb is used as is
void start() { /* ... */ }  // global

int main() {
    liba::start();
    ::start();  // global version
    return 0;
}

// Example solution for Exercise 2
namespace very::long::nested::module {
    void execute() { /* ... */ }
}

int main() {
    namespace ns = very::long::nested::module;
    ns::execute();
    return 0;
}

// Exercise 3: anonymous namespace
namespace {
    int square(int x) { return x * x; }
    struct Point { int x, y; };
}

int computeDistance() {
    Point p{3,4};
    return square(p.x) + square(p.y);  // 25
}

// Exercise 4: calc.h / calc.cpp split
// File calc.h
#ifndef CALC_H
#define CALC_H
namespace math::operations {
    int add(int a, int b);
    double multiply(double a, double b);
}
#endif
// File calc.cpp
#include "calc.h"
namespace math::operations {
    int add(int a, int b) { return a + b; }
    double multiply(double a, double b) { return a * b; }
}

// Exercise 5: overloading across namespaces
namespace first { void show(int) { /* ... */ } }
namespace second { void show(const std::string&) { /* ... */ } }
using first::show;
using second::show;
int main() {
    show(5);      // calls first::show
    show("hi");   // calls second::show
    return 0;
}