REPUBLIQUE DU CAMEROUN REPUBLIC OF CAMEROON

****** ******
Paix-Travail-Patrie Peace-Work-Fatherland
****** ******
NISTERE DE L’ENSEIGNEMENT SUPERIEUR MINISTRY OF HIGHER EDUCATION
****** ******
UT SUPERIEUR DES SCIENCES DE L’INDUSTRIE HIGHER INSTITUTE OF INDUSTRIAL SCIENCES

Email : info@issi.com BP: 15600 Douala-Cameroon

Tel: 699616628
Web : www.issi-ca.com 675776125

Academic Year: 2023-2024

COURSE TITLE: OOP

DEPARTMENT OF COMPUTER ENGINEERING: SPECIALITY:

Software Engineering

LECTURER: Eng. SONNE NJI CARLOS

4Th SEMESTER
 CHAPTER ONE : CONCEPT ON OBJECT ORIENTED
PROGRAMMING (OOP)
What is Object-Oriented Programming?
Object-oriented programming has a sweeping impact because it appeals at multiple levels
and promises faster and cheaper development and maintenance. It follows a bottom-up
approach to develop applications.

In this section, we will discuss in-depth what is object-oriented programming?

Object-Oriented Programming

The word object-oriented is the combination of two words i.e. object and oriented. The
dictionary meaning of the object is an article or entity that exists in the real world. The
meaning of oriented is interested in a particular kind of thing or entity. In layman's terms, it is
a programming pattern that rounds around an object or entity are called object-oriented
programming.

The technical definition of object-oriented programming is as follows:

The object-oriented programming is basically a computer programming design philosophy

or methodology that organizes/ models software design around data, or objects rather than
functions and logic.

An object is referred to as a data field that has unique attributes and behavior. Everything in
OOP is grouped as self-sustainable objects.

It is the most popular programming model among developers. It is well suited for programs
that are large, complex, and actively updated or maintained. It simplifies software
development and maintenance by providing major concepts such as abstraction,
inheritance, polymorphism, and encapsulation. These core concepts support OOP.

A real-world example of OOP is the automobile. It more completely illustrates the power of
object-oriented design.

Points to Remember
o Everything is an object
o Developer manipulates objects that uses message passing.
o Every object is an instance of a class.
o The class contains the attribute and behavior associated with an object.

Pillars of OOPs

The major concepts that we have discussed above are known as pillars of OOPs. There
are four pillars on which OOP rests.

o Abstraction
o Encapsulation
o Inheritance
o Polymorphism

Let's discuss each in detail.

Abstraction
The concept allows us to hide the implementation from the user but shows only essential
information to the user. Using the concept developer can easily make changes and added over
time.
There are the following advantages of abstraction:

o It reduces complexity.
o It avoids delicacy.
o Eases the burden of maintenance
o Increase security and confidentially.

Encapsulation
Encapsulation is a mechanism that allows us to bind data and functions of a class into an
entity. It protects data and functions from outside interference and misuse. Therefore, it also
provides security. A class is the best example of encapsulation.

Inheritance
The concept allows us to inherit or acquire the properties of an existing class (parent class)
into a newly created class (child class). It is known as inheritance. It provides code
reusability.
Polymorphism
The word polymorphism is derived from the two words i.e. ploy and morphs. Poly means
many and morphs means forms. It allows us to create methods with the same name but
different method signatures. It allows the developer to create clean, sensible, readable, and
resilient code.

The above figure best describes the concepts of polymorphism. A person plays an employee
role in the office, father and husband role in the home.

OOPs Concepts

The OOPs concepts include the following:

1. Object
2. Class
3. Inheritance
4. Polymorphism
 5. Abstraction
6. Encapsulation

Object
An object is a real-world entity that has attributes, behavior, and properties. It is referred to as
an instance of the class. It contains member functions, variables that we have defined in the
class. It occupies space in the memory. Different objects have different states or attributes,
and behaviors.

Class
A class is a blueprint or template of an object. It is a user-defined data type. Inside a class, we
define variables, constants, member functions, and other functionality. it binds data and
functions together in a single unit. It does not consume memory at run time. Note that classes
are not considered as a data structure. It is a logical entity. It is the best example of data
binding. Note that a class can exist without an object but vice-versa is not possible.

The following figure best illustrates the class and object in OOP.
Apart from these core concepts, there are some other object-oriented concepts used in OOP.

Coupling
In programming, separation of concerns is known as coupling. It means that an object cannot
directly change or modify the state or behavior of other objects. It defines how closely two
objects are connected together. There are two types of coupling, loose coupling,
and tight coupling.

Objects that are independent of one another and do not directly modify the state of other
objects is called loosely coupled. Loose coupling makes the code more flexible, changeable,
and easier to work with.

Objects that depend on other objects and can modify the states of other objects are called
tightly coupled. It creates conditions where modifying the code of one object also requires
changing the code of other objects. The reuse of code is difficult in tight coupling because we
cannot separate the code.

Since using loose coupling is always a good habit.

Cohesion
In OOP, cohesion refers to the degree to which the elements inside a module belong together.
It measures the strength of the relationship between the module and data. In short, cohesion
represents the clarity of the responsibilities of a module. It is often contrasted with coupling.

It focuses on a how single module or class is intended. Higher the cohesiveness of the module
or class, better is the object-oriented design.
There are two types of cohesion, i.e. High and Low.

o High cohesion is associated with several required qualities of software

including robustness, reliability, and understandability.
o Low cohesion is associated with unwanted qualities such as being difficult
to maintain, test, reuse, or even understand.

High cohesion often associates with loose coupling and vice versa.

Composition
Composition is one of the vital concepts in OOP. It describes a class that references one or
more objects of other classes in instance variables. It allows us to model a has-a association
between objects. We can find such relationships in the real world. For example, a car has an
engine. the following figure depicts the same
The main benefits of composition are:

o Reuse existing code

o Design clean APIs
o Change the implementation of a class used in a composition without adapting any
external clients.

Association
The association defines the relationship between the objects. Note that an object can be
associated with one or more than one object. The relationship can be unidirectional or
bidirectional. There are the following types of association.

o One to One
o One to Many
o Many to One, and
o Many to Many

Aggregation
It is an advanced form of association in which each object has its own Lifecycle but there
exists ownership as well. In other words, a relationship where a child can exist independently
of the parent. It is also termed as has-a relationship in Java. Like, inheritance represents the
is-a relationship. It is another way to reuse objects.

Why should we use OOP?

Object-oriented programming is an evolutionary development in software engineering. Using

OOP in software development is a good habit because it accomplishes the three major
software engineering goals, as we have shown in the following figure.
Where it is used?

OOP is often the best use when we are dealing with manufacturing and designing
applications. It provides modularity in programming. It allows us to break down the software
into chunks of small problems that we then can solve one object at a time.

It should be used where the reusability of code and maintenance is a major concern. Because
it makes development easy and we can easily append code without affecting other code
blocks. It should be used where complex programming is a challenge.

Benefits of OOP

o Modular, scalable, extensible, reusable, and maintainable.

o It models the complex problem in a simple structure.
o Object can be used across the program.
o Code can be reused.
o We can easily modify, append code without affecting the other code blocs.
o Provides security through encapsulation and data hiding features.
o Beneficial to collaborative development in which a large project is divided into
groups.
o Debugging is easy.

Limitations of OOP

o Requires intensive testing processes.

 o Solving problems takes more time as compared to Procedure Oriented Programming.
o The size of the programs created using this approach may become larger than the
programs written using the procedure-oriented programming approach.
o Software developed using this approach requires a substantial amount of pre-work
and planning.
o OOP code is difficult to understand if you do not have the corresponding class
documentation.
o In certain scenarios, these programs can consume a large amount of memory.
o Not suitable for small problems.
o Takes more time to solve problems.

List of Object-Oriented Programming Languages

There are various object-oriented programming languages are present. But we have enlisted
some popular and widely used OOP languages.

According to the TIOBE index, the top twenty OOP languages

are Java, C++, C#, Python, R, PHP, Visual Basic.NET, JavaScript, Ruby, Perl, Object
Pascal, Objective-C, Dart, Swift, Scala, Kotlin, Common Lisp, MATLAB, and Smalltalk.

Applications of OOPs

o Computer graphics applications

o Object-oriented database
o User-interface design such as windows
o Real-time systems
o Simulation and modeling
o Client-Server System
o Artificial Intelligence System
o CAD/CAM Software
o Office automation system
 CHAPTER TWO PRACTICAL IN OOP (C++)

INTRO TO C++

C++ tutorial provides basic and advanced concepts of C++. Our C++ tutorial is designed for
beginners and professionals.

C++ is an object-oriented programming language. It is an extension to C programming.

Our C++ tutorial includes all topics of C++ such as first example, control statements,
objects and classes, inheritance, constructor, destructor, this, static, polymorphism,
abstraction, abstract class, interface, namespace, encapsulation, arrays, strings, exception
handling, File IO, etc.

What is C++

C++ is a general purpose, case-sensitive, free-form programming language that supports

object-oriented, procedural and generic programming.

C++ is a middle-level language, as it encapsulates both high- and low-level language

features.

Object-Oriented Programming (OOPs)

C++ supports the object-oriented programming, the four major pillar of object-oriented
programming used in C++ are:

1. Inheritance
2. Polymorphism
3. Encapsulation
4. Abstraction

C++ Standard Libraries

Standard C++ programming is divided into three important parts:

o The core library includes the data types, variables and literals, etc.
o The standard library includes the set of functions manipulating strings, files, etc.
 o The Standard Template Library (STL) includes the set of methods manipulating a
data structure.

Usage of C++

By the help of C++ programming language, we can develop different types of secured and
robust applications:

o Window application
o Client-Server application
o Device drivers
o Embedded firmware etc

C++ Program

In this tutorial, all C++ programs are given with C++ compiler so that you can easily
change the C++ program code.

File: main.cpp

1. #include <iostream> //
2. using namespace std;
3. int main() {
4. cout << "Hello C++ Programming";
5. return 0;
6. }
A detailed explanation of first C++ program is given in next chapters.
No. C C++ C vs C++

1) C follows the procedural style C++ is multi-paradigm. It supports

programming. both procedural and object
oriented.

2) Data is less secured in C. In C++, you can use modifiers for

class members to make it
inaccessible for outside users.

3) C follows the top-down approach. C++ follows the bottom-up

approach.

4) C does not support function C++ supports function overloading.

overloading.

5) In C, you can't use functions in In C++, you can use functions in

structure. structure.

6) C does not support reference C++ supports reference variables.

variables.

7) In C, scanf() and printf() are C++ mainly uses stream cin and
mainly used for input/output. cout to perform input and output
operations.

8) Operator overloading is not possible Operator overloading is possible in

in C. C++.

9) C programs are divided C++ programs are divided

into procedures and modules into functions and classes.

10) C does not provide the feature of C++ supports the feature of
namespace. namespace.
 11) Exception handling is not easy in C. C++ provides exception handling
It has to perform using other using Try and Catch block.
functions.

C++ history

History of C++ language is interesting to know. Here we are going to discuss brief history
of C++ language.

C++ programming language was developed in 1980 by Bjarne Stroustrup at bell

laboratories of AT&T (American Telephone & Telegraph), located in U.S.A.

Bjarne Stroustrup is known as the founder of C++ language.

C++ history

History of C++ language is interesting to know. Here we are going to discuss brief history of C++ langua

C++ programming language was developed in 1980 by Bjarne Stroustrup at bell laboratories of AT&T (
Telegraph), located in U.S.A.

Bjarne Stroustrup is known as the founder of C++ language.

It was develop for adding a feature of OOP (Object Oriented Programming) in C without significantly c
component.

C++ programming is "relative" (called a superset) of C, it means any valid C program is also a valid C++ p

Let's see the programming languages that were developed before C++ language.

Language Year Developed By

Algol 1960 International Group

BCPL 1967 Martin Richard

B 1970 Ken Thompson

Traditional C 1972 Dennis Ritchie

K&RC 1978 Kernighan & Dennis Ritchie

C++ 1980 Bjarne Stroustrup

 C++ Program

Before starting the abcd of C++ language, you need to learn how to write, compile and run
the first C++ program.

To write the first C++ program, open the C++ console and write the following code:

1. #include <iostream.h>
2. #include<conio.h>
3. void main() {
4. clrscr();
5. cout << "Welcome to C++ Programming.";
6. getch();
7. }

#include<iostream.h> includes the standard input output library functions. It

provides cin and cout methods for reading from input and writing to output respectively.

#include <conio.h> includes the console input output library functions. The getch()
function is defined in conio.h file.

void main() The main() function is the entry point of every program in C++ language.
The void keyword specifies that it returns no value.

cout << "Welcome to C++ Programming." is used to print the data "Welcome to C++
Programming." on the console.

getch() The getch() function asks for a single character. Until you press any key, it blocks
the screen.
How to compile and run the C++ program

There are 2 ways to compile and run the C++ program, by menu and by shortcut.

By menu

Now click on the compile menu then compile sub menu to compile the c++ program.

Then click on the run menu then run sub menu to run the c++ program.

By shortcut

Or, press ctrl+f9 keys compile and run the program directly.

You will see the following output on user screen.

You can view the user screen any time by pressing the alt+f5 keys.

Now press Esc to return to the turbo c++ console.

C++ Basic Input/Output

C++ I/O operation is using the stream concept. Stream is the sequence of bytes or flow of
data. It makes the performance fast.

If bytes flow from main memory to device like printer, display screen, or a network
connection, etc, this is called as output operation.

If bytes flow from device like printer, display screen, or a network connection, etc to main
memory, this is called as input operation.

I/O Library Header Files

Let us see the common header files used in C++ programming are:

Header File Function and Description

<iostream> It is used to define the cout, cin and cerr objects, which correspond
to standard output stream, standard input stream and standard error
stream, respectively.

<iomanip> It is used to declare services useful for performing formatted I/O,

such as setprecision and setw.

<fstream> It is used to declare services for user-controlled file processing.

Standard output stream (cout)

 The cout is a predefined object of ostream class. It is connected with the standard output
device, which is usually a display screen. The cout is used in conjunction with stream
insertion operator (<<) to display the output on a console

Let's see the simple example of standard output stream (cout):

1. #include <iostream>
2. using namespace std;
3. int main( ) {
4. char ary[] = "Welcome to C++ tutorial";
5. cout << "Value of ary is: " << ary << endl;
cout<< ―HELLO HWM INSAM‖;
//in c programming – printf(―hello world \n‖);
6. }

Output:

Value of ary is: Welcome to C++ tutorial

Standard input stream (cin)

The cin is a predefined object of istream class. It is connected with the standard input device,
which is usually a keyboard. The cin is used in conjunction with stream extraction operator
(>>) to read the input from a console.

Let's see the simple example of standard input stream (cin):

1. #include <iostream>
2. using namespace std;
3. int main( ) {
4. int age;
5. cout << "Enter your age: ";
6. cin >> age;
7. cout << "Your age is: " << age << endl;
8. }

Output:

Enter your age: 22

Your age is: 22

Standard end line (endl)

The endl is a predefined object of ostream class. It is used to insert a new line characters and
flushes the stream.
 Let's see the simple example of standard end line (endl):

1. #include <iostream>
2. using namespace std;
3. int main( ) {
4. cout << "C++ Tutorial";
5. cout << " Javatpoint"<<endl;
6. cout << "End of line"<<endl; // ―\n‖
7. }

Output:

C++ Tutorial Javatpoint

End of line

C++ Variable

A variable is a name of memory location. It is used to store data. Its value can be changed
and it can be reused many times.

30 40
X Y

FFAB FFAC

It is a way to represent memory location through symbol so that it can be easily identified.

Let's see the syntax to declare a variable:

1. type variable_list;

The example of declaring variable is given below:

1. int x;
2. float y;
3. char z;

Here, x, y, z are variables and int, float, char are data types.

We can also provide values while declaring the variables as given below:

1. int x=5,b=10; //declaring 2 variable of integer type

2. float f=30.8;
3. char c='A';
 Rules for defining variables

 A variable can have alphabets, digits and underscore.

 A variable name can start with alphabet and underscore only. It can't start with digit.
 No white space is allowed within variable name. int xy not int x y
 A variable name must not be any reserved word or keyword e.g. char, float etc.

Valid variable names:

1. int a;
2. int _ab;
3. int a30;
4. float f;

Invalid variable names:

1. int 4;
2. int x y;
3. int double;
4. int int;
C++ Data Types

A data type specifies the type of data that a variable can store such as integer, floating,
character etc.

There are 4 types of data types in C++ language.

 Types Data Types

Basic Data Type int, char, float, double, etc

Derived Data Type array, pointer, etc

Enumeration Data Type enum

User Defined Data Type structure

Basic Data Types

The basic data types are integer-based and floating-point based. C++ language supports both
signed and unsigned literals.

The memory size of basic data types may change according to 32-Z or 64-bit operating
system.

Let's see the basic data types. It size is given according to 32 bit OS.

Data Types Memory Size Range

Char 1 byte -128 to 127

signed char 1 byte -128 to 127

unsigned char 1 byte 0 to 127

Short 2 byte -32,768 to 32,767

signed short 2 byte -32,768 to 32,767

unsigned short 2 byte 0 to 32,767

 Int 2 byte -32,768 to 32,767

signed int 2 byte -32,768 to 32,767

unsigned int 2 byte 0 to 32,767

short int 2 byte -32,768 to 32,767

signed short int 2 byte -32,768 to 32,767

unsigned short int 2 byte 0 to 32,767

long int 4 byte

signed long int 4 byte

unsigned long int 4 byte

Float 4 byte

Double 8 byte

long double 10 byte

C++ Keywords

A keyword is a reserved word. You cannot use it as a variable name, constant name etc. A
list of 32 Keywords in C++ Language which are also available in C language are given
below.

auto break case char const continue default do

 double else enum extern float for goto if

int long register return short signed sizeof static

struct switch typedef union unsigned void volatile while

A list of 30 Keywords in C++ Language which are not available in C language are given
below.

asm dynamic_cast namespace reinterpret_cast bool

explicit New static_cast false catch

operator Template friend private class

this Inline public throw const_cast

delete Mutable protected true try

typeid Typename using virtual wchar_t

C++ Operators

An operator is simply a symbol that is used to perform operations. There can be many types
of operations like arithmetic, logical, bitwise etc.

There are following types of operators to perform different types of operations in C language.

o Arithmetic Operators
o Relational Operators
o Logical Operators
o Bitwise Operators
o Assignment Operator
o Unary operator
o Ternary or Conditional Operator
o Misc Operator
 Precedence of Operators in C++

The precedence of operator species that which operator will be evaluated first and next. The
associativity specifies the operators direction to be evaluated, it may be left to right or right to
left.

Let's understand the precedence by the example given below:

1. int data=5+10*10;

The "data" variable will contain 105 because * (multiplicative operator) is evaluated before +
(additive operator).

The precedence and associativity of C++ operators is given below:

Category Operator Associativity

Postfix () [] -> . ++ - - Left to right

Unary + - ! ~ ++ - - (type)* & sizeof Right to left

Multiplicative */% Left to right

Additive +- Right to left

 Shift << >> Left to right

Relational < <= > >= Left to right

Equality == !=/td> Right to left

Bitwise AND & Left to right

Bitwise XOR ^ Left to right

Bitwise OR | Right to left

Logical AND && Left to right

Logical OR || Left to right

Conditional ?: Right to left

Assignment = += -= *= /= %=>>= <<= &= ^= |= Right to left

Comma , Left to right

Operators in C++ - Expanded

Example of Arithmetic Operators

#include <iostream>
using namespace std;
int main(){
int num1 = 240;
int num2 = 40;
cout<<"num1 + num2: "<<(num1 + num2)<<endl;
cout<<"num1 - num2: "<<(num1 - num2)<<endl;
cout<<"num1 * num2: "<<(num1 * num2)<<endl;
cout<<"num1 / num2: "<<(num1 / num2)<<endl;
cout<<"num1 % num2: "<<(num1 % num2)<<endl;
return 0;
}
Output:

num1 + num2: 280

num1 - num2: 200
num1 * num2: 9600
num1 / num2: 6
num1 % num2: 0
2) Assignment Operators
Assignments operators in C++ are: =, +=, -=, *=, /=, %=

num2 = num1 would assign value of variable num1 to the variable.

num2+=num1 is equal to num2 = num2+num1

num2-=num1 is equal to num2 = num2-num1

num2*=num1 is equal to num2 = num2*num1

num2/=num1 is equal to num2 = num2/num1

num2%=num1 is equal to num2 = num2%num1

Example of Assignment Operators

#include <iostream>
using namespace std;
int main(){
int num1 = 240;
int num2 = 40;
num2 = num1;
cout<<"= Output: "<<num2<<endl;
num2 += num1;
cout<<"+= Output: "<<num2<<endl;
num2 -= num1;
cout<<"-= Output: "<<num2<<endl;
num2 *= num1;
cout<<"*= Output: "<<num2<<endl;
num2 /= num1;
cout<<"/= Output: "<<num2<<endl;
num2 %= num1;
cout<<"%= Output: "<<num2<<endl;
return 0;
}
Output:

= Output: 240
+= Output: 480
-= Output: 240
*= Output: 57600
/= Output: 240
%= Output: 0
3) Auto-increment and Auto-decrement Operators

++ and —
num++ is equivalent to num=num+1;
num–- is equivalent to num=num-1;

Example of Auto-increment and Auto-decrement Operators

#include <iostream>
using namespace std;
int main(){
int num1 = 240;
int num2 = 40;
num1++; num2--;
cout<<"num1++ is: "<<num1<<endl;
cout<<"num2-- is: "<<num2;
return 0;
}
Output:

num1++ is: 241

num2-- is: 39
4) Logical Operators

Logical Operators are used with binary variables. They are mainly used in conditional
statements and loops for evaluating a condition.

Logical operators in C++ are: &&, ||, !

Let’s say we have two boolean variables b1 and b2.

b1&&b2 will return true if both b1 and b2 are true else it would return false.

b1||b2 will return false if both b1 and b2 are false else it would return true.

!b1 would return the opposite of b1, that means it would be true if b1 is false and it would
return false if b1 is true.

Example of Logical Operators

#include <iostream>
using namespace std;
int main(){
bool b1 = true;
bool b2 = false;
cout<<"b1 && b2: "<<(b1&&b2)<<endl;
cout<<"b1 || b2: "<<(b1||b2)<<endl;
cout<<"!(b1 && b2): "<<!(b1&&b2);
return 0;
}
Output:
b1 && b2: 0
b1 || b2: 1
!(b1 && b2): 1
5) Relational operators

We have six relational operators in C++: ==, !=, >, <, >=, <=

== returns true if both the left side and right side are equal

!= returns true if left side is not equal to the right side of operator.

> returns true if left side is greater than right.

< returns true if left side is less than right side.

>= returns true if left side is greater than or equal to right side.

<= returns true if left side is less than or equal to right side.

Example of Relational operators

#include <iostream>
using namespace std;
int main(){
int num1 = 240;
int num2 =40;
if (num1==num2) {
cout<<"num1 and num2 are equal"<<endl;
}
else{
cout<<"num1 and num2 are not equal"<<endl;
}
if( num1 != num2 ){
cout<<"num1 and num2 are not equal"<<endl;
}
else{
cout<<"num1 and num2 are equal"<<endl;
}
if( num1 > num2 ){
cout<<"num1 is greater than num2"<<endl;
}
else{
cout<<"num1 is not greater than num2"<<endl;
}
if( num1 >= num2 ){
cout<<"num1 is greater than or equal to num2"<<endl;
}
 else{
cout<<"num1 is less than num2"<<endl;
}
if( num1 < num2 ){
cout<<"num1 is less than num2"<<endl;
}
else{
cout<<"num1 is not less than num2"<<endl;
}
if( num1 <= num2){
cout<<"num1 is less than or equal to num2"<<endl;
}
else{
cout<<"num1 is greater than num2"<<endl;
}
return 0;
}
Output:

num1 and num2 are not equal

num1 and num2 are not equal
num1 is greater than num2
num1 is greater than or equal to num2
num1 is not less than num2
num1 is greater than num2
6) Bitwise Operators

There are six bitwise Operators: &, |, ^, ~, <<, >>

num1 = 11; /* equal to 00001011*/

num2 = 22; /* equal to 00010110 */
Bitwise operator performs bit by bit processing.
num1 & num2 compares corresponding bits of num1 and num2 and generates 1 if both bits
are equal, else it returns 0. In our case it would return: 2 which is 00000010 because in the
binary form of num1 and num2 only second last bits are matching.

num1 | num2 compares corresponding bits of num1 and num2 and generates 1 if either bit is
1, else it returns 0. In our case it would return 31 which is 00011111

num1 ^ num2 compares corresponding bits of num1 and num2 and generates 1 if they are
not equal, else it returns 0. In our example it would return 29 which is equivalent to
00011101

~num1 is a complement operator that just changes the bit from 0 to 1 and 1 to 0. In our
example it would return -12 which is signed 8 bit equivalent to 11110100
num1 << 2 is left shift operator that moves the bits to the left, discards the far left bit, and
assigns the rightmost bit a value of 0. In our case output is 44 which is equivalent to
00101100

Note: In the example below we are providing 2 at the right side of this shift operator that is
the reason bits are moving two places to the left side. We can change this number and bits
would be moved by the number of bits specified on the right side of the operator. Same
applies to the right side operator.

num1 >> 2 is right shift operator that moves the bits to the right, discards the far right bit,
and assigns the leftmost bit a value of 0. In our case output is 2 which is equivalent to
00000010

Example of Bitwise Operators

#include <iostream>
using namespace std;
int main(){
int num1 = 11; /* 11 = 00001011 */
int num2 = 22; /* 22 = 00010110 */
int result = 0;
result = num1 & num2;
cout<<"num1 & num2: "<<result<<endl;
result = num1 | num2;
cout<<"num1 | num2: "<<result<<endl;
result = num1 ^ num2;
cout<<"num1 ^ num2: "<<result<<endl;
result = ~num1;
cout<<"~num1: "<<result<<endl;
result = num1 << 2;
cout<<"num1 << 2: "<<result<<endl;
result = num1 >> 2;
cout<<"num1 >> 2: "<<result;
return 0;
}
Output:

num1 & num2: 2

num1 | num2: 31
num1 ^ num2: 29
~num1: -12
num1 << 2: 44 num1 >> 2: 2
7) Ternary Operator

This operator evaluates a boolean expression and assign the value based on the result.
Syntax:

variable num1 = (expression) ? value if true : value if false

If the expression results true then the first value before the colon (:) is assigned to the variable
num1 else the second value is assigned to the num1.

Example of Ternary Operator

#include <iostream>
using namespace std;
int main(){
int num1, num2; num1 = 99;
/* num1 is not equal to 10 that's why
* the second value after colon is assigned
* to the variable num2
*/
num2 = (num1 == 10) ? 100: 200;
cout<<"num2: "<<num2<<endl;
/* num1 is equal to 99 that's why
* the first value is assigned
* to the variable num2
*/
num2 = (num1 == 99) ? 100: 200;
cout<<"num2: "<<num2;
return 0;
}
Output:

num2: 200
num2: 100

C++ Pointers
C++ pointers are easy and fun to learn. Some C++ tasks are performed more easily with
pointers, and other C++ tasks, such as dynamic memory allocation, cannot be performed
without them.

As you know every variable is a memory location and every memory location has its address
defined which can be accessed using ampersand (&) operator which denotes an address in
memory. Consider the following which will print the address of the variables defined −

#include <iostream>

using namespace std;

int main () {

int var1;
 char var2[10];

cout << "Address of var1 variable: ";

cout << &var1 << endl;

cout << "Address of var2 variable: ";

cout << &var2 << endl;

return 0;

When the above code is compiled and executed, it produces the following result −

Address of var1 variable: 0xbfebd5c0

Address of var2 variable: 0xbfebd5b6

What are Pointers?

A pointer is a variable whose value is the address of another variable. Like any variable or
constant, you must declare a pointer before you can work with it. The general form of a
pointer variable declaration is –

A B(POINTER)

20 FF01

FF01 FF02

type *var-name;

Here, type is the pointer's base type; it must be a valid C++ type and var-name is the name
of the pointer variable. The asterisk you used to declare a pointer is the same asterisk that
you use for multiplication. However, in this statement the asterisk is being used to designate
a variable as a pointer. Following are the valid pointer declaration −

int *ip; // pointer to an integer

double *dp; // pointer to a double
float *fp; // pointer to a float
char *ch // pointer to character

The actual data type of the value of all pointers, whether integer, float, character, or
otherwise, is the same, a long hexadecimal number that represents a memory address. The
only difference between pointers of different data types is the data type of the variable or
constant that the pointer points to.

Using Pointers in C++

There are few important operations, which we will do with the pointers very
frequently. (a) We define a pointer variable. (b) Assign the address of a variable to a
pointer. (c) Finally access the value at the address available in the pointer variable. This is
done by using unary operator * that returns the value of the variable located at the address
specified by its operand. Following example makes use of these operations −

#include <iostream>

using namespace std;

int main () {

int var = 20; // actual variable declaration.

int *ip; // pointer variable

ip = &var; // store address of var in pointer variable

cout << "Value of var variable: ";

cout << var << endl;

// print the address stored in ip pointer variable

 cout << "Address stored in ip variable: ";

cout << ip << endl;

// access the value at the address available in pointer

cout << "Value of *ip variable: ";

cout << *ip << endl;

return 0;

When the above code is compiled and executed, it produces result something as follows −

Value of var variable: 20

Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20

Pointers in C++

Pointers have many but easy concepts and they are very important to C++ programming.
There are following few important pointer concepts which should be clear to a C++
programmer −

Sr.No Concept & Description

1 Null Pointers

C++ supports null pointer, which is a constant with a value of zero defined in
several standard libraries.

2 Pointer Arithmetic

There are four arithmetic operators that can be used on pointers: ++, --, +, -
3 Pointers vs Arrays

There is a close relationship between pointers and arrays.

4 Array of Pointers

You can define arrays to hold a number of pointers.

5 Pointer to Pointer

C++ allows you to have pointer on a pointer and so on.

6 Passing Pointers to Functions

Passing an argument by reference or by address both enable the passed argument

to be changed in the calling function by the called function.

7 Return Pointer from Functions

C++ allows a function to return a pointer to local variable, static variable and
dynamically allocated memory as well.

C++ Pointer to Pointer (Multiple Indirection)

A pointer to a pointer is a form of multiple indirection or a chain of pointers. Normally, a
pointer contains the address of a variable. When we define a pointer to a pointer, the first
pointer contains the address of the second pointer, which points to the location that contains
the actual value as shown below.

A variable that is a pointer to a pointer must be declared as such. This is done by placing an
additional asterisk in front of its name. For example, following is the declaration to declare a
pointer to a pointer of type int −
int **var;

When a target value is indirectly pointed to by a pointer to a pointer, accessing that value
requires that the asterisk operator be applied twice, as is shown below in the example −

#include <iostream>

using namespace std;

int main () {

int var;

int *ptr;

int **pptr;

var = 3000;

// take the address of var

ptr = &var;

// take the address of ptr using address of operator &

pptr = &ptr;

// take the value using pptr

cout << "Value of var :" << var << endl;

cout << "Value available at *ptr :" << *ptr << endl;

cout << "Value available at **pptr :" << **pptr << endl;
 return 0;

When the above code is compiled and executed, it produces the following result −

Value of var :3000

Value available at *ptr :3000
Value available at **pptr :3000

C++ Pointer Arithmetic

As you understood pointer is an address which is a numeric value; therefore, you can
perform arithmetic operations on a pointer just as you can a numeric value. There are four
arithmetic operators that can be used on pointers: ++, --, +, and -

To understand pointer arithmetic, let us consider that ptr is an integer pointer which points to
the address 1000. Assuming 32-bit integers, let us perform the following arithmetic
operation on the pointer −

ptr++

the ptr will point to the location 1004 because each time ptr is incremented, it will point to
the next integer. This operation will move the pointer to next memory location without
impacting actual value at the memory location. If ptr points to a character whose address is
1000, then above operation will point to the location 1001 because next character will be
available at 1001.

Incrementing a Pointer

We prefer using a pointer in our program instead of an array because the variable pointer can
be incremented, unlike the array name which cannot be incremented because it is a constant
pointer. The following program increments the variable pointer to access each succeeding
element of the array −

#include <iostream>
using namespace std;

const int MAX = 3;

int main () {

int var[MAX] = {10, 100, 200};

int *ptr;

// let us have array address in pointer.

ptr = var;

for (int i = 0; i < MAX; i++) {

cout << "Address of var[" << i << "] = ";

cout << ptr << endl;

cout << "Value of var[" << i << "] = ";

cout << *ptr << endl;

// point to the next location

ptr++;

return 0;

}
When the above code is compiled and executed, it produces result something as follows −

Address of var[0] = 0xbfa088b0

Value of var[0] = 10
Address of var[1] = 0xbfa088b4
Value of var[1] = 100
Address of var[2] = 0xbfa088b8
Value of var[2] = 200

Decrementing a Pointer

The same considerations apply to decrementing a pointer, which decreases its value by the
number of bytes of its data type as shown below −

#include <iostream>

using namespace std;

const int MAX = 3;

int main () {

int var[MAX] = {10, 100, 200};

int *ptr;

// let us have address of the last element in pointer.

ptr = &var[MAX-1];

for (int i = MAX; i > 0; i--) {

cout << "Address of var[" << i << "] = ";

cout << ptr << endl;

 cout << "Value of var[" << i << "] = ";

cout << *ptr << endl;

// point to the previous location

ptr--;

return 0;

When the above code is compiled and executed, it produces result something as follows −

Address of var[3] = 0xbfdb70f8

Value of var[3] = 200
Address of var[2] = 0xbfdb70f4
Value of var[2] = 100
Address of var[1] = 0xbfdb70f0
Value of var[1] = 10

Pointer Comparisons

Pointers may be compared by using relational operators, such as ==, <, and >. If p1 and p2
point to variables that are related to each other, such as elements of the same array, then p1
and p2 can be meaningfully compared.

The following program modifies the previous example one by incrementing the variable
pointer so long as the address to which it points is either less than or equal to the address of
the last element of the array, which is &var[MAX - 1] −

#include <iostream>

using namespace std;

const int MAX = 3;

int main () {

int var[MAX] = {10, 100, 200};

int *ptr;

// let us have address of the first element in pointer.

ptr = var;

int i = 0;

while ( ptr <= &var[MAX - 1] ) {

cout << "Address of var[" << i << "] = ";

cout << ptr << endl;

cout << "Value of var[" << i << "] = ";

cout << *ptr << endl;

// point to the previous location

ptr++;

i++;

return 0;

}
When the above code is compiled and executed, it produces result something as follows −

Address of var[0] = 0xbfce42d0

Value of var[0] = 10
Address of var[1] = 0xbfce42d4
Value of var[1] = 100
Address of var[2] = 0xbfce42d8
Value of var[2] = 200

C++ Functions

The function in C++ language is also known as procedure or subroutine in other

programming languages.

To perform any task, we can create function. A function can be called many times. It
provides modularity and code reusability.

Advantage of functions in C

There are many advantages of functions.

1) Code Reusability

By creating functions in C++, you can call it many times. So we don't need to write the same
code again and again.

2) Code optimization

It makes the code optimized, we don't need to write much code.

Suppose, you have to check 3 numbers (531, 883 and 781) whether it is prime number or not.
Without using function, you need to write the prime number logic 3 times. So, there is
repetition of code.

But if you use functions, you need to write the logic only once and you can reuse it several
times.
 Types of Functions

There are two types of functions in C programming:

1. Library Functions: are the functions which are declared in the C++ header files such as
ceil(x), cos(x), exp(x), etc.

2. User-defined functions: are the functions which are created by the C++ programmer, so
that he/she can use it many times. It reduces complexity of a big program and optimizes the
code.

Declaration of a function

The syntax of creating function in C++ language is given below:

1. return_type function_name (data_type parameter...)

2. {
3. //code to be executed
4. }

Different forms of functions

 Functions with return type and with argument (int add (int a, int b))

Function with return type and without arguments (int add ( ))

Function without return type and with arguments (void add (int a, int b ))

Function without return type and without argument (void add ( ))

C++ Function Example

Let's see the simple example of C++ function.

1. #include <iostream>
2. using namespace std;
3. void func() {
4. static int i=0; //static variable
5. int j=0; //local variable
6. i++;
7. j++;
8. cout<<"i=" << i<<" and j=" <<j<<endl;
9. }
10. int main()
11. {
12. func();
13. func();
14. func();
15. }
Output:

i= 1 and j= 1
i= 2 and j= 1
i= 3 and j= 1
 Call by value and call by reference in C++
There are two ways to pass value or data to function in C language: call by value and call by
reference. Original value is not modified in call by value but it is modified in call by
reference.

Let's understand call by value and call by reference in C++ language one by one.

Call by value in C++

In call by value, original value is not modified.

In call by value, value being passed to the function is locally stored by the function parameter
in stack memory location. If you change the value of function parameter, it is changed for the
current function only. It will not change the value of variable inside the caller method such as
main().

Let's try to understand the concept of call by value in C++ language by the example given
below:

1. #include <iostream>
2. using namespace std;
3. void change(int data);
4. int main()
5. {
6. int data = 3;
7. change(data);
8. cout << "Value of the data is: " << data<< endl;
9. return 0;
10. }
11. void change(int data)
12. {
13. data = 5;
14. }
Output:

Value of the data is: 3

Call by reference in C++

In call by reference, original value is modified because we pass reference (address).

Here, address of the value is passed in the function, so actual and formal arguments share the
same address space. Hence, value changed inside the function, is reflected inside as well as
outside the function.

Note: To understand the call by reference, you must have the basic knowledge of pointers.

Let's try to understand the concept of call by reference in C++ language by the example given
below:

1. #include<iostream>
2. using namespace std;
3. void swap(int *x, int *y)
4. {
5. int swap;
6. swap=*x;
7. *x=*y;
8. *y=swap;
9. }
10. int main()
11. {
12. int x=500, y=100;
13. swap(&x, &y); // passing value to function
14. cout<<"Value of x is: "<<x<<endl;
15. cout<<"Value of y is: "<<y<<endl;
16. return 0;
17. }
 Output:

Value of x is: 100

Value of y is: 500

Difference between call by value and call by reference in C++

No. Call by value Call by reference

1 A copy of value is passed to the An address of value is passed to the

function function

2 Changes made inside the function is not Changes made inside the function is
reflected on other functions reflected outside the function also

3 Actual and formal arguments will be Actual and formal arguments will be
created in different memory location created in same memory location

C++ Recursion
When function is called within the same function, it is known as recursion in C++. The
function which calls the same function, is known as recursive function.

A function that calls itself, and doesn't perform any task after function call, is known as tail
recursion. In tail recursion, we generally call the same function with return statement.

Let's see a simple example of recursion.

1. recursionfunction(){
2. recursionfunction(); //calling self function
3. }
 C++ Recursion Example

Let's see an example to print factorial number using recursion in C++ language.

1. #include<iostream>
2. using namespace std;
3. int main()
4. {
5. int factorial(int);
6. int fact,value;
7. cout<<"Enter any number: ";
8. cin>>value;
9. fact=factorial(value);
10. cout<<"Factorial of a number is: "<<fact<<endl;
11. return 0;
12. }
13. int factorial(int n)
14. {
15. if(n<0)
16. return(-1); /*Wrong value*/
17. if(n==0)
18. return(1); /*Terminating condition*/
19. else
20. {
21. return(n*factorial(n-1));
22. }
23. }
Output:

Enter any number: 5

Factorial of a number is: 120
We can understand the above program of recursive method call by the figure given below:
C++ Storage Classes
Storage class is used to define the lifetime and visibility of a variable and/or function within a
C++ program.

Lifetime refers to the period during which the variable remains active and visibility refers to
the module of a program in which the variable is accessible.

There are five types of storage classes, which can be used in a C++ program

1. Automatic
2. Register
3. Static
4. External
5. Mutable

Storage Class Keyword Lifetime Visibility I

Automatic Auto Function Block Local

Register register Function Block Local

 Mutable mutable Class Local

External Extern Whole Program Global

Static Static Whole Program Local

Automatic Storage Class

It is the default storage class for all local variables. The auto keyword is applied to all local
variables automatically.

1. {
2. auto int y;
3. float y = 3.45;
4. }
The above example defines two variables with a same storage class, auto can only be used
within functions.

Register Storage Class

The register variable allocates memory in register than RAM. Its size is same of register size.
It has a faster access than other variables.

It is recommended to use register variable only for quick access such as in counter.

Note: We can't get the address of register variable.

1. register int counter=0;

Static Storage Class

 The static variable is initialized only once and exists till the end of a program. It retains its
value between multiple functions call.

The static variable has the default value 0 which is provided by compiler.

1. #include <iostream>
2. using namespace std;
3. void func() {
4. static int i=0; //static variable
5. int j=0; //local variable
6. i++;
7. j++;
8. cout<<"i=" << i<<" and j=" <<j<<endl;
9. }
10. int main()
11. {
12. func();
13. func();
14. func();
15. }
Output:

i= 1 and j= 1
i= 2 and j= 1
i= 3 and j= 1

External Storage Class

The extern variable is visible to all the programs. It is used if two or more files are sharing
same variable or function.

1. extern int counter=0;

LECTURE FOUR
C++ Arrays

Like other programming languages, array in C++ is a group of similar types of elements that
have contiguous memory location.

In C++ std::array is a container that encapsulates fixed size arrays. In C++, array index starts
from 0. We can store only fixed set of elements in C++ array.

Advantages of C++ Array

o Code Optimization (less code)

o Random Access
o Easy to traverse data
o Easy to manipulate data
o Easy to sort data etc.

Disadvantages of C++ Array

o Fixed size

Array declaration

Syntax

Data-type arrayName[size]; or

Data-type arrayName[] = {val1, val2, val3};

For example

Int arr[3];// declaring a single dimensional array

 Int arr[3][3]; declaring a multidimensional array

C++ Array Types

There are 2 types of arrays in C++ programming:

1. Single Dimensional Array

2. Multidimensional Array

C++ Single Dimensional Array

Let's see a simple example of C++ array, where we are going to create, initialize and traverse
array.

1. #include <iostream>
2. using namespace std;
3. int main()
4. {
5. int arr[5]={10, 0, 20, 0, 30}; //creating and initializing array
6. //traversing array
7. for (int i = 0; i < 5; i++)
8. {
9. cout<<arr[i]<<"\n";
10. }
11. }

Output:/p>

10
0
20
0
30

C++ Array Example: Traversal using foreach loop

 We can also traverse the array elements using foreach loop. It returns array element one by
one.

1. #include <iostream>
2. using namespace std;
3. int main()
4. {
5. int arr[5]={10, 0, 20, 0, 30}; //creating and initializing array
6. //traversing array
7. for (int i: arr)
8. {
9. cout<<i<<"\n";
10. }
11. }

Output:

10
20
30
40
50

C++ Passing Array to Function

In C++, to reuse the array logic, we can create function. To pass array to function in C++, we
need to provide only array name.

1. functionname(arrayname); //passing array to function

C++ Passing Array to Function Example: print array elements

Let's see an example of C++ function which prints the array elements.

1. #include <iostream>
2. using namespace std;
3. void printArray(int arr[5]);
4. int main()
5. {
6. int arr1[5] = { 10, 20, 30, 40, 50 };
7. int arr2[5] = { 5, 15, 25, 35, 45 };
8. printArray(arr1); //passing array to function
9. printArray(arr2);
10. }
11. void printArray(int arr[5])
12. {
13. cout << "Printing array elements:"<< endl;
14. for (int i = 0; i < 5; i++)
15. {
16. cout<<arr[i]<<"\n";
17. }
18. }

Output:

Printing array elements:

10
20
30
40
50
Printing array elements:
5
15
25
35
45

C++ Passing Array to Function Example: Print minimum number

Let's see an example of C++ array which prints minimum number in an array using function.
1. #include <iostream>
2. using namespace std;
3. void printMin(int arr[5]);
4. int main()
5. {
6. int arr1[5] = { 30, 10, 20, 40, 50 };
7. int arr2[5] = { 5, 15, 25, 35, 45 };
8. printMin(arr1);//passing array to function
9. printMin(arr2);
10. }
11. void printMin(int arr[5])
12. {
13. int min = arr[0];
14. for (int i = 0; i > 5; i++)
15. {
16. if (min > arr[i])
17. {
18. min = arr[i];
19. }
20. }
21. cout<< "Minimum element is: "<< min <<"\n";
22. }

Output:

Minimum element is: 10

Minimum element is: 5

C++ Passing Array to Function Example: Print maximum number

Let's see an example of C++ array which prints maximum number in an array using function.

1. #include <iostream>
2. using namespace std;
3. void printMax(int arr[5]);
4. int main()
5. {
6. int arr1[5] = { 25, 10, 54, 15, 40 };
7. int arr2[5] = { 12, 23, 44, 67, 54 };
8. printMax(arr1); //Passing array to function
9. printMax(arr2);
10. }
11. void printMax(int arr[5])
12. {
13. int max = arr[0];
14. for (int i = 0; i < 5; i++)
15. {
16. if (max < arr[i])
17. {
18. max = arr[i];
19. }
20. }
21. cout<< "Maximum element is: "<< max <<"\n";
22. }

Output:

Maximum element is: 54

Maximum element is: 67

C++ Multidimensional Arrays

The multidimensional array is also known as rectangular arrays in C++. It can be two
dimensional or three dimensional. The data is stored in tabular form (row ∗ column) which is
also known as matrix.

C++ Multidimensional Array Example

 Let's see a simple example of multidimensional array in C++ which declares, initializes and
traverse two dimensional arrays.

1. #include <iostream>
2. using namespace std;
3. int main()
4. {
5. int test[3][3]; //declaration of 2D array
6. test[0][0]=5; //initialization
7. test[0][1]=10;
8. test[1][1]=15;
9. test[1][2]=20;
10. test[2][0]=30;
11. test[2][2]=10;
12. //traversal
13. for(int i = 0; i < 3; ++i)
14. {
15. for(int j = 0; j < 3; ++j)
16. {
17. cout<< test[i][j]<<" ";
18. }
19. cout<<"\n"; //new line at each row
20. }
21. return 0;
22. }

Output:

5 10 0
0 15 20
30 0 10

C++ Multidimensional Array Example: Declaration and initialization at same time

 Let's see a simple example of multidimensional array which initializes array at the time of
declaration.

1. #include <iostream>
2. using namespace std;
3. int main()
4. {
5. int test[3][3] =
6. {
7. {2, 5, 5},
8. {4, 0, 3},
9. {9, 1, 8} }; //declaration and initialization
10. //traversal
11. for(int i = 0; i < 3; ++i)
12. {
13. for(int j = 0; j < 3; ++j)
14. {
15. cout<< test[i][j]<<" ";
16. }
17. cout<<"\n"; //new line at each row
18. }
19. return 0;
20. }

Output:"

255
403
918
 CHAPTER THREE CLASSES AND OBJECTS C++

C++ What are Classes and Objects?

Classes and objects are the two main aspects of object-oriented programming.

Look at the following illustration to see the difference between class and objects:

Another example

So, a class is a template for objects, and an object is an instance of a class.

When the individual objects are created, they inherit all the variables and functions from the
class.
C++ Classes/Objects

C++ is an object-oriented programming language.

Everything in C++ is associated with classes and objects, along with its attributes and
methods. For example: in real life, a car is an object. The car has attributes, such as weight
and color, and methods, such as drive and brake.

Attributes and methods are basically variables and functions that belongs to the class. These
are often referred to as "class members".

A class is a user-defined data type that we can use in our program, and it works as an object
constructor, or a "blueprint" for creating objects.

Create a Class

To create a class, use the class keyword:

Example

Create a class called "MyClass":

class MyClass { // The class
public: // Access specifier
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
};

Example explained

 The class keyword is used to create a class called MyClass.

 The public keyword is an access specifier, which specifies that members (attributes
and methods) of the class are accessible from outside the class. You will learn more
about access specifiers later.
 Inside the class, there is an integer variable myNum and a string variable myString.
When variables are declared within a class, they are called attributes.
  At last, end the class definition with a semicolon ;.

Create an Object

In C++, an object is created from a class. We have already created the class named MyClass,
so now we can use this to create objects.

To create an object of MyClass, specify the class name, followed by the object name.

To access the class attributes (myNum and myString), use the dot syntax (.) on the object:

Example

Create an object called "myObj" and access the attributes:

class MyClass { // The class
public: // Access specifier
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
};

int main() {
MyClass myObj; // Create an object of MyClass

// Access attributes and set values

myObj.myNum = 15;
myObj.myString = "Some text";

// Print attribute values

cout << myObj.myNum << "\n";
cout << myObj.myString;
return 0;
}

Multiple Objects
You can create multiple objects of one class:

Example
// Create a Car class with some attributes
class Car {
public:
string brand;
string model;
int year;
};

int main() {
// Create an object of Car
Car carObj1;
carObj1.brand = "BMW";
carObj1.model = "X5";
carObj1.year = 1999;

// Create another object of Car

Car carObj2;
carObj2.brand = "Ford";
carObj2.model = "Mustang";
carObj2.year = 1969;

// Print attribute values

cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";
cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";
return 0;
}

Class Methods

Methods are functions that belongs to the class.

There are two ways to define functions that belongs to a class:

 Inside class definition

 Outside class definition

In the following example, we define a function inside the class, and we name it "myMethod".

Note: You access methods just like you access attributes; by creating an object of the class
and using the dot syntax (.):

Inside Example
class MyClass { // The class
public: // Access specifier
void myMethod() { // Method/function defined inside the class
cout << "Hello World!";
}
};

int main() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return 0;
}

Try it Yourself »

To define a function outside the class definition, you have to declare it inside the class and
then define it outside of the class. This is done by specifiying the name of the class, followed
the scope resolution :: operator, followed by the name of the function:

Outside Example
class MyClass { // The class
public: // Access specifier
void myMethod(); // Method/function declaration
};
// Method/function definition outside the class
void MyClass::myMethod() {
cout << "Hello World!";
}

int main() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return 0;
}

Parameters

You can also add parameters:

Example
#include <iostream>
using namespace std;

class Car {
public:
int speed(int maxSpeed);
};

int Car::speed(int maxSpeed) {

return maxSpeed;
}

int main() {
Car myObj; // Create an object of Car
cout << myObj.speed(200); // Call the method with an argument
return 0;
}
C++ Constructors

Constructors

A constructor in C++ is a special method that is automatically called when an object of a

class is created.

To create a constructor, use the same name as the class, followed by parentheses ():

Example
class MyClass { // The class
public: // Access specifier
MyClass() { // Constructor
cout << "Hello World!";
}
};

int main() {
MyClass myObj; // Create an object of MyClass (this will call the constructor)
return 0;
}

Constructor Parameters

Constructors can also take parameters (just like regular functions), which can be useful for
setting initial values for attributes.

The following class have brand, model and year attributes, and a constructor with different
parameters. Inside the constructor we set the attributes equal to the constructor parameters
(brand=x, etc). When we call the constructor (by creating an object of the class), we pass
parameters to the constructor, which will set the value of the corresponding attributes to the
same:
Example
class Car { // The class
public: // Access specifier
string brand; // Attribute
string model; // Attribute
int year; // Attribute
Car(string x, string y, int z) { // Constructor with parameters
brand = x;
model = y;
year = z;
}
};

int main() {
// Create Car objects and call the constructor with different values
Car carObj1("BMW", "X5", 1999);
Car carObj2("Ford", "Mustang", 1969);

// Print values
cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";
cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";
return 0;
}

Just like functions, constructors can also be defined outside the class. First, declare the
constructor inside the class, and then define it outside of the class by specifying the name of
the class, followed by the scope resolution :: operator, followed by the name of the
constructor (which is the same as the class):

Example
class Car { // The class
public: // Access specifier
string brand; // Attribute
string model; // Attribute
 int year; // Attribute
Car(string x, string y, int z); // Constructor declaration
};

// Constructor definition outside the class

Car::Car(string x, string y, int z) {
brand = x;
model = y;
year = z;
}

int main() {
// Create Car objects and call the constructor with different values
Car carObj1("BMW", "X5", 1999);
Car carObj2("Ford", "Mustang", 1969);

// Print values
cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";
cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";
return 0;
}

C++ Access Specifiers

Access Specifiers

By now, you are quite familiar with the public keyword that appears in all of our class
examples:

Example
class MyClass { // The class
public: // Access specifier
// class members goes here
};

The public keyword is an access specifier. Access specifiers define how the members
(attributes and methods) of a class can be accessed. In the example above, the members
are public - which means that they can be accessed and modified from outside the code.

However, what if we want members to be private and hidden from the outside world?

In C++, there are three access specifiers:

 public - members are accessible from outside the class

 private - members cannot be accessed (or viewed) from outside the class
 protected - members cannot be accessed from outside the class, however, they can be
accessed in inherited classes. You will learn more about Inheritance later.

In the following example, we demonstrate the differences

between public and private members:

Example
class MyClass {
public: // Public access specifier
int x; // Public attribute
private: // Private access specifier
int y; // Private attribute
};

int main() {
MyClass myObj;
myObj.x = 25; // Allowed (public)
myObj.y = 50; // Not allowed (private)
return 0;
}

If you try to access a private member, an error occurs:

error: y is private
Note: It is possible to access private members of a class using a public method inside the
same class. See the next chapter (Encapsulation) on how to do this.

Tip: It is considered good practice to declare your class attributes as private (as often as you
can). This will reduce the possibility of yourself (or others) to mess up the code. This is also
the main ingredient of the Encapsulation concept, which you will learn more about in the next
chapter.

Note: By default, all members of a class are private if you don't specify an access specifier:

Example
class MyClass {
int x; // Private attribute
int y; // Private attribute
};

C++ Encapsulation

Encapsulation

The meaning of Encapsulation, is to make sure that "sensitive" data is hidden from users. To
achieve this, you must declare class variables/attributes as private (cannot be accessed from
outside the class). If you want others to read or modify the value of a private member, you
can provide public get and set methods.

Access Private Members

To access a private attribute, use public "get" and "set" methods:

Example
#include <iostream>
using namespace std;
class Employee {
private:
// Private attribute
int salary;

public:
// Setter
void setSalary(int s) {
salary = s;
}
// Getter
int getSalary() {
return salary;
}
};

int main() {
Employee myObj;
myObj.setSalary(50000);
cout << myObj.getSalary();
return 0;
}

Example explained

The salary attribute is private, which have restricted access.

The public setSalary() method takes a parameter (s) and assigns it to the salary attribute
(salary = s).

The public getSalary() method returns the value of the private salary attribute.
Inside main(), we create an object of the Employee class. Now we can use
the setSalary() method to set the value of the private attribute to 50000. Then we call
the getSalary() method on the object to return the value.

Why Encapsulation?

 It is considered good practice to declare your class attributes as private (as often as
you can). Encapsulation ensures better control of your data, because you (or others)
can change one part of the code without affecting other parts
 Increased security of data

C++ Inheritance

Inheritance

In C++, it is possible to inherit attributes and methods from one class to another. We group
the "inheritance concept" into two categories:

 derived class (child) - the class that inherits from another class
 base class (parent) - the class being inherited from

To inherit from a class, use the : symbol.

In the example below, the Car class (child) inherits the attributes and methods from
the Vehicle class (parent):

Example
// Base class
class Vehicle {
public:
string brand = "Ford";
void honk() {
cout << "Tuut, tuut! \n" ;
 }
};

// Derived class
class Car: public Vehicle {
public:
string model = "Mustang";
};

int main() {
Car myCar;
myCar.honk();
cout << myCar.brand + " " + myCar.model;
return 0;
}

Why And When To Use "Inheritance"?

- It is useful for code reusability: reuse attributes and methods of an existing class when you
create a new class.

C++ Multilevel Inheritance

Multilevel Inheritance

A class can also be derived from one class, which is already derived from another class.

In the following example, MyGrandChild is derived from class MyChild (which is derived
from MyClass).

Example
// Base class (parent)
class MyClass {
public:
 void myFunction() {
cout << "Some content in parent class." ;
}
};

// Derived class (child)

class MyChild: public MyClass {
};

// Derived class (grandchild)

class MyGrandChild: public MyChild {
};

int main() {
MyGrandChild myObj;
myObj.myFunction();
return 0;
}

C++ Multiple Inheritance

Multiple Inheritance

A class can also be derived from more than one base class, using a comma-separated list:

Example
// Base class
class MyClass {
public:
void myFunction() {
cout << "Some content in parent class." ;
}
};
// Another base class
class MyOtherClass {
public:
void myOtherFunction() {
cout << "Some content in another class." ;
}
};

// Derived class
class MyChildClass: public MyClass, public MyOtherClass {
};

int main() {
MyChildClass myObj;
myObj.myFunction();
myObj.myOtherFunction();
return 0;
}

C++ Inheritance Access

Access Specifiers

You learned from the Access Specifiers chapter that there are three specifiers available in
C++. Until now, we have only used public (members of a class are accessible from outside
the class) and private (members can only be accessed within the class). The third
specifier, protected, is similar to private, but it can also be accessed in the inherited class:

Example
// Base class
class Employee {
protected: // Protected access specifier
 int salary;
};

// Derived class
class Programmer: public Employee {
public:
int bonus;
void setSalary(int s) {
salary = s;
}
int getSalary() {
return salary;
}
};

int main() {
Programmer myObj;
myObj.setSalary(50000);
myObj.bonus = 15000;
cout << "Salary: " << myObj.getSalary() << "\n";
cout << "Bonus: " << myObj.bonus << "\n";
return 0;
}

C++ Polymorphism

Polymorphism

Polymorphism means "many forms", and it occurs when we have many classes that are
related to each other by inheritance.
Like we specified in the previous chapter; Inheritance lets us inherit attributes and methods
from another class. Polymorphism uses those methods to perform different tasks. This
allows us to perform a single action in different ways.

For example, think of a base class called Animal that has a method called animalSound().
Derived classes of Animals could be Pigs, Cats, Dogs, Birds - And they also have their own
implementation of an animal sound (the pig oinks, and the cat meows, etc.):

Example
// Base class
class Animal {
public:
void animalSound() {
cout << "The animal makes a sound \n";
}
};

// Derived class
class Pig : public Animal {
public:
void animalSound() {
cout << "The pig says: wee wee \n";
}
};

// Derived class
class Dog : public Animal {
public:
void animalSound() {
cout << "The dog says: bow wow \n";
}
};

Remember from the Inheritance chapter that we use the : symbol to inherit from a class.
Now we can create Pig and Dog objects and override the animalSound() method:

Example
// Base class
class Animal {
public:
void animalSound() {
cout << "The animal makes a sound \n";
}
};

// Derived class
class Pig : public Animal {
public:
void animalSound() {
cout << "The pig says: wee wee \n";
}
};

// Derived class
class Dog : public Animal {
public:
void animalSound() {
cout << "The dog says: bow wow \n";
}
};

int main() {
Animal myAnimal;
Pig myPig;
Dog myDog;

myAnimal.animalSound();
myPig.animalSound();
 myDog.animalSound();
return 0;
}

Why And When To Use "Inheritance" and "Polymorphism"?

- It is useful for code reusability: reuse attributes and methods of an existing class when you
create a new class.

C++ Files

C++ Files

The fstream library allows us to work with files.

To use the fstream library, include both the standard <iostream> AND the <fstream> header
file:

Example
#include <iostream>
#include <fstream>

There are three classes included in the fstream library, which are used to create, write or read
files:

Class Description

ofstream Creates and writes to files

ifstream Reads from files

fstream A combination of ofstream and ifstream: creates, reads, and writes to files
Create and Write To a File

To create a file, use either the ofstream or fstream class, and specify the name of the file.

To write to the file, use the insertion operator (<<).

Example
#include <iostream>
#include <fstream>
using namespace std;

int main() {
// Create and open a text file
ofstream MyFile("filename.txt");

// Write to the file

MyFile << "Files can be tricky, but it is fun enough!";

// Close the file

MyFile.close();
}

Why do we close the file?

It is considered good practice, and it can clean up unnecessary memory space.

Read a File

To read from a file, use either the ifstream or fstream class, and the name of the file.

Note that we also use a while loop together with the getline() function (which belongs to
the ifstream class) to read the file line by line, and to print the content of the file:

Example
// Create a text string, which is used to output the text file
string myText;
// Read from the text file
ifstream MyReadFile("filename.txt");

// Use a while loop together with the getline() function to read the file line by line
while (getline (MyReadFile, myText)) {
// Output the text from the file
cout << myText;
}

// Close the file

MyReadFile.close();