Here are some programming exercises based on Aggregation in Object-Oriented Programming (OOP).

Aggregation represents a "has-a" relationship, where one object can contain or reference other objects,
but the contained objects can exist independently of the containing object.

Exercise 1: School and Student (Aggregation)

Objective:
Create a School class that aggregates Student objects. Each student is associated with a school, but can
exist independently from the school (i.e., a student can belong to multiple schools or exist without a
school).

Solution:

#include <iostream>

#include <vector>

using namespace std;

// Student class

class Student {

private:

string name;

public:

// Constructor to initialize student's name

Student(string n) : name(n) {}

// Method to get the student's name

string getName() const {

return name;

};

// School class (aggregates multiple Students)

private:

vector<Student*> students; // School "has many" Students (Aggregation)

public:

// Method to add a student to the school

void addStudent(Student* student) {

students.push_back(student);

// Method to display all students in the school

void displayStudents() const {

if ([Link]()) {

cout << "No students in the school." << endl;

return;

cout << "Students in the school:" << endl;

for (const auto& student : students) {

cout << student->getName() << endl;

};

int main() {

// Create some Student objects

Student student1("John Doe");

Student student2("Jane Smith");

Student student3("Sam Brown");

School school;

// Add students to the school

[Link](&student1);

[Link](&student2);

[Link](&student3);

// Display all students in the school

[Link]();

return 0;

Exercise 2: Library and Books (Aggregation)

Objective:
Create a Library class that aggregates Book objects. A library "has many" books, but books can exist
independently of the library.

Solution:

#include <iostream>

#include <vector>

using namespace std;

// Book class

class Book {

private:

string title;

public:
 // Constructor to initialize book title

Book(string t) : title(t) {}

// Method to get the book's title

string getTitle() const {

return title;

};

// Library class (aggregates multiple Books)

class Library {

private:

vector<Book*> books; // Library "has many" Books (Aggregation)

public:

// Method to add a book to the library

void addBook(Book* book) {

books.push_back(book);

// Method to display all books in the library

void displayBooks() const {

if ([Link]()) {

cout << "No books in the library." << endl;

return;

cout << "Books in the library:" << endl;

for (const auto& book : books) {

cout << book->getTitle() << endl;

};

int main() {

// Create some Book objects

Book book1("The Catcher in the Rye");

Book book2("To Kill a Mockingbird");

Book book3("1984");

// Create a Library object

Library library;

// Add books to the library

[Link](&book1);

[Link](&book2);

[Link](&book3);

// Display all books in the library

[Link]();

return 0;

Exercise 3: Department and Employee (Aggregation)

Objective:
Create a Department class that aggregates Employee objects. Each department has many employees,
but employees can exist without being part of a department.

Solution:
#include <iostream>

#include <vector>

using namespace std;

// Employee class

class Employee {

private:

string name;

string position;

public:

// Constructor to initialize employee's name and position

Employee(string n, string p) : name(n), position(p) {}

// Method to display employee's details

void display() const {

cout << "Employee: " << name << ", Position: " << position << endl;

};

// Department class (aggregates multiple Employees)

class Department {

private:

vector<Employee*> employees; // Department "has many" Employees (Aggregation)

public:

// Method to add an employee to the department

void addEmployee(Employee* employee) {

employees.push_back(employee);
 }

// Method to display all employees in the department

void displayEmployees() const {

if ([Link]()) {

cout << "No employees in the department." << endl;

return;

cout << "Employees in the department:" << endl;

for (const auto& employee : employees) {

employee->display();

};

int main() {

// Create some Employee objects

Employee emp1("John", "Manager");

Employee emp2("Sarah", "Developer");

Employee emp3("Mike", "Designer");

// Create a Department object

Department dept;

// Add employees to the department

[Link](&emp1);

[Link](&emp2);

[Link](&emp3);
 // Display all employees in the department

[Link]();

return 0;

Exercise 4: University and Courses (Aggregation)

Objective:
Create a University class that aggregates Course objects. Each university offers many courses, and
courses can exist independently of a specific university.

Solution:

#include <iostream>

#include <vector>

using namespace std;

// Course class

class Course {

private:

string courseName;

public:

// Constructor to initialize course name

Course(string name) : courseName(name) {}

// Method to get the course name

string getCourseName() const {

return courseName;

};
// University class (aggregates multiple Courses)

class University {

private:

vector<Course*> courses; // University "offers many" Courses (Aggregation)

public:

// Method to add a course to the university

void addCourse(Course* course) {

courses.push_back(course);

// Method to display all courses offered by the university

void displayCourses() const {

if ([Link]()) {

cout << "No courses offered." << endl;

return;

cout << "Courses offered by the university:" << endl;

for (const auto& course : courses) {

cout << course->getCourseName() << endl;

};

int main() {

// Create some Course objects

Course course1("Computer Science");

Course course2("Physics");
 Course course3("Mathematics");

// Create a University object

University uni;

// Add courses to the university

[Link](&course1);

[Link](&course2);

[Link](&course3);

// Display all courses offered by the university

[Link]();

return 0;

Exercise 5: Team and Player (Aggregation)

Objective:
Create a Team class that aggregates Player objects. The team "has many" players, but players can exist
independently and can belong to multiple teams.

Solution:

#include <iostream>

#include <vector>

using namespace std;

// Player class

class Player {

private:

string name;
 string position;

public:

// Constructor to initialize player's name and position

Player(string n, string p) : name(n), position(p) {}

// Method to display player's details

void display() const {

cout << "Player: " << name << ", Position: " << position << endl;

};

// Team class (aggregates multiple Players)

class Team {

private:

vector<Player*> players; // Team "has many" Players (Aggregation)

public:

// Method to add a player to the team

void addPlayer(Player* player) {

players.push_back(player);

// Method to display all players in the team

void displayPlayers() const {

if ([Link]()) {

cout << "No players in the team." << endl;

return;

}
 cout << "Players in the team:" << endl;

for (const auto& player : players) {

player->display();

};

int main() {

// Create some Player objects

Player player1("Alice", "Forward");

Player player2("Bob", "Midfielder");

Player player3("Charlie", "Defender");

// Create a Team object

Team team;

// Add players to the team

[Link](&player1);

[Link](&player2);

[Link](&player3);

// Display all players in the team

[Link]();

return 0;

Key Concepts Covered:

 Encapsulation: Classes keep their attributes and behaviors within themselves, and provide public
interfaces to interact with their data.

 Object Construction and Management: Managing relationships between objects, including

These exercises should help you understand **aggregation

**, how objects can reference other objects without owning them, and how to create meaningful
relationships between classes.