Scribd
Upload
13 views5 pages

Unit IV Pointers and Polymorphism

msbte k scheme oop unit 4 notes

Uploaded by

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

Unit IV Pointers and Polymorphism

msbte k scheme oop unit 4 notes

Uploaded by

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

Unit IV: Pointers and Polymorphism in C++

4.1 Concept of Pointer

A pointer is a variable that stores the address of another variable.

Pointers provide a way to access and manipulate memory locations directly.

- Pointer Declaration: int *ptr;

Here, 'ptr' is a pointer to an integer.

- Pointer Operator: The '*' operator is used to access the value at the address the pointer points to.

- Address Operator: The '&' operator is used to get the address of a variable.

- Pointer Arithmetic:

- Increment/Decrement: ptr++ or ptr-- moves the pointer to the next/previous memory location.

- Addition/Subtraction: ptr + n or ptr - n adds/subtracts n units from the pointer.

Example:

int a = 10;

int *ptr = &a; // ptr holds the address of a

std::cout << *ptr; // Outputs 10

4.2 Pointer to Object

Pointers can also point to objects. This allows dynamic memory allocation and the use of 'this' and

derived class pointers.


- 'this' Pointer:

- It refers to the current object of a class.

- Syntax: return *this;

- Pointer to Derived Class:

- A base class pointer can point to a derived class object.

Example:

class Base {};

class Derived : public Base {};

Base *bptr;

Derived d;

bptr = &d; // Base class pointer pointing to derived class object

4.3 Introduction to Polymorphism

Polymorphism means "many forms." It allows a single function or operator to behave differently

based on the input.

Types:

1. Compile-Time Polymorphism:

- Achieved using function overloading and operator overloading.

2. Run-Time Polymorphism:

- Achieved using virtual functions and inheritance.

4.4 Compile-Time Polymorphism


- Function Overloading:

- Functions with the same name but different parameters.

- Constructor Overloading:

- Multiple constructors with the same name but different parameters.

- Operator Overloading:

- Customizing the behavior of operators.

Rules for Operator Overloading:

1. Only existing operators can be overloaded.

2. At least one operand must be a user-defined type.

3. Cannot change operator precedence.

Example:

class Complex {

int real, imag;

public:

Complex operator+(Complex const &obj) {

Complex res;

res.real = real + obj.real;

res.imag = imag + obj.imag;

return res;

};
4.5 Run-Time Polymorphism

Run-time polymorphism is achieved using virtual functions and inheritance.

- Virtual Function:

- Declared using 'virtual' keyword in base class.

Rules:

1. Virtual functions must be defined in the base class.

2. Derived class must override the base class function.

- Pure Virtual Function:

- Declared using '= 0' syntax.

- Example: virtual void display() = 0;

Example:

class Base {

public:

virtual void show() {

std::cout << "Base class";

};

class Derived : public Base {

public:

void show() override {

std::cout << "Derived class";

}
};

You might also like