OOP ( Object Oriented Programming Language )

An Over VIEW :-

C++ Arrays:

Following is an example, which will show array declaration, assignment and accessing arrays in C++:
#include <iostream>
using namespace std;

#include <iomanip>
using std::setw;

int main ()
{
int n[ 10 ]; // n is an array of 10 integers

// initialize elements of array n to 0
for ( int i = 0; i < 10; i++ )
{
n
[ i ] = i + 100; // set element at location i to i + 100
}
cout
<< "Element" << setw( 13 ) << "Value" << endl;

// output each array element's value
for ( int j = 0; j < 10; j++ )
{
cout
<< setw( 7 )<< j << setw( 13 ) << n[ j ] << endl;
}

return 0;
}

C++ Strings:

C++ provides following two types of string representations:
The C-style character string as follows:
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
The standard C++ library provides a string class type that supports all the operations mentioned above, additionally much more functionality. Following is the example:
#include <iostream>
#include <string>

using namespace std;

int main ()
{
string str1 = "Hello";
string str2 = "World";
string str3;

// copy str1 into str3
str3
= str1;
cout
<< "str3 : " << str3 << endl;

// concatenates str1 and str2
str3
= str1 + str2;
cout
<< "str1 + str2 : " << str3 << endl;

return 0;
}

C++ Classes & Objects

A class definition starts with the keyword class followed by the class name; and the class body, enclosed by a pair of curly braces. A class definition must be followed either by a semicolon or a list of declarations. For example we defined the Box data type using the keyword class as follows:
class Box
{
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
The keyword public determines the access attributes of the members of the class that follow it. A public member can be accessed from outside the class anywhere within the scope of the class object. You can also specify the members of a class as private or protected which we will discuss in a sub-section.

Define C++ Objects:

A class provides the blueprints for objects, so basically an object is created from a class. We declare objects of a class with exactly the same sort of declaration that we declare variables of basic types. Following statements declare two objects of class Box:
Box Box1;          // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
Both of the objects Box1 and Box2 will have their own copy of data members.

Accessing the Data Members:

The public data members of objects of a class can be accessed using the direct member access operator (.). Let us try following example to make the things clear:
#include <iostream>

using namespace std;

class Box
{
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};

int main( )
{
Box Box1; // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box here

// box 1 specification
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;

// box 2 specification
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// volume of box 1
volume
= Box1.height * Box1.length * Box1.breadth;
cout
<< "Volume of Box1 : " << volume <<endl;

// volume of box 2
volume
= Box2.height * Box2.length * Box2.breadth;
cout
<< "Volume of Box2 : " << volume <<endl;
return 0;
}

C++ Inheritance:

One of the most important concepts in object-oriented programming is that of inheritance. Inheritance allows us to define a class in terms of another class which makes it easier to create and maintain an application. This also provides an opportunity to reuse the code functionality and fast implementation time.
When creating a class, instead of writing completely new data members and member functions, the programmer can designate that the new class should inherit the members of an existing class. This existing class is called the base class, and the new class is referred to as the derived class.
A class can be derived from more than one classes, which means it can inherit data and functions from multiple base classes. To define a derived class, we use a class derivation list to specify the base class(es). A class derivation list names one or more base classes and has the form:
class derived-class: access-specifier base-class
Where access-specifier is one of public, protected, or private, and base-class is the name of a previously defined class. If the access-specifier is not used, then it is private by default.
Consider a base class Shape and its derived class Rectangle as follows:
#include <iostream>

using namespace std;

// Base class
class Shape
{
public:
void setWidth(int w)
{
width
= w;
}
void setHeight(int h)
{
height
= h;
}
protected:
int width;
int height;
};

// Derived class
class Rectangle: public Shape
{
public:
int getArea()
{
return (width * height);
}
};

int main(void)
{
Rectangle Rect;

Rect.setWidth(5);
Rect.setHeight(7);

// Print the area of the object.
cout
<< "Total area: " << Rect.getArea() << endl;

return 0;
}

C++ Overloading

C++ allows you to specify more than one definition for a function name or an operator in the same scope, which is called function overloading and operator overloading respectively.
Following is the example where same function print() is being used to print different data types:
#include <iostream>
using namespace std;

class printData
{
public:
void print(int i) {
cout
<< "Printing int: " << i << endl;
}

void print(double f) {
cout
<< "Printing float: " << f << endl;
}

void print(char* c) {
cout
<< "Printing character: " << c << endl;
}
};

int main(void)
{
printData pd
;

// Call print to print integer
pd
.print(5);
// Call print to print float
pd
.print(500.263);
// Call print to print character
pd
.print("Hello C++");

return 0;
}

Polymorphism in C++

C++ polymorphism means that a call to a member function will cause a different function to be executed depending on the type of object that invokes the function.
Consider the following example where a base class has been derived by other two classes and area() method has been implemented by the two sub-classes with different implementation.
#include <iostream> 
using namespace std;

class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0)
{
width
= a;
height
= b;
}
int area()
{
cout
<< "Parent class area :" <<endl;
return 0;
}
};
class Rectangle: public Shape{
public:
Rectangle( int a=0, int b=0)
{
Shape(a, b);
}
int area ()
{
cout
<< "Rectangle class area :" <<endl;
return (width * height);
}
};
class Triangle: public Shape{
public:
Triangle( int a=0, int b=0)
{
Shape(a, b);
}
int area ()
{
cout
<< "Triangle class area :" <<endl;
return (width * height / 2);
}
};
// Main function for the program
int main( )
{
Shape *shape;
Rectangle rec(10,7);
Triangle tri(10,5);

// store the address of Rectangle
shape
= &rec;
// call rectangle area.
shape
->area();

// store the address of Triangle
shape
= &tri;
// call triangle area.
shape
->area();

return 0;
}

Data Abstraction in C++:

Data abstraction refers to, providing only essential information to the outside word and hiding their background details ie. to represent the needed information in program without presenting the details.
Data abstraction is a programming (and design) technique that relies on the separation of interface and implementation.
For example, in C++ we use classes to define our own abstract data types (ADT). You can use the coutobject of class ostream to stream data to standard output like this:
#include <iostream>
using namespace std;

int main( )
{
cout
<< "Hello C++" <<endl;
return 0;
}
Here, you don't need to understand how cout displays the text on the user's screen. You need only know the public interface and the underlying implementation of cout is free to change.

Data Encapsulation in C++:

All C++ programs are composed of following two fundamental elements:
  • Program statements (code): This is the part of a program that performs actions and they are called functions.
  • Program data: The data is the information of the program which affected by the program functions.
Encapsulation is an Object Oriented Programming concept that binds together the data and functions that manipulate the data, and that keeps both safe from outside interference and misuse. Data encapsulation led to the important OOP concept of data hiding.
C++ supports the properties of encapsulation and data hiding through the creation of user-defined types, called classes. We already have studied that a class can contain private, protected and publicmembers. By default, all items defined in a class are private. For example:
class Box
{
public:
double getVolume(void)
{
return length * breadth * height;
}
private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};

0 comments:

Post a Comment

My Instagram