OOPs and Data Structures using C++

sankalpnegi2310

Post ur doubts, work log etc on the same

sankalpnegi2310

Basic OOPs features :

Classes
Objects
Data Abstraction
Data Encapsulation
Polymorphism
Data Inheritance
Dynamic Binding
Message Passing

sankalpnegi2310

Basic OOPs concepts in C++ :

Each class ha s 2 sections, private and public
The private data members can only be accessed by the objects of same class, but not directly, they are accessed by class member functions only
No other entity but the objects of the same class can access the private member variables
We use a scope resolution operator '::' to resolve the object of a class to that class
If we dont use 'using std namespace' then we need to resolve the 'cout' 'cin' and 'cerr', as they are objects of class iostream

sankalpnegi2310

Constructors and Destructor concepts:

Constructors and destructor have the same name as the class name, with the latter being preceded by a '~' symbol as well
Every time an object of class is created constructor is called to initialize the private member variables to some default value
Constructors are not called for formal objects within some member function
Destructors are called every time an object of class is destroyed
Destructors are called even for the formal objects within the member function

sankalpnegi2310

Copy constructor concepts:

When compiler optimization is enabled, there runs a default copy constructor
It has the same name as the class name
We need to explicilty create a copy constructor when we have pointers or runtime memory allocation of resources.
It has a specific prototype :
classname (const classname &obj) {/* Body */}
It is called everytime an object of class is copied
It always receives the object as "accept by reference"

sankalpnegi2310

Friend, inline functions and "this" operator and "const":

Friend function is declared as the member of class but it is not the member of class
It has access to all the private, protected and public members of class
We don't need to resolve the scope for the friend function
Being part of the class it can recognize the objects of class
Inline functions come into play when the calling overhead is greater then the run overhead of the function
The compiler may ignore the inline keyword if the function extends more than one line
This operator is used by an object to refer to its own object
This is passed as an implicit argument to the called member function by default
Writing "const" after the function prototype makes each argument of the function as "constant", this also applies to the object itself as a reference to the same is passed implicitly for each function

adeshagarwal02

Feature of C++

C++ is an middle level language
support oop's
procedure oriented
generic programing

Comparison between C and C++

C++ is a superset of c language
C++ can use c libraries
C follows Top to bottom approach where as C++ follows bottom up approach programming
C adapts procedure oriented programming
C++ adapts both procedure and object oriented programming.

Key principle of Object oriented programming

Encapsulation
Data hiding
Abstraction
Polymorphism
Inheritance

adeshagarwal02

Object:
Any entity in the system that can define a set of property and set of operation performed using entity properties.

Class:
Class is a blue print of an object, class is the description of object property set and set of operations.

class means to achieve encapsulation
object is run time entity.
object is an instance of class

adeshagarwal02

Reference variable:

Reference variable means address.
Reference variable means an internal pointer.
Declaration of reference variable is proceeds with '&' symbol (do not read it as "address of")
Reference variable must be initialized during deceleration.
It can be initialized with already declared variable only.
Reference variable cannot be updated.

example :

int main()

{

int x =5;

int &y = x;

y++;

cout<<x;

}

Output:

6

sankalpnegi2310

References vs Pointers:

Once a reference is created, it cannot be later made to reference
another object; it cannot be reseated. This is often done with pointers.
References cannot be NULL. Pointers are often made NULL to indicate that they are not pointing to any valid thing.
A reference must be initialized when declared. There is no such restriction with pointers

adeshagarwal02

Class and Object:

Difference between class and structure:

Only difference between structure and class

The member of structure are by default public.
The member of class are by default private.

Note:

object consume memory not class
if we define member function inside a class it is by default inline function, where as if member function is defined outside the class than to make inline we have to use inline keyword during deceleration inside the class.

Technical terminology:

The variable declared inside the class are called instance member variable (or attributes, data-member, fields,properties)
The function declared inside the class are called instance member function( or method, procedure, action, operation, service).
State of an object is changes when object function is called.

Note:
state of object is the collection of values of variable of member of an object.

adeshagarwal02

Static member in C++

Static member variable:

Also called class variable.
Declared inside class.
They must be defined outside the class.
Does not belong to object, but to whole class.
Do not depend on object.
There will be only one copy of static member variable for whole class.
Any object can use the same copy of class variable
They can also be used as class name

Static member function:

Can call without object.
Can access static variable(or static member of class).
Class member function.
Can be invoke with or without object.

adeshagarwal02

Constructor and Destructors:
Constructor:

Instance member function of class.
Since it is instance therefore never static keyword is used for it.
Name is same as the name of class.
No return type can't use return key word.
Constructor are invoked implicitly when an object is created.
Used to solve problem of initialization.
Can take arguments overloading is possible.

Destructor:

Instance member function of a class.
Never be static.
No return type.
Name is same as the class by proceeded by "~" symbol.
Invoked implicitly when object is going to destroy, destructor is the last function which object calls.
Can not take arguments therefore no overloading is possible.

adeshagarwal02

Operator overloading:

When an operator is overloading with multiple jobs,it is known as operator overloading.
It is the way to implement compiler time Polymorphism.
Any symbol can be used as an function name, if it is a valid operator in c++ language.
It is proceeded by operator keyword.
Operator like sizeof and ?: can not be overloaded.

Example:

class A
{
        private:
                int a;
        public:
                void setdata(int x)
                {a =x;}
                A operator+(A x)
                {
                        A c;
                        c.a = a+x.a;
                       return c;
                }
                void showdata()
                {cout<<a<<endl;}
};
int main()
{
        A obj1,obj2,obj3;
        obj1.setdata(2);
        obj2.setdata(3);
        obj3 = obj1 + obj2;   // now two non primitive type are been added
        obj3.showdata();
        return 0;
}

Note :
obj1 + obj2 can also be written as obj1.operator+(obj2)

adeshagarwal02

Friend Function:

It is not a member function of a class to which it is friend.
Friend function declared in class with friend keyword.
It must be defined outside the class to which it is friend.
Friend function can access any member of the class but not directly to which it is friend.
Can be declared any where in private or public it has no effect since it is not the member of the class.

Example:

class comp
{
        private:
                int a,b;
        public:
                comp(){a=0;b=0;}
                void setdata(int x,int y)
                {a = x; b = y;}
                friend comp add(comp, comp);
                void showdata()
                {cout<<a<<"+j"<<b;}
};
comp add(comp x,comp y)
{
        comp o;
        o.a = x.a + y.a;
        o.b = y.b + y.b;
        return o;

}
int main()
{
        comp obj1,obj2,obj3;
        obj1.setdata(5,6);
        obj2.setdata(6,7);
        obj3 = add(obj1,obj2);
        obj3.showdata();
        return 0;
}

adeshagarwal02

Inheritance:

Class is used to describe properties and behavior of an object. Inheritance is a process of inheriting properties and behaviors of existing class into new class
Existing class = old class = parent class = Base class.
New class = child class = Derived Class.

Example:
class Base_class
{
};
class Derived_class:Visibility_Mode Base class
{
};

Type of inheritance:

Single inheritance.
Multilevel inheritance.
Multiple inheritance.
Hierarchical inheritance.
Hybrid inheritance.

Note:
Visibility mode are

Private.
Public.
Protected.

adeshagarwal02

Constructor and Distructor inheritance in C++:

Constructor inheritance:

We know that constructor is invoked implicitly when an object is created.
In inheritance, Derived class constructor will call Base class constructor.
Derived class default constructor will call Base class default constructor.
If we define a constructor in a Base class but not in a Derive class than default constructor of Derived class will call the default constructor of Base class since we made a constructor in a class therefore there will be no default constructor in the Base class therefore it will generate an error.
So if there is no default constructor in a Base Class than we have to make constructor in a derived class and have to call Base class constructor and also have to pass arguments.

Distructor Inheritance:

In distructor first Derived class distructor will execute than Base class will execute.
There is no such compulsion of calling Base class distructor form Derived class.

Note :

In Constructor Derived class is called first than Base class.
But Constructor of Base class will execute first than Derived class.
In Distructor Derived class is called first than Base class.
But Distructor of Derived class is called first than Base class.

Example:
class Base_class
{
    private:
        int a;
    public:
        Base_class(int x)
        {
            a = x;
            cout<<"Base_class constructor invoke"<<endl;
        }
        void showdata()
        {
            cout<<"Base_class:"<<a<<endl;
        }
        ~Base_class()
        {
            cout<<"Base_class Distructor invoke"<<endl;
        }

};

class Derived_class:public Base_class
{
    private:
        int b;
    public:
        Derived_class(int x,int y):Base_class(y)
        {
            b = x;
            cout<<"Derived_class constructor invoke"<<endl;
        }
        void showdata()
        {
            cout<<"Derive_class:"<<b<<endl;
            Base_class::showdata();
        }
        ~Derived_class()
        {
            cout<<"Derived_class Distructor invoke"<<endl;
        }
};
int main()
{
    Derived_class obj1(2,3);
    obj1.showdata();
    return 0;
}

Output:
Base_class constructor invoke
Derived_class constructor invoke
Derive_class:2
Base_class:3
Derived_class Distructor invoke
Base_class Distructor invoke

adeshagarwal02

This Pointer:

Object pointer:

A pointer contain an address of an object is called object pointer.
Arrow is used to call the fields of an object.

This pointer:

This is a keyword.
This is a local object pointer in every instance member function containing address of the call object.
This pointer can not be modify.
It is used to refer call object int member function.

Example:

class Box
{
        private:
                int l,b,h;
        public:
                void getdem(int l,int b,int h)
                {
                        this->l = l;
                        this->b = b;
                        this->h = h;
                }
                void showdem()
                {
                        cout<<"l="<<l<<endl<<"b="<<b<<endl<<"h="<<h<<endl;
                }

};
int main()
{
        Box b1;
        b1.getdem(2,3,4);
        b1.showdem();
        return 0;
}

akashravindra98

#include<iostream>

using namespace std;

class ov

{

private:

int c,d;

public:

ov()

{

}

friend void operator >> (istream &in , ov &a);

friend ostream & operator << (ostream &out , ov &b);

};

void operator >> (istream &in , ov &a)

{

cout << "overloading func."<< endl;

in >> a.c;

in >> a.d;

}

ostream & operator << (ostream &out , ov &b)

{

cout << "overloading func."<< endl;

out << b.c<<endl;

out << b.d<<endl;

return out;

}

int main()

{

ov m;

cin >> m;

cout << m;

return 0;

}

in above code , if i use void in return type while overloading extraction operator >> , then the code will run perfectly. my question is what is the use of 'istream &' in return type ??

OOPs and Data Structures using C++

Howdy, Stranger!

Categories