Below are some programming exercises focused on composition in Object-Oriented Programming (OOP).

In composition, one class contains objects of another class as member variables, representing a "has-a"
relationship between them.

Exercise 1: Car and Engine (Composition)

Objective:
Create a Car class that contains an Engine class as a member variable. The Car class should use the
Engine class to start the engine and drive the car.

Solution:

#include <iostream>

using namespace std;

// Engine class

class Engine {

private:

bool isRunning;

public:

// Constructor to initialize engine state

Engine() : isRunning(false) {}

// Method to start the engine

void start() {

isRunning = true;

cout << "Engine is now running." << endl;

// Method to stop the engine

void stop() {

isRunning = false;
 cout << "Engine has stopped." << endl;

// Method to check engine status

bool isEngineRunning() {

return isRunning;

};

// Car class (composes an Engine)

class Car {

private:

Engine engine; // Car "has a" Engine

public:

// Method to start the car (start the engine)

void startCar() {

[Link]();

cout << "Car is ready to drive!" << endl;

// Method to stop the car (stop the engine)

void stopCar() {

[Link]();

cout << "Car has stopped!" << endl;

// Method to check if the car is running

bool isCarRunning() {
 return [Link]();

};

int main() {

Car myCar;

[Link]();

[Link]();

return 0;

Exercise 2: Library and Book (Composition)

Objective:
Create a Library class that contains a collection of Book objects. The Library class should provide
functionality to add and remove books from the collection.

Solution:

#include <iostream>

#include <vector>

using namespace std;

// Book class

class Book {

private:

string title;

string author;

public:

// Constructor to initialize a book

// Method to display book details

void display() const {

cout << "Title: " << title << ", Author: " << author << endl;

};

// Library class (composes a collection of Books)

class Library {

private:

vector<Book> books; // Library "has many" Books

public:

// Method to add a book to the library

void addBook(const Book& book) {

books.push_back(book);

cout << "Book added to library!" << endl;

// Method to remove a book by title

void removeBook(string title) {

for (auto it = [Link](); it != [Link](); ++it) {

if (it->getTitle() == title) {

[Link](it);

cout << "Book removed from library!" << endl;

return;

}
 cout << "Book not found!" << endl;

// Method to display all books in the library

void displayBooks() const {

if ([Link]()) {

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

return;

for (const auto& book : books) {

[Link]();

};

int main() {

// Create some Book objects

Book book1("1984", "George Orwell");

Book book2("To Kill a Mockingbird", "Harper Lee");

// Create a Library object

Library library;

// Add books to the library

[Link](book1);

[Link](book2);

// Display all books in the library

[Link]();
 return 0;

Exercise 3: House and Room (Composition)

Objective:
Create a House class that contains multiple Room objects. Each Room should have a name (e.g.,
bedroom, kitchen) and an area. The House class should allow displaying information about all rooms.

Solution:

#include <iostream>

#include <vector>

using namespace std;

// Room class

class Room {

private:

string name;

double area;

public:

// Constructor to initialize room

Room(string n, double a) : name(n), area(a) {}

// Method to display room details

void display() const {

cout << "Room: " << name << ", Area: " << area << " square meters" << endl;

};
// House class (composes multiple Rooms)

class House {

private:

vector<Room> rooms; // House "has many" Rooms

public:

// Method to add a room to the house

void addRoom(const Room& room) {

rooms.push_back(room);

cout << "Room added to house!" << endl;

// Method to display all rooms in the house

void displayRooms() const {

if ([Link]()) {

cout << "No rooms in the house." << endl;

return;

for (const auto& room : rooms) {

[Link]();

};

int main() {

// Create Room objects

Room room1("Living Room", 25.5);

Room room2("Kitchen", 15.0);

Room room3("Bedroom", 18.0);

House house;

// Add rooms to the house

[Link](room1);

[Link](room2);

[Link](room3);

// Display all rooms in the house

[Link]();

return 0;

Exercise 4: Computer and Processor (Composition)

Objective:
Create a Computer class that contains a Processor class. The Processor class should have a method to
display its speed, and the Computer class should use the processor to display the computer's processing
power.

Solution:

#include <iostream>

using namespace std;

// Processor class

class Processor {

private:

double speed; // Processor speed in GHz

public:
 // Constructor to initialize speed

Processor(double s) : speed(s) {}

// Method to display processor speed

void displaySpeed() const {

cout << "Processor Speed: " << speed << " GHz" << endl;

};

// Computer class (composes a Processor)

class Computer {

private:

Processor processor; // Computer "has a" Processor

public:

// Constructor to initialize processor

Computer(double speed) : processor(speed) {}

// Method to display computer specs

void displaySpecs() const {

cout << "Computer Specs:" << endl;

[Link]();

};

int main() {

// Create a Computer object with a Processor of 3.5 GHz

Computer myComputer(3.5);
 // Display computer specs

[Link]();

return 0;

Exercise 5: Author and Book (Composition)

Objective:
Create a Book class that contains an Author class. The Book should display the author's name and the
title of the book.

Solution:

#include <iostream>

using namespace std;

// Author class

class Author {

private:

string name;

public:

// Constructor to initialize author

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

// Method to get author's name

string getName() const {

return name;

};
// Book class (composes an Author)

class Book {

private:

string title;

Author author; // Book "has an" Author

public:

// Constructor to initialize title and author

Book(string t, Author a) : title(t), author(a) {}

// Method to display book and author details

void display() const {

cout << "Book: " << title << ", Author: " << [Link]() << endl;

};

int main() {

// Create an Author object

Author author("J.K. Rowling");

// Create a Book object

Book book("Harry Potter and the Sorcerer's Stone", author);

// Display book and author details

[Link]();

return 0;

}
Key Concepts Covered:

 Composition: One class contains objects of another class as member variables, representing a
"has-a" relationship.

 Encapsulation: Using classes to encapsulate behavior and data, keeping it hidden from the
outside world.

 Object Construction: Initializing and constructing complex objects that consist of multiple
components (classes).

These exercises will help you understand how objects can be composed of other objects, which is an
essential concept in OOP.