#include <iostream>
#include <string>

struct Student
{
    std::string name;
    int         age;
    double      gpa;
};

// Функція отримує КОПІЮ студента
void celebrateBirthday(Student s)
{
    s.age += 1; // змінюємо копію — оригінал не зачіпаємо

    std::cout << "Вітаємо " << s.name
              << " з " << s.age << "-річчям!\n";
}

int main()
{
    Student student = { "Олена Коваль", 20, 3.9 };

    celebrateBirthday(student); // передаємо копію

    // Оригінал не змінився
    std::cout << "Вік у main(): " << student.age << "\n";

    return 0;
}

#include <iostream>
#include <string>

struct Student
{
    std::string name;
    int         age;
    double      gpa;
};

// Жодного копіювання. const гарантує незмінність оригіналу.
void printStudent(const Student& s)
{
    std::cout << s.name << ", " << s.age << " р., GPA: " << s.gpa << "\n";
    // s.age = 99; // ← помилка компіляції: const не дозволяє запис
}

double calcBonus(const Student& s)
{
    if (s.gpa >= 3.5)
        return s.gpa * 1000.0; // відмінник — підвищена стипендія

    return s.gpa * 500.0;
}

int main()
{
    Student student = { "Олена Коваль", 20, 3.9 };

    printStudent(student);

    std::cout << "Стипендія: " << calcBonus(student) << " грн\n";

    return 0;
}

#include <iostream>
#include <string>

struct Student
{
    std::string name;
    int         age;
    double      gpa;
};

// Функція-мутатор: явно змінює оригінал
void applyScholarship(Student& s, double bonus)
{
    s.gpa = std::min(s.gpa + bonus * 0.1, 4.0); // максимум 4.0
}

void birthday(Student& s)
{
    s.age += 1;
}

int main()
{
    Student student = { "Максим Дяченко", 21, 3.2 };

    std::cout << "До: GPA = " << student.gpa << "\n";
    applyScholarship(student, 5.0); // scholarship bonus = 5
    std::cout << "Після: GPA = " << student.gpa << "\n";

    birthday(student);
    std::cout << "Вік: " << student.age << "\n";

    return 0;
}

#include <iostream>
#include <string>

struct Student
{
    std::string name;
    int         age;
    double      gpa;
};

// Повертає nullptr якщо студент з таким ім'ям не знайдений
Student* findByName(Student* arr, int size, const std::string& name)
{
    for (int i = 0; i < size; ++i)
    {
        if (arr[i].name == name)
            return &arr[i]; // адреса знайденого студента
    }
    return nullptr; // не знайдено
}

int main()
{
    Student group[3] =
    {
        { "Олена Коваль",   20, 3.9 },
        { "Максим Дяченко", 22, 3.4 },
        { "Тетяна Бондар",  21, 3.7 },
    };

    Student* found = findByName(group, 3, "Максим Дяченко");

    if (found != nullptr)
        std::cout << "Знайдено: " << found->name << ", GPA: " << found->gpa << "\n";
    else
        std::cout << "Студента не знайдено.\n";

    // Пошук неіснуючого студента
    Student* notFound = findByName(group, 3, "Іван Петренко");

    if (notFound != nullptr)
        std::cout << "Знайдено: " << notFound->name << "\n";
    else
        std::cout << "Студента не знайдено.\n";

    return 0;
}

#include <iostream>
#include <string>

struct Student
{
    std::string name;
    int         age;
    double      gpa;
};

// Функція повертає нову структуру за значенням
Student createStudent(const std::string& name, int age, double gpa)
{
    Student s;
    s.name = name;
    s.age  = age;
    s.gpa  = gpa;
    return s; // повертаємо об'єкт — компілятор оптимізує
}

int main()
{
    Student s1 = createStudent("Олена Коваль", 20, 3.9);
    Student s2 = createStudent("Максим Дяченко", 22, 3.4);

    std::cout << s1.name << " | GPA: " << s1.gpa << "\n";
    std::cout << s2.name << " | GPA: " << s2.gpa << "\n";

    return 0;
}

#include <iostream>
#include <string>

struct Student
{
    std::string name;
    int         age;
    double      gpa;
};

// Фабрична функція: перевіряє і конструює
bool createStudent(const std::string& name, int age, double gpa, Student& out)
{
    if (name.empty())
    {
        std::cout << "Помилка: ім'я не може бути порожнім\n";
        return false;
    }

    if (age < 16 || age > 100)
    {
        std::cout << "Помилка: некоректний вік " << age << "\n";
        return false;
    }

    if (gpa < 0.0 || gpa > 4.0)
    {
        std::cout << "Помилка: GPA поза діапазоном [0.0, 4.0]\n";
        return false;
    }

    out = { name, age, gpa };
    return true;
}

void printStudent(const Student& s)
{
    std::cout << s.name << ", вік " << s.age << ", GPA: " << s.gpa << "\n";
}

int main()
{
    Student s;

    if (createStudent("Олена Коваль", 20, 3.9, s))
        printStudent(s);

    if (!createStudent("", 20, 3.9, s))
        std::cout << "Студента не створено.\n";

    if (!createStudent("Іван", 15, 3.0, s))
        std::cout << "Студента не створено.\n";

    return 0;
}

#include <iostream>
#include <cmath>

struct Point3D
{
    double x;
    double y;
    double z;
};

// Трансформація: повертає нову точку
Point3D translate(const Point3D& p, double dx, double dy, double dz)
{
    return { p.x + dx, p.y + dy, p.z + dz };
}

Point3D scale(const Point3D& p, double factor)
{
    return { p.x * factor, p.y * factor, p.z * factor };
}

double distanceTo(const Point3D& a, const Point3D& b)
{
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    double dz = a.z - b.z;
    return std::sqrt(dx*dx + dy*dy + dz*dz);
}

void print(const Point3D& p)
{
    std::cout << "(" << p.x << ", " << p.y << ", " << p.z << ")\n";
}

int main()
{
    Point3D origin = { 0.0, 0.0, 0.0 };
    Point3D p      = { 1.0, 2.0, 3.0 };

    Point3D moved  = translate(p, 5.0, 0.0, -1.0);
    Point3D scaled = scale(p, 2.0);

    std::cout << "Оригінал: ";   print(p);
    std::cout << "Зміщена:  ";   print(moved);
    std::cout << "Збільшена: ";  print(scaled);
    std::cout << "Відстань від origin до moved: "
              << distanceTo(origin, moved) << "\n";

    return 0;
}