مساحات الأسماء، الرؤوس و ODR

#include <iostream>

// Defining a namespace
namespace math {
    double pi = 3.14159265358979323846;

    double area_of_circle(double radius) {
        return pi * radius * radius;
    }

    // Nested namespace (C++17 shorthand)
    namespace geometry {
        struct Point { double x, y; };
    }
}

// C++17 nested namespace shorthand — equivalent to above
namespace math::geometry {
    double distance(Point a, Point b) {
        double dx = a.x - b.x;
        double dy = a.y - b.y;
        return std::sqrt(dx * dx + dy * dy);
    }
}

// Anonymous namespace — internal linkage (visible only in this file)
namespace {
    int internal_counter = 0;      // Like 'static' at file scope, but works for types too
}

int main() {
    // Fully qualified name
    std::cout << math::pi << '\n';

    // using declaration — imports one name
    using math::area_of_circle;
    std::cout << area_of_circle(5.0) << '\n';

    // using directive — imports ALL names (avoid in headers!)
    using namespace math::geometry;
    Point p1{0, 0}, p2{3, 4};

    // NEVER put 'using namespace std;' in a header file
    // It pollutes the global namespace for every file that includes the header
}

// === math_utils.hpp ===
#pragma once                          // Include guard (non-standard but universal)
// Alternative: #ifndef MATH_UTILS_HPP / #define MATH_UTILS_HPP / ... / #endif

#include <cmath>
#include <cstdint>

namespace math_utils {

// Declarations — OK in headers (not definitions of non-inline entities)
double hypotenuse(double a, double b);          // Function declaration
extern int precision;                            // Variable declaration (extern!)

// Definitions OK in headers — templates and inline
template <typename T>
T clamp(T value, T low, T high) {               // Template: implicitly inline
    return (value < low) ? low : (value > high) ? high : value;
}

inline double degrees_to_radians(double deg) {   // Inline: ODR-safe in header
    return deg * 3.14159265358979323846 / 180.0;
}

constexpr std::int32_t max_iterations = 1000;    // constexpr: implicitly inline (C++17)

// Class definition — OK in headers (must be identical in all TUs)
struct Vec2 {
    double x, y;
    double length() const { return std::sqrt(x * x + y * y); }  // Implicitly inline
};

}  // namespace math_utils


// === math_utils.cpp ===
// #include "math_utils.hpp"
//
// namespace math_utils {
//
// // Definitions — exactly ONE .cpp file provides these
// double hypotenuse(double a, double b) {
//     return std::sqrt(a * a + b * b);
// }
//
// int precision = 6;   // Definition of the extern variable
//
// }  // namespace math_utils