Scribd
Upload
16 views12 pages

Object-Oriented Programming Notes

The document discusses key concepts of object-oriented programming, including inheritance, polymorphism, abstract classes, friend functions, and composition versus aggregation. It highlights the benefits of these concepts such as code reusability, flexibility, and better organization. Additionally, it provides code examples to illustrate the differences between composition and aggregation.

Uploaded by

rehan31104
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
16 views12 pages

Object-Oriented Programming Notes

The document discusses key concepts of object-oriented programming, including inheritance, polymorphism, abstract classes, friend functions, and composition versus aggregation. It highlights the benefits of these concepts such as code reusability, flexibility, and better organization. Additionally, it provides code examples to illustrate the differences between composition and aggregation.

Uploaded by

rehan31104
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 12

Object-oriented programming

Inheritance
Mechanism by which one class can derive or inherit its
features from another class.

 public → Inherited as-is

 protected → Accessible in child, not outside

 private → Hidden from child


Benefits:
 Code reusability(write once, use many)
 Better organization through hierarchy
 Scalability of software systems

Polymorphism
The same function or operator behaves differently based
on the object or context.
Two types of Polymorphism:
1.Method overloading/ function overloading is decided
at compile time.

2.Virtual functions — method overriding using


inheritance and virtual functions.
Benefits:
 Flexibility and extensibility in code
 Easier maintenance and upgrade of the system
 Makes code easier and scalable

Abstract class/pure virtual functions


An abstract class is a class that cannot be
instantiated directly. It is meant to be a base class,
designed to be inherited by other classes. It usually
contains at least one pure virtual function.

A pure virtual function is a function that has no


implementation in the base class and is declared by
assigning = 0 at the end.
Friend function and class
A friend function is a non-member function that is
granted access to the private and protected members of
a class.
A friend class is a class that is allowed to access the
private and protected members of another class.

When to Use Friend Classes or Functions:

 When tight coupling between two classes/functions


is intended and safe
 When you need external functions to work closely
with class internals
 When overloading operators that require access to
the private data of multiple objects.

Composition and Aggregation


The lifetime of the part is controlled by the whole.

 If the container (whole) is destroyed, the part


(member) is also destroyed.
 Think of "a human has-a heart" — if the human is
gone, the heart goes too.

Simple Code for Composition:

Imagine a Car and its Engine. A Car has an Engine, and


the Engine is created as part of the Car. If the Car is
destroyed, the Engine (as part of that car) is also
gone.

#include <iostream>

#include <string>

class Engine {

public:

Engine() {

std::cout << "Engine created for the car." << std::endl;

~Engine() {

std::cout << "Engine in the car is gone." << std::endl;


}

void start() const {

std::cout << "Engine started." << std::endl;

};

class Car {

private:

std::string model;

Engine engine; // Car *has* an Engine (object member)

public:

Car(std::string m) : model(m) {

std::cout << "Car '" << model << "' built." << std::endl;

~Car() {

std::cout << "Car '" << model << "' is scrapped." <<
std::endl;

// The Engine object 'engine' is automatically destroyed here

// because it's a member object.

void drive() const {


engine.start();

std::cout << "Car is moving." << std::endl;

};

int main() {

Car myCar("SimpleCar");

myCar.drive();

// When myCar is destroyed at the end of main(),

// the Engine object 'engine' that is a part of it is also


automatically destroyed.

return 0;

Aggregation (Weak Has-a)

The lifetime of the part is independent of the whole.

 The contained object exists separately.


 Example: "A student has-a laptop", but if the
student leaves the school, the laptop still exists.
Simple Code for Aggregation:

Imagine a Student and a Book. A Student might use a


Book, but the Book exists independently of that
particular Student.

#include <iostream>

#include <string>

class Book {

public:

std::string title;

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

std::cout << "Book '" << title << "' exists." << std::endl;

~Book() {

std::cout << "Book '" << title << "' is gone." << std::endl;

void read() const {


std::cout << "Reading book: " << title << std::endl;

};

class Student {

public:

std::string name;

Book* currentBook; // Student *uses* a Book (pointer)

Student(std::string n) : name(n), currentBook(nullptr) {

std::cout << "Student '" << name << "' created." <<
std::endl;

~Student() {

std::cout << "Student '" << name << "' is done." <<
std::endl;

// The Student doesn't own the book, so doesn't delete it.

void borrowBook(Book* book) {

currentBook = book;

std::cout << name << " borrowed '" << book->title << "'."
<< std::endl;

}
void study() const {

if (currentBook) {

currentBook->read();

} else {

std::cout << name << " has no book to study." <<


std::endl;

};

int main() {

Book* book1 = new Book("The Great Adventure");

Student student1("Alice");

student1.borrowBook(book1);

student1.study();

Student student2("Bob");

student2.study(); // Bob has no book yet

delete book1; // The book can be deleted even if students


existed.
return 0;

You might also like