need for object-oriented paradigm - kmit
TRANSCRIPT
Need for object-oriented paradigm
it produces reusable code/objects because of encapsulation and inheritance.
the data is protected because it can be altered only by the encapsulated methods.
it is more efficient to write programs which use pre-defined objects.
the storage structure and/or procedures within an object type could be altered if required without affecting
programs that make use of that object type.
new functions can easily be added to objects by using inheritance
the code produced is likely to contain fewer errors because pretested objects are being used.
less maintenance effort will be required by the developer because objects can be reused.
Differences between OOP and Procedure oriented programming
Basis For comparison POP OOP
Basic Procedure/Structure oriented . Object oriented.
Approach Top-down. Bottom-up.
Basis
Main focus is on "how to get the task done"
i.e. on the procedure or structure of a
program .
Main focus is on 'data security'. Hence,
only objects are permitted to access the
entities of a class.
Division Large program is divided into units called
functions. Entire program is divided into objects.
Entity accessing mode No access specifier observed. Access specifier are "public", "private",
"protected".
Overloading/Polymorphism Neither it overload functions nor operators. It overloads functions, constructors, and
operators.
Inheritance Their is no provision of inheritance. Inheritance achieved in three modes
public private and protected.
Data hiding & security There is no proper way of hiding the data, so
data is insecure
Data is hidden in three modes public,
private, and protected. hence data security
increases.
Data sharing Global data is shared among the functions in
the program.
Data is shared among the objects through
the member functions.
Friend functions/classes No concept of friend function.
Classes or function can become a friend
of another class with the keyword
"friend".
Note: "friend" keyword is used only in
c++
Virtual classes/ function No concept of virtual classes . Concept of virtual function appear during
inheritance.
Example C, VB, FORTRAN, Pascal C++, JAVA, VB.NET, C#.NET.
Overview of OOP concepts-
Object
Any entity that has state and behavior is known as an object. For example: chair, pen, table, keyboard, bike etc. It
can be physical and logical.
Class
Collection of objects is called class. It is a logical entity.
Inheritance
When one object acquires all the properties and behaviours of parent object i.e. known as inheritance. It
provides code reusability. It is used to achieve runtime polymorphism.
Polymorphism
When one task is performed by different ways i.e. known as polymorphism. For example: to convince the
customer differently, to draw something e.g. shape or rectangle etc.
In C++, we use Function overloading and Function overriding to achieve polymorphism.
Abstraction
Hiding internal details and showing functionality is known as abstraction. For example: phone call, we don't
know the internal processing.
In C++, we use abstract class and interface to achieve abstraction.
Encapsulation
Binding (or wrapping) code and data together into a single unit is known as encapsulation. For example:
capsule, it is wrapped with different medicines.
Structure of a CPP program
Data types in C++ are categorised in three groups: Built-in, user-defined and Derived.
What are Variables?
Variables are used in C++ where you will need to store any type of values within a program and
whose value can be changed during the program execution. These variables can be declared in
various ways each having different memory requirements and storing capability. Variables are
the name of memory locations that are allocated by compilers, and the allocation is done based
on the data type used for declaring the variable.
Variable Definition in C++
A variable definition means that the programmer writes some instructions to tell the compiler to
create the storage in a memory location. The syntax for defining variables is:
Syntax:
data_type variable_name;
data_type variable_name, variable_name, variable_name;
/* variable definition */int width, height, age;
char letter;
float area;
double d;
Variable Initialization in C++
Variables are declared in the above example, but none of them has been assigned any value.
Variables can be initialized, and the initial value can be assigned along with their declaration.
Syntax:
data_type variable_name = value;
Example:
/* variable definition and initialization */int width, height=5, age=32;
char letter='A';
float area;
double d;
/* actual initialization */width = 10;
area = 26.5;
Rules of Declaring variables in C++
A variable name can consist of Capital letters A-Z, lowercase letters a-z, digits 0-9, and
the underscore character.
The first character must be a letter or underscore.
Blank spaces cannot be used in variable names.
Special characters like #, $ are not allowed.
C++ keywords cannot be used as variable names.
Variable names are case-sensitive.
A variable name can be consisting of 31 characters only if we declare a variable more
than one characters compiler will ignore after 31 characters.
Variable type can be bool, char, int, float, double, void or wchar_t.
Here's a Program to Show the Usage of Variables in C++
Example:
#include <iostream>
using namespace std;
int main()
{
int x = 5;
int y = 2;
int Result;
Result = x * y;
cout << Result;
}
Another program showing how Global variables are declared and used within a program:
#include <iostream>
using namespace std;
// Global Variable declaration:
int x, y;
float f;
int main()
{
// Local variable
int tot;
float f;
x = 10;
y = 20;
tot = x + y;
cout << tot;
cout << endl;
f = 70.0 / 3.0;
cout << f;
cout << endl;
}
Expressions
A combination of variables, constants and operators that represents a computation forms an
expression. Depending upon the type of operands involved in an expression or the result
obtained after evaluating expression, there are different categories of an expression. These
categories of an expression are discussed here. Constant expressions: The expressions that
comprise only constant values are called constant expressions. Some examples of constant
expressions are 20, ‘ a‘ and 2/5+30 .
• Integral expressions: The expressions that produce an integer value as output after performing
all types of conversions are called integral expressions. For example, x, 6*x-y and 10 +int (5.0)
are integral expressions. Here, x and yare variables of type into
Float expressions: The expressions that produce floating-point value as output after performing
all types of conversions are called float expressions. For example, 9.25, x-y and 9+ float (7) are
float expressions. Here, x 'and yare variables of type float.
• Relational or Boolean expressions: The expressions that produce a bool type value, that is,
either true or false are called relational or Boolean expressions. For example, x + y<100, m +
n==a-b and a>=b + c .are relational expressions.
• Logical expressions: The expressions that produce a bool type value after combining two or
more relational expressions are called logical expressions. For example, x==5 &&m==5 and
y>x I I m<=n are logical expressions.
• Bitwise expressions: The expressions which manipulate data at bit level are called bitwise
expressions. For example, a >> 4 and b<< 2 are bitwise expressions.
Operators in C / C++
We can define operators as symbols that helps us to perform specific mathematical and logical
computations on operands. In other words we can say that an operator operates the operands.
For example, consider the below statement:
c = a + b;
Arithmetic Operators: These are the operators used to perform arithmetic/mathematical
operations on operands. Examples: (+, -, *, /, %,++,–).
Arithmetic operator are of two types:
1. Unary Operators: Operators that operates or works with a single operand are unary
operators.
For example: (++ , –)
2. Binary Operators: Operators that operates or works with two operands are binary
operators.For example: (+ , – , * , /)
To learn Arithmetic Operators in details visit this link.
Relational Operators: Relational operators are used for comparison of the values of two
operands. For example: checking if one operand is equal to the other operand or not, an operand
is greater than the other operand or not etc. Some of the relational operators are (==, >= , <= ).
To learn about each of these operators in details go to this link.
Logical Operators: Logical Operators are used to combine two or more
conditions/constraints or to complement the evaluation of the original condition in consideration.
The result of the operation of a logical operator is a boolean value either true or false. To learn
about different logical operators in details please visit this link.
Bitwise Operators: The Bitwise operators is used to perform bit-level operations on the
operands. The operators are first converted to bit-level and then calculation is performed on the
operands. The mathematical operations such as addition , subtraction , multiplication etc. can be
performed at bit-level for faster processing. To learn bitwise operators in details, visit this link.
Assignment Operators: Assignment operators are used to assign value to a variable. The left
side operand of the assignment operator is a variable and right side operand of the assignment
operator is a value. The value on the right side must be of the same data-type of variable on the
left side otherwise the compiler will raise an error.
Different types of assignment operators are shown below:
“=”: This is the simplest assignment operator. This operator is used to assign the value on
the right to the variable on the left.
For example:
a = 10;
b = 20;
ch = 'y';
“+=”:This operator is combination of ‘+’ and ‘=’ operators. This operator first adds the
current value of the variable on left to the value on right and then assigns the result to the
variable on the left.
Example:
(a += b) can be written as (a = a + b)
If initially value stored in a is 5. Then (a += 6) = 11.
“-=”:This operator is combination of ‘-‘ and ‘=’ operators. This operator first subtracts
the value on right from the current value of the variable on left and then assigns the result
to the variable on the left.
Example:
(a -= b) can be written as (a = a - b)
If initially value stored in a is 8. Then (a -= 6) = 2.
“*=”:This operator is combination of ‘*’ and ‘=’ operators. This operator first multiplies
the current value of the variable on left to the value on right and then assigns the result to
the variable on the left.
Example:
(a *= b) can be written as (a = a * b)
If initially value stored in a is 5. Then (a *= 6) = 30.
“/=”:This operator is combination of ‘/’ and ‘=’ operators. This operator first divides the
current value of the variable on left by the value on right and then assigns the result to the
variable on the left.
Example:
(a /= b) can be written as (a = a / b)
If initially value stored in a is 6. Then (a /= 2) = 3.
Other Operators: Apart from the above operators there are some other operators available in
C or C++ used to perform some specific task. Some of them are discussed here:
sizeof operator: sizeof is a much used in the C/C++ programming language. It is a
compile time unary operator which can be used to compute the size of its operand. The
result of sizeof is of unsigned integral type which is usually denoted by size_t. Basically,
sizeof operator is used to compute the size of the variable. To learn about sizeof operator
in details you may visit this link.
Comma Operator: The comma operator (represented by the token ,) is a binary operator
that evaluates its first operand and discards the result, it then evaluates the second
operand and returns this value (and type). The comma operator has the lowest precedence
of any C operator. Comma acts as both operator and separator. To learn about comma in
details visit this link.
Conditional Operator: Conditional operator is of the form Expression1 ? Expression2 :
Expression3 . Here, Expression1 is the condition to be evaluated. If the
condition(Expression1) is True then we will execute and return the result of Expression2
otherwise if the condition(Expression1) is false then we will execute and return the result
of Expression3. We may replace the use of if..else statements by conditional operators.
To learn about conditional operators in details, visit this link.
Operator precedence chart The below table describes the precedence order and associativity of operators in C / C++
. Precedence of operator decreases from top to bottom.
Expression evaluation in CPP
Priority: this represents evaluation of expression starts from what operator.
Associativity:
It represents which operator should be evaluated first if an expression is containing more than
one operator with same priority.
Operator Priority Associativity
{}, (), [] 1 Left to right
++, --, ! 2 Right to left
*, /, % 3 Left to right
+, - 4 Left to right
<, <=, >, >=, ==, != 5 Left to right
&& 6 Left to right
|| 7 Left to right
?: 8 Right to left
=, +=, -=, *=, /=, %= 9 Right to left
Example 1:
Example 2
Type Conversion in C++
A type cast is basically a conversion from one type to another. There are two types of type
conversion:
Implicit Type Conversion Also known as ‘automatic type conversion’.
Done by the compiler on its own, without any external trigger from the user.
Generally takes place when in an expression more than one data type is present. In such
condition type conversion (type promotion) takes place to avoid lose of data.
All the data types of the variables are upgraded to the data type of the variable with
largest data type.
It is possible for implicit conversions to lose information, signs can be lost (when signed
is implicitly converted to unsigned), and overflow can occur (when long long is implicitly
converted to float).
#include <iostream>
using namespace std;
int main()
{
int x = 10; // integer x
char y = 'a'; // character c
// y implicitly converted to int. ASCII
// value of 'a' is 97
x = x + y;
// x is implicitly converted to float
float z = x + 1.0;
cout << "x = " << x << endl
<< "y = " << y << endl
<< "z = " << z << endl;
return 0;
}
Explicit Type Conversion: This process is also called type casting and it is user-defined. Here
the user can typecast the result to make it of a particular data type.
Converting by assignment: This is done by explicitly defining the required type in front of the
expression in parenthesis. This can be also considered as forceful casting.
(type) expression
#include <iostream>
using namespace std;
int main()
{
double x = 1.2;
// Explicit conversion from double to int
int sum = (int)x + 1;
cout << "Sum = " << sum;
return 0;
}
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 −
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;
}
Output of the above program:
Value of var variable: 20
Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20
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 to 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++ References
A reference variable is an alias, that is, another name for an already existing variable. Once a
reference is initialized with a variable, either the variable name or the reference name may be
used to refer to the variable.
Creating References in C++
Think of a variable name as a label attached to the variable's location in memory. You can then
think of a reference as a second label attached to that memory location. Therefore, you can
access the contents of the variable through either the original variable name or the reference. For
example, suppose we have the following example −
int i = 17;
We can declare reference variables for i as follows.
int& r = i;
#include <iostream>
using namespace std;
int main () {
// declare simple variables
int i;
double d;
// declare reference variables
int& r = i;
double& s = d;
i = 5;
cout << "Value of i : " << i << endl;
cout << "Value of i reference : " << r << endl;
d = 11.7;
cout << "Value of d : " << d << endl;
cout << "Value of d reference : " << s << endl;
return 0;
}
Output of the program:
Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7
References are usually used for function argument lists and function return values. So following
are two important subjects related to C++ references which should be clear to a C++ programmer
–
Sr.No Concept & Description
1 References as Parameters
C++ supports passing references as function parameter more safely than parameters.
2 Reference as Return Value
You can return reference from a C++ function like any other data type.
Arrays
An array is a collection of elements of the same type placed in contiguous memory locations that
can be individually referenced by using an index to a unique identifier.
Five values of type int can be declared as an array without having to declare five different
variables (each with its own identifier).
For example, a five element integer array foo may be logically represented as;
where each blank panel represents an element of the array. In this case, these are values of type
int. These elements are numbered from 0 to 4, with 0 being the first while 4 being the last; In
C++, the index of the first array element is always zero. As expected, an n array must be declared
prior its use. A typical declaration for an array in C++ is:
type name [elements];
Initializing arrays
By default, are left uninitialized. This means that none of its elements are set to anyparticular
value; their contents are undetermined at the point the array is declared.
The initializer can even have no values, just the braces:
int baz [5] = { };
This creates an array of five int values, each initialized with a value of zero:
But, the elements in an array can be explicitly initialized to specific values when it is declared,
by enclosing those initial values in braces {}. For example:
int foo [5] = { 16, 2, 77, 40, 12071 };
This statement declares an array that can be represented like this:
The number of values between braces {} shall not be greater than the number of elements in the
array. For example, in the example above, foo was declared having 5 elements (as specified by
the number enclosed in square brackets, []), and the braces {} contained exactly 5 values, one for
each element. If declared with less, the remaining elements are set to their default values (which
for fundamental types, means they are filled with zeroes). For example:
int bar [5] = { 10, 20, 30 };
Will create an array like this:
When an initialization of values is provided for an array, C++ allows the possibility of leaving
the square brackets empty[]. In this case, the compiler will assume automatically a size for the
array that matches the number of values included between the braces {}:
int foo [] = { 16, 2, 77, 40, 12071 };
After this declaration, array foo would be five int long, since we have provided five initialization
values.
Both these statements are equivalent:
int foo[] = { 10, 20, 30 };
int foo[] { 10, 20, 30 };
Pointers and Arrays: Pointers are the variables that hold address. Not only can pointers store
address of a single variable, it can also store address of cells of an array.
int* ptr;
int a[5];
ptr = &a[2]; // &a[2] is the address of third element of a[5].
Suppose, pointer needs to point to the fourth element of an array, that is, hold address of fourth
array element in above case.
Since ptr points to the third element in the above example, ptr + 1 will point to the fourth
element.
You may think, ptr + 1 gives you the address of next byte to the ptr. But it's not correct.
This is because pointer ptr is a pointer to an int and size of int is fixed for a operating system
(size of int is 4 byte of 64-bit operating system). Hence, the address between ptr and ptr + 1
differs by 4 bytes.
If pointer ptr was pointer to char then, the address between ptr and ptr + 1
would have differed by 1 byte since size of a character is 1 byte.
#include <iostream>
using namespace std;
int main()
{
float arr[5];
float *ptr;
cout << "Displaying address using arrays: " << endl;
for (int i = 0; i < 5; ++i)
{
cout << "&arr[" << i << "] = " << &arr[i] << endl;
}
// ptr = &arr[0]
ptr = arr;
cout<<"\nDisplaying address using pointers: "<< endl;
for (int i = 0; i < 5; ++i)
{
cout << "ptr + " << i << " = "<< ptr + i << endl;
}
return 0;
}
C++ Program to display address of array elements using pointer notation.
#include <iostream>
using namespace std;
int main() {
float arr[5];
cout<<"Displaying address using pointers notation: "<< endl;
for (int i = 0; i < 5; ++i) {
cout << arr + i <<endl;
}
return 0;
}
Displaying address using pointers notation:
0x7fff5fbff8a0
0x7fff5fbff8a4
0x7fff5fbff8a8
0x7fff5fbff8ac
0x7fff5fbff8b0
C++ Program to insert and display data entered by using pointer notation.
#include <iostream>
using namespace std;
int main() {
float arr[5];
// Inserting data using pointer notation
cout << "Enter 5 numbers: ";
for (int i = 0; i < 5; ++i) {
cin >> *(arr + i) ;
}
// Displaying data using pointer notation
cout << "Displaying data: " << endl;
for (int i = 0; i < 5; ++i) {
cout << *(arr + i) << endl ;
}
return 0;
}
Enter 5 numbers: 2.5
3.5
4.5
5
2
Displaying data:
2.5
3.5
4.5
5
2
Strings in CPP
String is a collection of characters. There are two types of strings commonly
used in C++ programming language:
C++ program to display a string entered by user.
#include <iostream>
using namespace std;
int main()
{
char str[100];
cout << "Enter a string: ";
cin >> str;
cout << "You entered: " << str << endl;
cout << "\nEnter another string: ";
cin >> str;
cout << "You entered: "<<str<<endl;
return 0;
}
Enter a string: C++
You entered: C++
Enter another string: Programming is fun.
You entered: Programming
C++ program to read and display an entire line entered by user.
#include <iostream>
using namespace std;
int main()
{
char str[100];
cout << "Enter a string: ";
cin.get(str, 100);
cout << "You entered: " << str << endl;
return 0;
}
Enter a string: Programming is fun.
You entered: Programming is fun.
string Object
In C++, you can also create a string object for holding strings.
Unlike using char arrays, string objects has no fixed length, and can be extended as per your
requirement.
#include <iostream>
using namespace std;
int main()
{
// Declaring a string object
string str;
cout << "Enter a string: ";
getline(cin, str);
cout << "You entered: " << str << endl;
return 0;
}
Enter a string: Programming is fun.
You entered: Programming is fun.
Passing String to a Function
Strings are passed to a function in a similar way arrays are passed to a function.
#include <iostream>
using namespace std;
void display(char *);
void display(string);
int main()
{
string str1;
char str[100];
cout << "Enter a string: ";
getline(cin, str1);
cout << "Enter another string: ";
cin.get(str, 100, '\n');
display(str1);
display(str);
return 0;
}
void display(char s[])
{
cout << "Entered char array is: " << s << endl;
}
void display(string s)
{
cout << "Entered string is: " << s << endl;
}
Enter a string: Programming is fun.
Enter another string: Really?
Entered string is: Programming is fun.
Entered char array is: Really?
In the above program, two strings are asked to enter. These are stored in str and str1 respectively,
where str is a char array and str1 is a string object. Then, we have two functions display()
that outputs the string onto the string. The only difference between the two functions is the
parameter. The first display() function takes char array as a parameter, while the second takes
string as a parameter.
Find Frequency of Characters of a String Object #include <iostream>
using namespace std;
int main()
{
string str = "C++ Programming is awesome";
char checkCharacter = 'a';
int count = 0;
for (int i = 0; i < str.size(); i++)
{
if (str[i] == checkCharacter)
{
++ count;
}
}
cout << "Number of " << checkCharacter << " = " << count;
return 0;
}
Length of String Object
You can get the length of a string object by using a size() function or a length() function.
The size() and length() functions are just synonyms and they both do exactly same thing.
#include <iostream>
using namespace std;
int main()
{
string str = "C++ Programming";
// you can also use str.length()
cout << "String Length = " << str.size();
return 0;
}
Output
String Length = 15
To get the length of a C-string string, strlen() function is used.
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
char str[] = "C++ Programming is awesome";
// you can also use str.length()
cout << "String Length = " << strlen(str);
return 0;
}
Output
String Length = 26
C++ Structures Structure is a collection of variables of different data types under a single
name. It is similar to a class in that, both holds a collecion of data of
different data types.
For example: You want to store some information about a person: his/her name,
citizenship number and salary. You can easily create different variables
name, citNo, salary to store these information separately.
However, in the future, you would want to store information about multiple persons. Now, you'd
need to create different variables for each information per person: name1, citNo1, salary1,
name2, citNo2, salary2
You can easily visualize how big and messy the code would look. Also, since no relation
between the variables (information) would exist, it's going to be a daunting task.
A better approach will be to have a collection of all related information under a single name
Person, and use it for every person. Now, the code looks much cleaner, readable and efficient as
well.
This collection of all related information under a single name Person is a structure.
How to declare a structure in C++ programming? struct Person
{
char name[50];
int age;
float salary;
};
When a structure is created, no memory is allocated.
How to access members of a structure?
The members of structure variable is accessed using a dot (.) operator.
Suppose, you want to access age of structure variable bill and assign it 50 to it. You can perform
this task by using following code below:
bill.age = 50;
C++ Program to assign data to members of a structure variable and display it.
#include <iostream>
using namespace std;
struct Person
{
char name[50];
int age;
float salary;
};
int main()
{
Person p1;
cout << "Enter Full name: ";
cin.get(p1.name, 50);
cout << "Enter age: ";
cin >> p1.age;
cout << "Enter salary: ";
cin >> p1.salary;
cout << "\nDisplaying Information." << endl;
cout << "Name: " << p1.name << endl;
cout <<"Age: " << p1.age << endl;
cout << "Salary: " << p1.salary;
return 0;
}
Output:
Enter Full name: Magdalena Dankova
Enter age: 27
Enter salary: 1024.4
Displaying Information.
Name: Magdalena Dankova
Age: 27
Salary: 1024.4
Store and Display Information Using Structure #include <iostream>
using namespace std;
struct student
{
char name[50];
int roll;
float marks;
};
int main()
{
student s;
cout << "Enter information," << endl;
cout << "Enter name: ";
cin >> s.name;
cout << "Enter roll number: ";
cin >> s.roll;
cout << "Enter marks: ";
cin >> s.marks;
cout << "\nDisplaying Information," << endl;
cout << "Name: " << s.name << endl;
cout << "Roll: " << s.roll << endl;
cout << "Marks: " << s.marks << endl;
return 0;
}
Enter information,
Enter name: Bill
Enter roll number: 4
Enter marks: 55.6
Displaying Information,
Name: Bill
Roll: 4
Marks: 55.6
Control Statements in C++
Control statements are elements in the source code that control the flow of
program execution. They include blocks using { and } brackets, loops using
for, while and do while, and decision-making using if and switch. There's
also goto. There are two types of control statements: conditional and
unconditional.
Conditional Statements in C++
At times, a program needs to execute depending on a particular condition. Conditional
statements are executed when one or more conditions are satisfied. The most common of these
conditional statements is the if statement, which takes the form:
if (condition)
{
statement(s);
}
This statement executes whenever the condition is true.
C++ uses many other conditional statements including:
if-else: An if-else statement operates on an either/or basis. One statement is executed if
the condition is true; another is executed if the condition is false.
if-else if-else: This statement chooses one of the statements available depending on the
condition. If no conditions are true, the else statement at the end is executed.
while: While repeats a statement as long as a given statement is true.
do while: A do while statement is similar to a while statement with the addition that the
condition is checked at the end.
for: A for statement repeats a statement as long as the condition is satisfied.
Unconditional Control Statements
Unconditional control statements do not need to satisfy any condition. They immediately move
control from one part of the program to another part. Unconditional statements in C++ include:
goto: A goto statement directs control to another part of the program.
break: A break statement terminates a loop (a repeated structure)
continue: A continue statement is used in loops to repeat the loop for the next value by
transferring control back to the beginning of the loop and ignoring the statements that
come after it.
These statements are executed when one or more conditions is/are satisfied. C++ supports
many such statements. These statements are listed below with a brief description.
if:- The statement following the if statement is executed when the condition given is true.
if(condition)
s1;
s2;
When the condition is true statement s1 and then s2 is executed. If the
condition is false only s2 is executed. If we want to execute more than 1 statements
whencondition is true then we should write all those statements within braces {} after if
if(condition)
{
s1;
s2;
}
s3;
when the condition is true statement s1, s2 and then s3 is executed. If the condition isfalse
only s3 is executed
if-else:- Also known as either or. This statement is used to select one statement and
ignore the other statements.
if(condition)
s1;
else
s2;
when the condition is true statement s1 is executed. If the condition is false s2is
executed. Thus one of the statements, either s1 or s2 is always executed
if-else if-else:- It is a branching statement which can choose and execute on of
thestatements available depending upon the condition.
if(condition1)
s1;
else if(condition2)
s2;
else
s3;
when the condition1 is true statement s1 is executed and rest are ignored.
Whencondition1 is false condition2 is verified. If condition2 is true statement s2 is
exected and other statements are ignored and so on. Thus only one statement is executed
fro the top, depending upon the condition. The statement following else is executed when
allthe conditions are false. However else clause is optional.
while:- It is a repeated structure statement which repeats a statement given as long as
thecondition is true.
while(condition)
statement1;
statement1 is executed till the condition is true.
do while:- Like while statement it repeats a statement given as long as the condition
issatisfied unlike in while statement the condition is checked at the end of the structure.
do
{
statement1;
}
while(condition);
statement1 is executed till the condition is true.
for:- It is a repeated structure which can repeat a statement as long as the given
conditionis satisfied.
for(statement1; condition; statement2)
statement3;
where statement1 initialises control variable, condition is used to check
whetherstatement written after loop can be repeated or not , statement2 is used to modify
the conrol variable. Statement3 is a simple statement (having only one statement) or
compund statement (a set of statements written within braces {} ) which can be repeated
as log as condition is true or satisfied.
gotoxy(x,y):- This function moves the cursor to the xth
column of the yth
row i.e. it
fixesthe displaying position at xth
column of yth
row. Its header file is <conio.h>
switch:- It is a multi branch statement which can be used to select and execute one of
theavailable statements.
switch(value)
{
case 1: statement 1; break;
case 2: statement 2; break;
case n: statement n; break;
default: statement d;
}
Where value can be a variable of type numeric or character. The case label 1 to n can
alsobe written with constant identifiers.
When the value assigned matches with case label 1 statement 1 is executed. The
break statement written after statement 1 transfers the control out of the switch statement.
When the value doesn’t match with case label 1 then it checks with case label 2 and so
on. When the value assigned doesn’t match with any of the case labels (1 to n) then the
default clause is considered and the statement d is executed.
Default clause is optional like else clause in if-else-if-else statement.
C++ Functions
In programming, function refers to a segment that groups code to perform a specific task.
Depending on whether a function is predefined or created by programmer; there are two types of
function:
1. Library Function
2. User-defined Function
Library Function
Library functions are the built-in function in C++ programming.
Programmer can use library function by invoking function directly; they don't need to write it
themselves.
Example program on usage of library functions
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
double number, squareRoot;
cout << "Enter a number: ";
cin >> number;
// sqrt() is a library function to calculate square root
squareRoot = sqrt(number);
cout << "Square root of " << number << " = " << squareRoot;
return 0;
}
Enter a number: 26
Square root of 26 = 5.09902
User-defined Function
C++ allows programmer to define their own function.
A user-defined function groups code to perform a specific task and that group of code is given a
name(identifier).
When the function is invoked from any part of program, it all executes the codes defined in the
body of function.
How user-defined function works in C Programming?
User Defined Function Example Program
#include <iostream>
using namespace std;
// Function prototype (declaration)
int add(int, int);
int main()
{
int num1, num2, sum;
cout<<"Enters two numbers to add: ";
cin >> num1 >> num2;
// Function call
sum = add(num1, num2);
cout << "Sum = " << sum;
return 0;
}
// Function definition
int add(int a, int b)
{
int add;
add = a + b;
// Return statement
return add;
}
Enters two integers: 8
-4
Sum = 4
Passing Arguments to Function
In programming, argument (parameter) refers to the data which is passed to a function (function
definition) while calling it.
In the above example, two variables, num1 and num2 are passed to function during function call.
These arguments are known as actual arguments.
The value of num1 and num2 are initialized to variables a and b respectively. These arguments a
and b are called formal arguments.
This is demonstrated in figure below:
Notes on passing arguments
The numbers of actual arguments and formals argument should be the same. (Exception: Function Overloading)
The type of first actual argument should match the type of first formal argument. Similarly, type of second actual argument should match the type of second formal argument and so on.
You may call function a without passing any argument. The number(s) of argument passed to a function depends on how programmer want to solve the problem.
You may assign default values to the argument. These arguments are known as default arguments.
In the above program, both arguments are of int type. But it's not necessary to have both arguments of same type.
Return Statement A function can return a single value to the calling program using return statement.
In the above program, the value of add is returned from user-defined function to the
calling program using statement below: return add;
The figure below demonstrates the working of return statement.
Prime Numbers Between two Intervals using functions #include <iostream>
using namespace std;
int checkPrimeNumber(int);
int main()
{
int n1, n2;
bool flag;
cout << "Enter two positive integers: ";
cin >> n1 >> n2;
cout << "Prime numbers between " << n1 << " and " << n2 << " are: ";
for(int i = n1+1; i < n2; ++i)
{
// If i is a prime number, flag will be equal to 1
flag = checkPrimeNumber(i);
if(flag)
cout << i << " ";
}
return 0;
}
// user-defined function to check prime number
int checkPrimeNumber(int n)
{
bool flag = true;
for(int j = 2; j <= n/2; ++j)
{
if (n%j == 0)
{
flag = false;
break;
}
}
return flag;
}
Enter two positive integers: 12
55
Prime numbers between 12 and 55 are: 13 17 19 23 29 31 37 41 43 47 53
C++ inline function: How is it different from regular function and why is it
required?
Normally, a function call transfers the control from the calling program to the called function.
After the execution of the program, the called function returns the control to the calling program
with a return value.
This concept of function saves program space because instead of writing same code multiple
times the function stored in a place can be simply used by calling it at a desired place in
the program.
This might be handy to reduce the program size but it definitely increases the execution time of
the program as the function is invoked every time the control is passed to the function and
returns a value after execution.
In large functions, this is very helpful but in a small function in order to save execution time a
user may wish to put the code of function definition directly in the line of called location.
For this C++ provides inline function to reduce function call overhead. That is every time a
function is called the compiler generate a copy of the function’s code in place to avoid function
call.
This type of function whose code is copied to the called location is called inline function
inline data_type function_name(arguments_list);
C++ Inline Function Example #include <iostream>
#using namespace std;
inline void square_me(int a) //inline function
{
a* = a;
}
int main()
{
int x;
cout << "enter number: ";
cin >> x;
square_me( x );
cout << x;
return 0;
}
enter number: 5
25
C++ Recursion with example
The process in which a function calls itself is known as recursion and the
corresponding function is called the recursive function. The popular example
to understand the recursion is factorial function.
C++ recursion example: Factorial #include <iostream>
using namespace std;
//Factorial function
int f(int n){
/* This is called the base condition, it is
* very important to specify the base condition
* in recursion, otherwise your program will throw
* stack overflow error.
*/
if (n <= 1)
return 1;
else
return n*f(n-1);
}
int main(){
int num;
cout<<"Enter a number: ";
cin>>num;
cout<<"Factorial of entered number: "<<f(num);
return 0;
}
Enter a number: 5
Factorial of entered number: 120
Direct recursion: When function calls itself, it is called direct recursion, the example we have
seen above is a direct recursion example.
Indirect recursion: When function calls another function and that function calls the calling
function, then this is called indirect recursion. For example: function A calls function B and
Function B calls function A.
Indirect Recursion Example in C++
#include <iostream>
using namespace std;
int fa(int);
int fb(int);
int fa(int n){
if(n<=1)
return 1;
else
return n*fb(n-1);
}
int fb(int n){
if(n<=1)
return 1;
else
return n*fa(n-1);
}
int main(){
int num=5;
cout<<fa(num);
return 0;
}
Pointers to functions
A pointer to a function points to the address of the executable code of the function. You can use
pointers to call functions and to pass functions as arguments to other functions. You cannot
perform pointer arithmetic on pointers to functions.
The type of a pointer to a function is based on both the return type and parameter types of the
function.
A declaration of a pointer to a function must have the pointer name in parentheses.
int (*g)(int a); /* pointer g to a function returning an int