Inheriting, Converting, Aggregate, and constexpr Constructors

class Animal {
protected:
    std::string name_;
    int age_;
public:
    Animal(std::string name, int age)
        : name_(std::move(name)), age_(age) {}

    Animal(std::string name)
        : name_(std::move(name)), age_(0) {}

    void info() const {
        std::cout << std::format("  {}, age {}", name_, age_);
    }
};

class Dog : public Animal {
    std::string breed_ = "Unknown";  // default member initializer — safe!
public:
    using Animal::Animal;  // inherit ALL constructors from Animal

    // Add a constructor that also takes breed
    Dog(std::string name, int age, std::string breed)
        : Animal(std::move(name), age), breed_(std::move(breed)) {}

    void info() const {
        Animal::info();
        std::cout << std::format(", breed: {}\n", breed_);
    }
};

class IntList {
    std::vector<int> data_;
    std::string label_;

public:
    // Regular constructor: create n copies of value
    IntList(std::size_t count, int value, std::string label = "list")
        : data_(count, value), label_(std::move(label)) {}

    // Initializer list constructor: accept {1, 2, 3, ...}
    IntList(std::initializer_list<int> init, std::string label = "list")
        : data_(init), label_(std::move(label))
    {
        std::cout << std::format("  initializer_list ctor called with {} elements\n",
                                  init.size());
    }

    void print() const {
        std::cout << std::format("  [{}]: ", label_);
        for (int n : data_) std::cout << n << ' ';
        std::cout << std::format("(size={})\n", data_.size());
    }
};

struct Point3D {
    double x;
    double y;
    double z;
    // No constructors — this is an aggregate

    double magnitude() const {
        return std::sqrt(x * x + y * y + z * z);
    }
};

struct Color {
    uint8_t r = 0;
    uint8_t g = 0;
    uint8_t b = 0;
    uint8_t a = 255;  // default alpha: fully opaque
    // Aggregate with default member initializers
};

struct ServerConfig {
    std::string host = "localhost";
    int port = 8080;
    int max_connections = 100;
    bool tls_enabled = false;
    int timeout_ms = 30000;
};

class Kilometers {
    double value_;
public:
    // NOT explicit — allows implicit conversion from double
    Kilometers(double v) : value_(v) {}
    double value() const { return value_; }
};

class Miles {
    double value_;
public:
    // explicit — prevents accidental implicit conversion
    explicit Miles(double v) : value_(v) {}
    double value() const { return value_; }
};

void log_distance_km(Kilometers km) {
    std::cout << std::format("  Distance: {:.2f} km\n", km.value());
}

void log_distance_mi(Miles mi) {
    std::cout << std::format("  Distance: {:.2f} mi\n", mi.value());
}

class Vec2 {
    double x_, y_;
public:
    constexpr Vec2() : x_(0.0), y_(0.0) {}
    constexpr Vec2(double x, double y) : x_(x), y_(y) {}

    constexpr Vec2 operator+(const Vec2& other) const {
        return {x_ + other.x_, y_ + other.y_};
    }

    constexpr Vec2 operator*(double scalar) const {
        return {x_ * scalar, y_ * scalar};
    }

    constexpr double dot(const Vec2& other) const {
        return x_ * other.x_ + y_ * other.y_;
    }

    constexpr double magnitude_squared() const {
        return x_ * x_ + y_ * y_;
    }

    constexpr double x() const { return x_; }
    constexpr double y() const { return y_; }
};

// Compile-time lookup table built using constexpr constructor
constexpr auto build_unit_vectors() {
    std::array<Vec2, 8> dirs{};
    for (int i = 0; i < 8; ++i) {
        double angle = i * 3.14159265358979 / 4.0;
        // Note: std::cos/sin are not constexpr in C++20 standard,
        // so we use a simple approximation for demonstration
        dirs[i] = Vec2(
            (i == 0 || i == 7 || i == 1) ? 1.0 :
            (i == 3 || i == 4 || i == 5) ? -1.0 : 0.0,
            (i == 1 || i == 2 || i == 3) ? 1.0 :
            (i == 5 || i == 6 || i == 7) ? -1.0 : 0.0
        );
    }
    return dirs;
}

constexpr auto unit_directions = build_unit_vectors();

class Percentage {
    double value_;  // 0.0 to 100.0
public:
    explicit Percentage(double v) : value_(v) {}

    // Explicit conversion to double — requires static_cast or if()
    explicit operator double() const { return value_ / 100.0; }

    // Explicit conversion to bool — allows if(pct) but not int x = pct
    explicit operator bool() const { return value_ > 0.0; }

    double value() const { return value_; }
};