Списки ініціалізації та делегуючі конструктори

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    Fraction(int num = 0, int den = 1)
    {
        // Присвоєння значень після створення полів
        numerator = num;
        denominator = (den != 0) ? den : 1;
    }
};

ClassName(параметри) : поле1(значення1), поле2(значення2), поле3(значення3)
{
    // Тіло конструктора (опціонально)
}

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    // Використовуємо список ініціалізації після двокрапки
    Fraction(int num = 0, int den = 1) : numerator(num), denominator((den != 0) ? den : 1)
    {
        // Тіло конструктора порожнє — ініціалізація вже відбулася!
    }

    int getNumerator() const { return numerator; }
    int getDenominator() const { return denominator; }
    
    double getValue() const 
    {
        return static_cast<double>(numerator) / denominator;
    }
};

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    // Uniform initialization — фігурні дужки замість круглих
    Fraction(int num = 0, int den = 1) : numerator{num}, denominator{(den != 0) ? den : 1}
    {
    }
};

class Student
{
private:
    const int id;        // Унікальний ID студента — не змінюється після створення
    string name;

public:
    // ✅ Правильно — ініціалізація через MIL
    Student(int studentId, string studentName) : id(studentId), name(studentName)
    {
    }

    int getId() const { return id; }
    string getName() const { return name; }
};

int main()
{
    Student alice(12345, "Alice");
    cout << alice.getId() << ": " << alice.getName() << "\n";
    
    // alice.id = 67890;  // ❌ Помилка — id константний
    
    return 0;
}

class Wrapper
{
private:
    int& reference;      // Посилання на зовнішню змінну

public:
    // ✅ Правильно — ініціалізація через MIL
    Wrapper(int& value) : reference(value)
    {
    }

    void print() const 
    {
        cout << "Referenced value: " << reference << "\n";
    }

    void modify(int newValue)
    {
        reference = newValue;  // Змінюємо значення за посиланням
    }
};

int main()
{
    int x = 10;
    Wrapper wrapper(x);
    
    wrapper.print();        // Вивід: 10
    wrapper.modify(20);
    
    cout << "x = " << x << "\n";  // Вивід: x = 20 — змінили через посилання!
    
    return 0;
}

class Engine
{
private:
    int horsepower;

public:
    // Немає конструктора за замовчуванням!
    Engine(int hp) : horsepower(hp)
    {
        cout << "Engine created: " << hp << " HP\n";
    }

    int getHorsepower() const { return horsepower; }
};

class Car
{
private:
    Engine engine;       // Поле-об'єкт класу Engine
    string model;

public:
    // ✅ Правильно — викликаємо конструктор Engine через MIL
    Car(string carModel, int enginePower) : engine(enginePower), model(carModel)
    {
        cout << "Car created: " << model << "\n";
    }

    void printInfo() const
    {
        cout << model << " with " << engine.getHorsepower() << " HP\n";
    }
};

int main()
{
    Car myCar("Toyota", 150);
    myCar.printInfo();
    
    return 0;
}

class ArrayHolder
{
private:
    int arr[5];

public:
    // До C++11 — тільки обнулення
    ArrayHolder() : arr{}
    {
        // Масив містить {0, 0, 0, 0, 0}
        // Якщо потрібні інші значення — присвоювання в тілі
    }
};

class ArrayHolder
{
private:
    int arr[5];

public:
    // C++11 — повна ініціалізація масиву
    ArrayHolder() : arr{10, 20, 30, 40, 50}
    {
        // Масив містить {10, 20, 30, 40, 50}
    }

    void print() const
    {
        for (int i = 0; i < 5; i++) {
            cout << arr[i] << " ";
        }
        cout << "\n";
    }
};

int main()
{
    ArrayHolder holder;
    holder.print();  // Вивід: 10 20 30 40 50
    
    return 0;
}

class Dangerous
{
private:
    int first;
    int second;

public:
    // ⚠️ Увага! Порядок у списку ініціалізації: second, потім first
    Dangerous(int value) : second(value), first(second * 2)
    {
    }

    void print() const
    {
        cout << "first = " << first << ", second = " << second << "\n";
    }
};

int main()
{
    Dangerous obj(5);
    obj.print();  // Очікуємо: first = 10, second = 5
                  // Отримуємо: first = ??? (невизначене значення!), second = 5
    
    return 0;
}

class Point
{
private:
    int x = 0;        // Значення за замовчуванням для x
    int y = 0;        // Значення за замовчуванням для y
    string label{"Origin"};  // Можна використовувати {}

public:
    // Конструктор за замовчуванням — поля вже мають значення
    Point()
    {
        // x = 0, y = 0, label = "Origin" автоматично
    }

    // Параметризований конструктор
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord)
    {
        // x і y отримують нові значення через MIL
        // label залишається "Origin" (значення за замовчуванням)
    }

    void print() const
    {
        cout << label << ": (" << x << ", " << y << ")\n";
    }
};

int main()
{
    Point origin;            // x = 0, y = 0, label = "Origin"
    Point custom(10, 20);    // x = 10, y = 20, label = "Origin"
    
    origin.print();   // Origin: (0, 0)
    custom.print();   // Origin: (10, 20)
    
    return 0;
}

class Counter
{
private:
    int count = 100;     // NSMI — значення за замовчуванням

public:
    Counter()
    {
        // count = 100 (NSMI)
    }

    Counter(int initialCount) : count(initialCount)
    {
        // count = initialCount (MIL перевизначає NSMI)
    }
};

int main()
{
    Counter c1;       // count = 100 (NSMI)
    Counter c2(50);   // count = 50 (MIL)
    
    return 0;
}

class Rectangle
{
private:
    int width;
    int height;
    string color;

public:
    // Конструктор з трьома параметрами
    Rectangle(int w, int h, string c) : width(w), height(h), color(c)
    {
        // Складна валідація
        if (width <= 0) width = 1;
        if (height <= 0) height = 1;
        cout << "Rectangle created: " << width << "x" << height << " (" << color << ")\n";
    }

    // Конструктор з двома параметрами — дублювання логіки!
    Rectangle(int w, int h) : width(w), height(h), color("Black")
    {
        // ❌ Потрібно продублювати валідацію
        if (width <= 0) width = 1;
        if (height <= 0) height = 1;
        cout << "Rectangle created: " << width << "x" << height << " (" << color << ")\n";
    }

    // Конструктор за замовчуванням — ще більше дублювання!
    Rectangle() : width(1), height(1), color("Black")
    {
        // ❌ Знову дублювання
        cout << "Rectangle created: " << width << "x" << height << " (" << color << ")\n";
    }
};

class Rectangle
{
private:
    int width;
    int height;
    string color;

public:
    // Головний конструктор — вся логіка тут
    Rectangle(int w, int h, string c) : width(w), height(h), color(c)
    {
        // Валідація та додаткова логіка в одному місці
        if (width <= 0) width = 1;
        if (height <= 0) height = 1;
        cout << "Rectangle created: " << width << "x" << height << " (" << color << ")\n";
    }

    // Делегуючий конструктор — викликає головний
    Rectangle(int w, int h) : Rectangle(w, h, "Black")
    {
        // Тіло порожнє — вся робота делегована головному конструктору
    }

    // Ще один делегуючий конструктор
    Rectangle() : Rectangle(1, 1, "Black")
    {
        // Також делегує головному конструктору
    }

    int getWidth() const { return width; }
    int getHeight() const { return height; }
    string getColor() const { return color; }
};

int main()
{
    Rectangle rect1;                 // Викликає Rectangle() → Rectangle(1, 1, "Black")
    Rectangle rect2(10, 20);         // Викликає Rectangle(10, 20) → Rectangle(10, 20, "Black")
    Rectangle rect3(5, 8, "Red");    // Викликає Rectangle(5, 8, "Red") напряму
    
    return 0;
}

ClassName(параметри) : ClassName(інші_параметри)
{
    // Опціональне тіло
}

class Person
{
private:
    string firstName;
    string lastName;
    int age;

public:
    // Головний конструктор
    Person(string first, string last, int personAge) 
        : firstName(first), lastName(last), age(personAge)
    {
        cout << "Full constructor: " << firstName << " " << lastName << ", " << age << "\n";
    }

    // Делегує головному з age = 0
    Person(string first, string last) : Person(first, last, 0)
    {
    }

    // Делегує попередньому (який делегує головному) — ланцюжок!
    Person(string first) : Person(first, "Unknown")
    {
    }
};

int main()
{
    Person p1("Alice", "Smith", 30);  // Викликає головний
    Person p2("Bob", "Jones");        // Bob, Jones → Bob, Jones, 0
    Person p3("Charlie");             // Charlie → Charlie, Unknown → Charlie, Unknown, 0
    
    return 0;
}