C++ - Beginner’s Oops Exercise

Beginner’s OOP Exercise for C++

Introduction

This document provides an overview and notes for a C++ exercise aimed at beginners to understand the fundamentals of Object-Oriented Programming (OOP). The exercise covers key concepts such as classes, objects, constructors, destructors, member functions, and access specifiers.

Key Concepts

• Classes and Objects: Fundamental building blocks in OOP. A class defines the structure and behavior of objects.
• Encapsulation: Bundling the data (attributes) and methods (functions) that operate on the data into a single unit called a class.
• Constructors and Destructors: Special functions used to initialize objects and clean up after them.
• Access Specifiers: Defining the access levels of members (private, public, and protected).
• Member Functions: Functions that define the behaviors or actions of the class.

Exercise Overview

The exercise involves creating a simple class representing a "Book" and performing the following tasks:

• Define attributes such as title, author, and price for the book.
• Create a constructor to initialize these attributes.
• Implement getter and setter functions to access and modify the attributes.
• Create a function to display the details of the book.
• Demonstrate the use of constructors and destructors.

Step-by-Step Solution

1. Defining the Class

Start by defining a class called Book. This class will have private attributes to store the book's title, author, and price. Public functions will provide access to these attributes.

class Book {
private:
    string title;
    string author;
    double price;

public:
    Book(string t, string a, double p) {
        title = t;
        author = a;
        price = p;
    }

    void displayDetails() {
        cout << "Title: " << title << endl;
        cout << "Author: " << author << endl;
        cout << "Price: $" << price << endl;
    }
};
    

2. Constructors and Destructor

Constructors are special member functions used to initialize objects when they are created. In this case, we have a constructor that initializes the title, author, and price attributes. A destructor can also be defined (though it’s not essential in this simple example, as we don't need cleanup resources).

~Book() {
    cout << "Book object destroyed" << endl;
}
    

3. Getter and Setter Functions

Getter functions are used to access private attributes, and setter functions are used to modify them. Here is an example of getter and setter functions for the title attribute:

    string getTitle() {
        return title;
    }

    void setTitle(string t) {
        title = t;
    }
    

4. Main Program

The main program demonstrates how to create a Book object, access its attributes, and display the details.

#include 
using namespace std;

int main() {
    Book book1("C++ Primer", "Stanley B. Lippman", 45.99);
    book1.displayDetails();
    
    // Change the price using setter
    book1.setTitle("Advanced C++");
    cout << "\nUpdated Book Information:\n";
    book1.displayDetails();

    return 0;
}
    

Explanation of Code

• Class Declaration: The class Book has three private attributes: title, author, and price.
• Constructor: The constructor Book(string t, string a, double p)is used to initialize the attributes when an object of type Book is created.
• Member Function (displayDetails): This function displays the details of the book.
• Getter and Setter: getTitle and setTitle are functions that allow access to and modification of the title< attribute. Similar getter and setter functions can be written for author and price.
• Main Program: In the main function, we create a Book object, display its details, update its title using the setter, and then display the updated details.

Benefits of This Exercise

• Understanding Classes and Objects: This exercise helps in understanding how to create and use classes and objects in C++.
• Learn Constructors and Destructors: Students get to practice how constructors are used to initialize objects and how destructors can clean up resources (even though not needed in this example).
• Encapsulation: It shows how data (attributes) can be encapsulated within a class and accessed or modified through functions, ensuring data protection.
• Introduction to Member Functions: The exercise demonstrates how to create member functions to define actions or behaviors related to an object.

The Beginner’s OOP exercise in C++ provides a great starting point for understanding the core concepts of Object-Oriented Programming. By practicing with classes, constructors, member functions, and basic encapsulation, you can build a strong foundation for more advanced OOP topics. This exercise prepares you to work with more complex systems and applications that rely on the OOP paradigm.