How Constructors Work in C++

class Widget {
    int id_;
    std::string name_;
public:
    // Compiler-generated default constructor: id_ is indeterminate (!),
    // name_ is default-constructed to "".
    // We explicitly default it to document intent:
    Widget() = default;

    // Because we declared the constructor above, this parameterized
    // constructor doesn't suppress the default one.
    Widget(int id, std::string name) : id_(id), name_(std::move(name)) {}

    int id() const { return id_; }
    const std::string& name() const { return name_; }
};

class Connection {
    const int id_;               // const: must use init list
    std::string host_;
    int port_;
    std::string connection_string_;  // depends on host_ and port_

public:
    // Members are initialized in declaration order: id_, host_, port_,
    // connection_string_. The init list below happens to match, but even
    // if we reordered it, the actual initialization would follow the
    // class declaration order.
    Connection(int id, std::string host, int port)
        : id_(id),
          host_(std::move(host)),
          port_(port),
          connection_string_(std::format("{}:{}", host_, port_))  // safe: host_ and port_ already initialized
    {
        // By this point, ALL members are fully initialized.
        std::cout << std::format("  Connection {} to {} created\n",
                                  id_, connection_string_);
    }

    // BAD ORDER EXAMPLE (commented out):
    // If connection_string_ were declared BEFORE host_ and port_,
    // this init list would read uninitialized members — UB!
    // The compiler would warn with -Wreorder.

    const std::string& connection_string() const { return connection_string_; }
};

class Config {
    // Default member initializers — safe, readable, no boilerplate
    int timeout_ms_ = 5000;
    int max_retries_ = 3;
    bool verbose_ = false;
    std::string endpoint_ = "localhost";

public:
    // Uses ALL defaults — zero boilerplate
    Config() = default;

    // Overrides only the endpoint; other members use their defaults
    explicit Config(std::string endpoint)
        : endpoint_(std::move(endpoint)) {}

    // Overrides everything
    Config(int timeout, int retries, bool verbose, std::string endpoint)
        : timeout_ms_(timeout),
          max_retries_(retries),
          verbose_(verbose),
          endpoint_(std::move(endpoint)) {}

    void print() const {
        std::cout << std::format("  timeout={}ms retries={} verbose={} endpoint={}\n",
                                  timeout_ms_, max_retries_, verbose_, endpoint_);
    }
};

class Logger {
    std::string prefix_;
    bool enabled_;
    int level_;

public:
    // "Real" constructor — does all the work
    Logger(std::string prefix, bool enabled, int level)
        : prefix_(std::move(prefix)), enabled_(enabled), level_(level) {
        std::cout << std::format("  Logger created: prefix='{}' enabled={} level={}\n",
                                  prefix_, enabled_, level_);
    }

    // Delegating: provide defaults for enabled and level
    explicit Logger(std::string prefix)
        : Logger(std::move(prefix), true, 1) {}  // delegates to the 3-arg ctor

    // Delegating: full default
    Logger() : Logger("DEFAULT") {}  // delegates to the 1-arg, which delegates to the 3-arg

    const std::string& prefix() const { return prefix_; }
};

class Meters {
    double value_;
public:
    // explicit: prevents "Meters m = 5.0;" and passing a raw double
    // where a Meters is expected
    explicit Meters(double v) : value_(v) {}

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

class Feet {
    double value_;
public:
    explicit Feet(double v) : value_(v) {}
    double value() const { return value_; }
};

// This function requires the caller to be explicit about units
void print_distance(Meters m) {
    std::cout << std::format("  Distance: {:.2f} meters\n", m.value());
}

class Temperature {
    double celsius_;
public:
    explicit Temperature(double c) : celsius_(c) {}
    double celsius() const { return celsius_; }
    double fahrenheit() const { return celsius_ * 9.0 / 5.0 + 32.0; }
};

class Singleton {
public:
    Singleton(const Singleton&) = delete;             // no copying
    Singleton& operator=(const Singleton&) = delete;  // no copy-assignment

    static Singleton& instance() {
        static Singleton s;  // thread-safe since C++11 (magic statics)
        return s;
    }

    void greet() const { std::cout << "  Singleton instance\n"; }

private:
    Singleton() = default;  // only instance() can create one
};

// Prevent calling with bool (would silently convert to int)
class StrictInt {
    int value_;
public:
    explicit StrictInt(int v) : value_(v) {}
    StrictInt(bool) = delete;  // calling StrictInt(true) is now a compile error
    int value() const { return value_; }
};