1.9 Circular Linked List

#include<iostream>
using namespace std;

/*public inheritance*/

class Base{
private:
/*CANT be inherited*/
    int restricted;

protected:
/*can be inherited,available as protected member in derived class*/
    int id;

public:
/*can be inherited,available as public member in derived class*/
void setid(int iid){
    id=iid;};
};

class Derived:public Base{/*public inheritance*/
public:
    void disp(){
    cout<<id<<endl; //id- is inherited as protected member by derived class*/
    }
};

int main()
{
    Derived d;
    //d.id=786;/*ERROR: trying to access protected member,outside class */
    d.setid(123);
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

/*protected inheritance*/

class Base{
private:
/*CANT be inherited*/
    int restricted;

protected:
/*can be inherited,available as protected member in derived class*/
    int id;

public:
/*can be inherited,available as PROTECTED member in derived class(THOUGH ITS PUBLIC MEMBER IN BASE CLASS)*/
void setid(int iid){
    id=iid;};
};

class Derived:protected Base{/*protected inheritance*/
public:
    void via(int x){
    setid(x);}
    void disp(){
    cout<<id<<endl; //id- is inherited as protected member by derived class*/
    }
};

int main()
{
    Derived d;
    //d.setid(123);/*ERROR: trying to access protected member,outside class */
/*SINCE public member setid() of base class has become PROTECTED member of derived class, it CANT be accessed OUTSIDE class */
    d.via(786);
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

/*PRIVATE INHERITANCE*/

class Base{
private:
/*CANT BE INHERITED*/

protected:/*can be inherited,available as PRIVATE member in derived class*/
    int id;
public:/*can be inherited,available as PRIVATE member in derived class*/
    void setid(int iid){
    id=iid;}
};

class Derived:private Base{/*private inheritance*/
public:
    void disp(){
    cout<<id<<endl;}
    };
/*both protected & public members has become PRIVATE members of DERIVED class,
so its not available for ANY DERIVED CLASS & OUTSIDE CLASS*/

class Der2:public Derived{
public:
    void setnum(int iid){
    setid(iid);/*generates ERROR,since setid(PRIVATE MEMBER)*/
    id=iid;/*generates ERROR,since id(PRIVATE MEMBER),not avilable for any derived class*/
    }
};

int main()
{
    Der2 d;
    d.setnum(123);/*since private members cant access id(private)*/
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

/*PRIVATE INHERITANCE*/

class Base{
private:
/*CANT BE INHERITED*/

protected:/*acts as PRIVATE member in derived class*/
    int id;
public:/*acts as PRIVATE member in derived class*/
    void setid(int iid){/*4th--> (setid) member ftn set value of id*/
    id=iid;}
};

class Derived:private Base{/*private inheritance*/
public:
    void d1_id(int iid){/*3rd-->(d1_id) member ftn calls (setid) member ftn*/
    setid(iid);
    }

    void disp(){
    cout<<id<<endl;}
    };

class Der2:public Derived{
public:
    void d2_id(int iid){/*2nd-->(d2_id) member ftn calls (d1_id) member ftn*/
    d1_id(iid);
    }
};

int main()
{
    Der2 d;
    d.d2_id(786);/*1st-->derived2 object calls (d2_id) member ftn*/
    d.disp();/*since disp()is public ftn it can be called outside class*/
    return 0;
}

/*USING ACCESS DECLARATION*/
#include<iostream>
using namespace std;

class Base{
protected:
    int id;
public:
    void setid(int iid){
    id=iid;}
};

/*Access declaration changes the ACCESS LEVEL/SCOPE
of base class member in derived class */
/*  syntax:
        accessDeclaration:  say, public/protected/private
            BaseclassName :: memberName  */
class Derived:private Base{
public: //ACCESS DECLARATION
    Base::id; /*now id(PRIVATE member) has become PUBLIC,it can be accessed OUTSIDE CLASS */

    void disp(){
    cout<<id<<endl;}
};

int main()
{
    Derived d;
    d.id=123;/*private member is changed scope as public and used OUTSIDE class */
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Base{
public:
    Base(){
    cout<<"1st-->base class constructor called"<<endl;
    }
    ~Base(){
    cout<<"4th-->base class destructor called"<<endl;
    }
};

class Derived:public Base{
public:
    Derived(){
    cout<<"2nd-->Derived class constructor called"<<endl;
    }
    ~Derived(){
    cout<<"3rd-->Derived class destructor called"<<endl;
    }
};

int main()
{
    Derived ob;/*derived class object created*/
    return 0;
}

#include<iostream>
using namespace std;

class Device{
public:
    Device(){
    cout<<"inherited from Device class"<<endl;
    }
    int id;
    /*void setid(int iid){   //we can do through this method also 
    id=iid;}*/
};

class Wless{
public:
    Wless(){
    cout<<"inherited from Wless class"<<endl;}
    int model;
    /*void setmodel(int mno){ //we can do through this method also 
    model=mno;}*/
};

class Btooth:public Device,public Wless{
public:
    Btooth(){
    cout<<"Multiple inheritance"<<endl;}

    void setid_model(int iid,int imodel){
    id=iid;
    model=imodel;
    /*setid(iid); //we can do through this method also
    setmodel(imodel);*/
    }

    void thisp()
    {
    cout<<id<<"  "<<model<<endl;}
};

int main()
{
    Btooth bt;
    bt.setid_model(123,1100);
    bt.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Base{
protected:
    int id;
public:
    Base(int iid){
    id=iid;
    cout<<"base class constructor called"<<endl;}
};

class Derived:public Base{
public:
    Derived(int x):Base(x){      /*value passed to base class constructor*/
    cout<<"derived class constructor called"<<endl;}

    void disp(){
    cout<<id<<endl;}
};


int main()
{
    Derived d(123);
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Base{
protected:
    int id;
public:
    Base(){
    cout<<"base class constructor called "<<endl;}
};

class Derived :public Base{
public:
    Derived(int x):Base(){   /*base class constructor can be called*/
    id=x;                   /*and value can be passed*/
    cout<<"derived class constructor called"<<endl;}
    void disp(){
    cout<<id<<endl;
    }
};

int main()
{
    Derived d(111);
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Base{
public:
    void disp(){
    cout<<"base class method called"<<endl;}
};

class Derived: public Base{
public:
    void disp(){ /*base class method overridden,i.e., same return type, same ftn.name, same parameters*/
    cout<<"derived class method is called"<<endl;
    cout<<"which has overridden base class method"<<endl;}
};

int main(){
    Derived d;
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Base{
public:
    void disp(){
    cout<<"base class method called "<<endl;}
};

class Derived: public Base{
public:
    void disp(){   //base class method overridden
    cout<<"derived class method called"<<endl;}
};

int main()
{
    Derived d;
    d.disp();       //derived class method called
    d.Base::disp(); //overridden base class method called
    return 0;
}

#include<iostream>
using namespace std;

class Base{
public:
    void disp(){
    cout<<"base class method called"<<endl;}
};

class Derived : public Base{
public:
    void disp(){   /*inside derived class method, we can call base class overridden METHOD*/
    cout<<"derived class method called"<<endl;

    Base::disp();  //calls overridden base class method

    }
};


int main()
{
    Derived d;
    d.disp();
    return 0;
}

#we get GARBAGE VALUE as output -expected error- solution is provided below
#include<iostream>
using namespace std;

class Device{
public:
    int id;

    void setid(int id){
    id=id;/*puts garbage value,since local variable id is same as member variable id*/
    }

    void disp(){
    cout<<id<<endl;}
};

int main()
{
    Device d;
    d.setid(123);
    d.disp();//prints GARBAGE VALUE
    return 0;
}

#include<iostream>
using namespace std;

class Device{
public:
    int id;

    void setid(int id){
    this->id=id;       /*this pointer points to the member variable, of invoking object*/
    }

    void disp(){
    cout<<id<<endl;}
};

int main()
{
    Device d;
    d.setid(123);
    d.disp();          /*prints correct value, since we used THIS POINTER*/
    return 0;
}

/*Calling Methods Using Base Class Type*/
#include<iostream>
using namespace std;

class Base{
public:
    void disp(){
    cout<<"base class method called "<<endl;}
};

class Derived:public Base{
public:
    void disp(){
    cout<<"derived class method called"<<endl;}
};

void intro(Base ob){    /*method takes BASE CLASS OBJECT as a parameter*/
    ob.disp();
}

int main()
{
    Derived d;
    d.disp();
    intro(d);      /*passed derived class method,but calls base class method*/ 
    return 0;
}

/*Calling Methods Using Base Class Type*/
#include<iostream>
using namespace std;

class Base{
public:
    void disp(){
    cout<<"base class method called "<<endl;}
};

class Derived:public Base{
public:
    void disp(){
    cout<<"derived class method called"<<endl;}
};

void intro(Base *ob){     /*method takes BASE CLASS POINTER as a parameter*/
    ob->disp();           /*USE ARROW OPERATOR, since accesing thru' pointer*/
}

int main()
{
    Derived d;
    d.disp();
    intro(&d);   /*address is passed*/
    return 0;
}

/*Calling Methods Using Base Class Type*/
#include<iostream>
using namespace std;

class Base{
public:
    void disp(){
    cout<<"base class method called "<<endl;}
};

class Derived:public Base{
public:
    void disp(){
    cout<<"derived class method called"<<endl;}
};

void intro(Base &ob){/*PASS BY REFERENCE*/
    ob.disp();/*USE DOT OPERATOR, since accesing through OBJECT*/
}

int main()
{
    Derived d;
    d.disp();
    intro(d);   /*OBJECT is passed*/
    return 0;
}

#include<iostream>
using namespace std;

class Person{
public:
	virtual void display(){
	cout<<"hi person"<<endl;	
	}
};

class student : public Person{
public:
	void display(){
	cout<<"hi student"<<endl;	
	}
};

class Farmer : public Person{

public:
	void display(){
	cout<<"hi farmer"<<endl;	
	}
};

void whosThis(Person &p){ /* LOOK CLOSER: pass by reference-base class reference   (Person &p) */
	p.display();
}


int main()
{
	student anil;
	Farmer muthu;
	whosThis(anil);
	whosThis(muthu);
	return 0;

}

#include<iostream>
using namespace std;

class Person{
public:
	virtual void display(){            //virtual function
	cout<<"hi from person"<<endl;	
	}

};

class student : public Person{      //inherit from base class person
public:
	void display(){         //overridden the base class method
	cout<<"hi from student"<<endl;	
	}

};
 
class Gstudent : public student{ /#Important:*virtual nature is inherited*///inherit from derived class student
public:
	/*void display(){ /* $ commented to demostrate hierarchial nature*/
	cout<<"hi from Graduate student"<<endl;	  //overridden the base class method
	}*/
};

//call a method by passing the base class parameter, by reference
void whosThis(Person &p){
	p.display();
}

int main()
{
	Person AuthorRS;	//base class object
	student bamu;	//derived class object
	Gstudent randomGuy;	//derived class object, inherited from another Derivedclass

	whosThis(AuthorRS);
	whosThis(bamu);
	whosThis(randomGuy);	/*calls the method from class student,since no overridden method by that class, demonstrates “hierarchial nature “ $ */

	return 0;
}

#include<iostream>
using namespace std;


class Person{   //ABSTRACT CLASS,since contains one or more PURE VIRTUAL FUNCTION
public:
	virtual void display()=0;	//pure virtual function [syntax: virtual return_type ftn_name(parameters, if any)=0;]
};


//to define the method, use SCOPE RESOLUTION OPERATOR  [syntax: return_type BASEclass_name::method_name(){body of the ftn;}]

void Person ::display(){

	cout<<"hi from person"<<endl;
}


class student: public Person{	//this SHOULD override the base class method
public:
	virtual void display(){
	
	cout<<"hi from student"<<endl;

	//if u want dat base class method 2 be called , use SCOPE RESOLUTION OPERATOR
	Person::display();
	}

};



int main()
{
	//Person AuthorRS;   error:object cant be created for an ABSTRACT CLASS
	student bamu;
	bamu.display();

	return 0;
}

#Demonstrating the issue -error: ambiguous access (solution is provided below)
class Animal{
public:
	void walk(){
	cout<<"Animal walks"<<endl;	
	}
};

class Lion : public Animal{
		
};


class Tiger : public Animal{
		
};


class Liger : public Lion, public Tiger{
		
};

int main()
{
	Liger diamond;
	diamond.walk();  //error C2385: ambiguous access of 'walk'


	return 0;
}

#include<iostream>

using namespace std;

//SOLUTION for diamond problem, use VIRTUAL INHERITANCE

class Animal{
public:
	void walk(){
	cout<<"Animal walks"<<endl;	
	}
};

class Lion : virtual public Animal{	  //virtual inheritance
		
};


class Tiger : virtual public Animal{  //virtual inheritance
		
};


class Liger : public Lion, public Tiger{ /* virtual inheritance provides only one instance of the common base class*/
		
};

int main()
{
	Liger diamond;
	diamond.walk();  //calls base class method, since VIRTUALLY INHERITED


	return 0;
}

#include<iostream>
using namespace std;

//constructor call order
class Animal{
public:
	Animal(){   //base class constructor
	cout<<"base class constructor called"<<endl;
	
	}
	void walk(){
	cout<<"Animal walks"<<endl;	
	}
};

class Lion : virtual public Animal{	  //virtual inheritance
public:
	Lion(){   //derived_1a class constructor
	cout<<"derived_1 class constructor called"<<endl;
	
	}
		
};


class Tiger : virtual public Animal{  //virtual inheritance
public:
	Tiger(){   //derived_1b class constructor
	cout<<"derived_1b class constructor called"<<endl;
	
	}
};


class Liger : public Lion, public Tiger{
public:
	Liger(){   //derived_2 class constructor
	cout<<"derived_2 class constructor called"<<endl;
	
	}	
};

int main()
{
	Liger diamond;
	diamond.walk();  //calls base class method, since VIRTUALLY INHERITED


	return 0;
}

output:

base class constructor called
derived_1 class constructor called
derived_1b class constructor called
derived_2 class constructor called
Animal walks
Press any key to continue . . .

#include<iostream>
#include<string>

using namespace std;

class Person{
public:
	string name;

	class Address{    //Nested class
	public:
		int hno;
		string stName;
		string place;	
	};
	Address addr; //object of the inner class Address

	//method to call the properties
	void Locate(){
		cout<<name<<endl<<addr.hno<<endl<<addr.stName<<endl<<addr.place<<endl;
	
	}

};

int main()
{
	Person AuthorRS;
	AuthorRS.name="AuthorRS";
	//AuthorRS.hno=18;  //error ,since diff scope
	AuthorRS.addr.hno=18;
	AuthorRS.addr.stName="DummyStrt";
	AuthorRS.addr.place="DummyPlace";
	AuthorRS.Locate();


	//Address ad;	      object creation //error, since its nested class

	//using SCOPE RESOLUTION OPERATOR, can create object for the nested class
	
	Person::Address ad; //initialize if u want
	
	return 0;
}

#include<iostream>
#include<string>


using namespace std;


void studentList();		//function prototype


int main()
{
	studentList();		//function call
	return 0;
}

void studentList(){
	class student{		//local class
	public:
		string name;
		int age;

		void display(){		//method to access the properties
		cout<<name<<endl<<age<<endl;
		
		}
	
	};

	student bamu;		//object
	bamu.name="bamu";
	bamu.age=18;
	bamu.display();

}

#include<iostream>
using namespace std;

class Mk{
public:
    int intmk;
    int extmk;

    Mk(){ //default constructor
    intmk=0;
    extmk=0;}

    Mk(int im,int em){
    intmk=im;
    extmk=em;}

    void disp(){
    cout<<intmk<<endl<<extmk<<endl;}

    /*operator overloading function*/
    Mk operator + (Mk m){  /*here only one parameter is passed, current object parameter is passed implicitly*/
    Mk temp;
    temp.intmk=intmk+m.intmk;   /*here only one parameter is passed, current object parameter is passed implicitly, i.e., m.intmk is passed and current obj intmk is passed automatically*/
    temp.extmk=extmk+m.extmk;
    return temp;
    }
};

 int main()
 {
    Mk m1(10,20),m2(40,70);
    Mk m3=m1+m2;
    m3.disp();
    return 0;
 }

#include<iostream>
using namespace std;

class Mark{
public:
    int intmk;
    int extmk;

    Mark(){//default constructor
    intmk=0;
    extmk=0;}

    Mark(int im,int em){ //user defined constructor
    intmk=im;
    extmk=em;}

    void disp(){
    cout<<intmk<<endl<<extmk<<endl;}

    Mark operator-(Mark m); //DECLARATION
};


Mark Mark:: operator-(Mark m)//Defined outside class
{
    Mark temp;
    temp.intmk=intmk-m.intmk; /*first obj passed automatically,since its a member of class*/
    temp.extmk=extmk-m.extmk;
    return temp;
}

int main()
{
    Mark m1(10,20),m2(40,60);
    Mark m3=m2-m1; /*two operands, 1-passed automatically,2-passed manually*/
    m3.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Mark{
public:
    int mk;

    Mark(){
    mk=0;}

    Mark(int im){
    mk=im;}

    void disp(){
    cout<<mk<<endl;}

    friend void operator+=(Mark &curobj,int);/*friend ftn*/
};

void operator+=(Mark &curobj,int bonusmark){
curobj.mk+=bonusmark;}

int main()
{
    Mark m(150);
    m+=10;
    m.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Mark{
public:
    int mk;

    Mark(){
    mk=0;}

    Mark(int im){
    mk=im;}

    void disp(){
    cout<<mk<<endl;}

    void operator++() {/*no parameter passed,since its an UNARY OPERATOR*/
        mk+=3;
    }

    friend void operator--(Mark &); /*friend ftn doesnt belong to class, so pass current object*/
};

void operator--(Mark &curobj){ /*friend ftn definition, outside class*/
    curobj.mk-=5;
}


int main()
{
    Mark m1(100);
   // m1++;
    ++m1;
    m1.disp();

    --m1;
    m1.disp();
    return 0;
}

/*Exception occurs*/

#include<iostream>
using namespace std;

int main()
{
    int a=10,b=0,c;

    c=a/b;  //exception occurs
    cout<<c<<endl;

    return 0;
}

/*to handle the exception use try,throw,catch*/
#include<iostream>
using namespace std;

int main()
{
    int a=10,b=0,c;

    try{  //place the code block,which may give exception

        if(b==0)
            throw("Divide by zero error"); //if exception occurs throw exception
        c=a/b;  //exception occurs
        cout<<c<<endl;
    }
    catch(const char *e){ //handle d exception case
        cout<<"Exception occured: "<<e<<endl;
    }

    return 0;
}

#include<iostream>
#include<string>
using namespace std;

class Device{
protected:
    string *name;
    int *id;
public:
    Device(string iname,int iid){
        name=new string (iname);
        id=new int(iid);
    }

    //copy constructor
    Device (const Device &d){  /*pass object by ref and const: value of passed object not changed*/
        cout<<"copy constructor called"<<endl;
        name=new string (*d.name); //value at d.name
        id=new int (*d.id);  //value at d.id, since they are pointers

    }

void disp(){
    cout<<*name<<" "<<*id<<endl;  //remember value at
}

void changeVal(string newname,int newid){
    *name=newname;  //remember value at
    *id=newid;
}

};

int main()
{
    Device d("awd",123);
    Device e=d; //copy constructor called now
    d.disp();
    e.disp();

    d.changeVal("new",786);
    d.disp();
    e.disp();

    return 0;
}

#include<iostream>
using namespace std;

/*default constructor and default copy constructor
are inserted by compiler, when it is missing from a class */
class A{
private:
    int x; //data member
public:
   A():x(0){ //default constructor
    }
    void getX(){
        cout<<x<<endl;
    }
};

int main(){
    A obj1; //default constructor called
    A obj2=obj1; //default copy constructor is called
    obj1.getX(); //0
    obj2.getX(); //0

    A obj3;        //default constructor is called
    obj3=obj1;     /default =operator ftn is called
    obj3.getX();   //0
    return 0;
}

/* The above code will work as expected until the class member is not allocated any resource (file or memory). */

#include<iostream>
using namespace std;

class A{
private:
    int *x;
    int N;
public:
    A():x(NULL){   //default constructor

    }

    void allocateX(int N){
        this->N=N;
        x=new int [this->N]; //dyn.mem.alloc
    }

    void getX(){
        cout<<*x<<endl;
    }

    ~A(){  //destructor
        delete []x; //dealloc
    }
};

int main(){
    A obj1; //default constructor is called
    obj1.allocateX(10);
    obj1.getX();

    A obj2=obj1;  //default copy constructor is called
    obj2.getX();

    A obj3;  //default constructor is called
    obj3=obj1;  //default =operator ftn is called
    obj3.getX();

    return 0;
}

#include<iostream>
using namespace std;

class A{
private:
    int *x;
    int N;
public:
    A():x(NULL){  //default constructor

    }

    //copy constructor with deep copy
    A(const A &ob){
        this->N=ob.N;
        this->x=new int [this->N]; //x
    }

    //= operator with deep copy
    void operator=(const A & ob){
        this->N=ob.N;
        this->x=new int [this->N];
    }

    void allocateX(int N){
        this->N=N;
        this->x=new int[this->N];
    }

    void getX(){
        cout<<x<<endl;  //*x or return x
    }

    ~A(){  //destructor
        delete []x;  //dealloc
    }
};

int main(){
    A obj1; //default constructor is called
    obj1.allocateX(10);
    obj1.getX();

    A obj2=obj1;  //deep copying copy constructor is called
    obj2.getX();

    A obj3;  //default constructor is called
    obj3=obj1;  //deep copy =operator ftn is called
    obj3.getX();

    return 0;
}

#include <iostream>
using namespace std;

class Device{ //class is a userdefined datatype,just a blueprint
private:   //access specifier
int id;    //attribute or property

public:
void setid(int iid){      //method or function to access the property
    id=iid;
}

void getid(){      //method or function
    cout<<id<<endl;
}
};

int main()
{
    Device d;//object(runtime variable of the class)
    d.setid(123);//accessing the member of class
    d.getid();//Dot operator to access members
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Device{
public:
string name;

void detect(){
cout<<name<<" device detected"<<endl;
}
};

int main()
{
    Device bt;
    bt.name="bluetooth";
    bt.detect();
    
    Device wf;
    wf.name="Wifi";
    wf.detect();
    
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Device{
public:
string name;

void detect(){
cout<<name<<" device detected"<<endl;
}
};

int main()
{
    Device bt; //object stored in STACK
    bt.name="bluetooth";//use DOT OPERATOR to access object
    bt.detect();

    Device *wf=new Device();//object stored in HEAP,since dyn mem alloc
    wf->name="Wifi"; //use ARROW OPERATOR to access object , since its pointer
    wf->detect();

    return 0;
}

#include<iostream>
using namespace std;

class Device{
public:
    int id;//member variable can be initialized inside class, to be clarified
    /*Note: STATIC VARIABLES can be initialized outside class, using SCOPE RESOLUTION OPERATOR*/

    void disp();//should be declared inside class
};

void Device::disp(){ //METHODS define outside using SCOPE RESOLUTION OPERATOR
cout<<Device::id<<endl;//use scope resolution op to access var outside class
}

int main(){
Device d;
d.id=10;
d.disp();
    return 0;
}

#include<iostream>
using namespace std;

class ATM{
private:    //private access specifier
    int pin;    //private member variables cant be accessed outside the class

    void getpin(){  //private member functions cant be accessed outside
    cout<<pin-199<<endl;}

public:
    void setpin(int ipin){          /*private member var can be accessed 
thru’ a public member ftn of the same class*/
        pin=ipin;}

    void disp(){ 
        getpin();}
};

int main()
{
    ATM sbi;
    sbi.setpin(1234);
    sbi.disp();    //private data is hidden successfully
    return 0;
}

#include<iostream>
#include<string>
using namespace std;

class Device{
private:
    string name;
    int id;
public: //constructor MUST be public..!!!!
/*Constructor syntax: className( ){ .... }
NOTE: strictly no return type,but it may take parameters*/
    Device(){  //constructor initializes properties
    name="noname";
    id=0;
    cout<<"constructor is called automatically, when object created"<<endl;
    }
};

int main()
{
    Device d;//object created, compiler calls CONSTRUCTOR automatically
    return 0;
}

#include<iostream>
#include<string>
using namespace std;

class Device{
private:
    string name;
    int id;
public:
    Device(){  //default constructor ( with no parameter)
    name="noname";
    id=0;
    cout<<"default constructor called"<<endl;}

    Device(string iname,int iid){  /*overloaded constructor (
 with iname and iid as parameters)*/
    name=iname;
    id=iid;
    cout<<"overloaded constructor called"<<endl;}

    void disp(){
    cout<<name<<"  "<<id<<endl;
    }
};

int main()
{
    Device d;//object created, default constructor called
    d.disp();

    Device e("NOKIA",1100);//object created, overloaded constructor called
    e.disp();
    return 0;
}

#include<iostream>
#include<string>
using namespace std;

class Device{
private:
    string name;
    int id;
public:
    Device(){
    name="noname";
    id=0;
    cout<<"default constructor called"<<endl;}

    Device(string iname,int iid=6600){//default parameter-6600,can be overwritten
    name=iname;
    id=iid;
    cout<<"overloaded constructor called"<<endl;}

    void disp(){
    cout<<name<<"  "<<id<<endl;
    }
};

int main()
{
    Device d;//default constructor called
    d.disp();

    Device e("NOKIA");//overloaded constructor calledwith one parameter
    e.disp();//one default parameter is taken

    Device f("NOKIA",1100);//overloaded constructor called with 2 parameters
    f.disp();//default parameter overwritten by passed value

    return 0;
}

#include<iostream>
#include<string>
using namespace std;

class Device{
private:
    string name;
    int id;
public:
    Device(string iname="noname",int iid=0){    //default parameters passed
    cout<<"overloaded constructor called"<<endl;
    name=iname;
    id=iid;
    }

    void disp(){
    cout<<name<<"  "<<id<<endl;
    }
};

int main()
{
    Device f;     //overloaded constructor called with two default parameters
    f.disp();

    return 0;
}

#include<iostream>
using namespace std;

class Device{
public:
    Device(){   //constructor
    cout<<"constructor called"<<endl;
    }
    ~Device(){    //Destructor
    cout<<"destructor called"<<endl;
    }
};

int main(){
    Device *d=new Device;    //constructor called

    delete d;    //destructor called
    return 0;
}

#include<iostream>
#include<string>
using namespace std;

class Device{
private:
    string *name;
    int *id;
public:
    Device(string iname,int iid){
        name=new string;    //dynamic memory allocation
        id=new int;

        *name=iname;    //ATTENTION:*name,*Id since values NOT ADDRESS
        *id=iid;
    }
    ~Device(){
    delete name;      //deallocate memory
    delete id;
    cout<<"All memories are released"<<endl;}

    void disp(){
    cout<<*name<<"  "<<*id<<endl;}   /*ATTENTION:*name,*Id since we need values NOT ADDRESS*/
};


int main()
{
    Device *d=new Device("NOKIA",1100);   //dyn mem alloc, calls constructor
    d->disp();

    delete d;    //dealloc mem, calls destructor
    return 0;
}

#include<iostream>
using namespace std;

void disp();
int main()
{
    disp();
    disp();
    disp();
    disp();
    return 0;
}
void disp(){
    static int counter=0;    //only for the 1st time gets executed
    cout<<++counter<<" times called"<<endl; /*next time onwards the value in (DATA MEM)heap is acessed*/
}

#include<iostream>
using namespace std;

void disp(){
    int a=10;
    static int b=5;
    a+=5;
    b+=10;
    cout<<a<<" "<<b<<endl;
}

int main()
{
    disp();  //15 15
    disp();  //15 25
    disp();  //15  35
    disp();  //15  45
    disp();  //15 55

    return 0;
}

#include<iostream>
using namespace std;

/*static member var-has class scope,shared by all the objects of the class*/
class Device{
public:
    static int counter;     /*ATTENTION:should be initialized outside the class*/

    Device(){  //constructor
        counter++;      /*everytime obj is created, this will get incremented*/
    }

    void disp(){
    cout<<counter<<" devices found"<<endl;}
};

int Device::counter=0;    //initialize outside the class

int main()
{
    Device d;
    Device e;
    Device f;
    d.disp();   /*since same copy is shared by all objects,prints total count*/
    return 0;
}

#include<iostream>
using namespace std;

class Device{
public:
    static int counter;

    Device(){
        ++counter;
    }

    static void dispCount(){         //static method
       cout<<counter<<endl;      //static methods use only static varaibles
    }
};

int Device::counter=0;

int main()
{
    Device d;
    Device e;
    Device f;

    Device::dispCount();      /*use scope resolution operator to access static ftn*/
    return 0;
}

#include<iostream>
using namespace std;

class Atm{
private:
    int pin;
public:
    Atm(int ipin){
    pin=ipin;}

    friend void dispPin(Atm obj);/*declare friend ftn, ATTENTION: object of the class should be passed as parameter!!!*/
    /*syntax: friend returntype ftnname(classname object)*/
};

void dispPin(Atm obj){ /*friend ftn can access all members of the class,including PRIVATE&PROTECTED members*/
cout<<obj.pin<<endl;}  /*access the member through d object- obj.pin*/

int main()
{
    Atm sbi(1234);
    dispPin(sbi);//obj of the class is passed as parameter
    return 0;
}

#include<iostream>
#include<string>
using namespace std;

class Base{
private:
/*!!!CANT be inherited*/

protected:
/*can be inherited*/

public:
/*can be inherited*/
    string name;
    void setname(string iname){
    name=iname;}
};

class Derived:public Base{ //inheritance
public:
    int id;
    void setid(int iid){
    id=iid;}

    void disp(){
    cout<<name<<" "<<id<<endl;} /* derived class inherited base class property name*/
};

int main()
{
    Derived d;//derived class object
    d.setname("rs");
    d.setid(123);
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;

class Base{
protected: /*same as private, BUT it can be inherited*/
    int id;
public:
    void setid(int iid){
        id=iid;}
};

class Derived:public Base{
public:
    void disp(){
        cout<<id<<endl;}
};

int main()
{
    Derived d;
    //d.id=786;  /*cant be accessed outside the class, since PROTECTED*/
    d.setid(123);
    d.disp();
    return 0;
}

#include<iostream>
using namespace std;
int main()
{
	char input='z';
	switch(input){     //data type of switch input & case should be same
	case 'A':{
		cout<<'A'<<endl;
		break;
	}
	case'B':{
		cout<<'B'<<endl;
		break;}
	case 'C':{
			 cout<<'C'<<endl;
			 break;
			 }
	default:
		cout<<"default"<<endl;//if none of the cases matches,default'll be exectd
		//no need of break in default case
	}
	return 0;
}

#include<iostream>
using namespace std;

bool check(int);


int main()
{
	if(check(18))
		cout<<"u r adult"<<endl;
	else
		cout<<"u r kid"<<endl;
	return 0;
}

bool check(int age)
{
	if(age>=18)
		return true;//u can have many return statements in a pgm, but only one gets executed
	else
		return false;
}

#include<iostream>
using namespace std;

int main()
{
	int age=20,weight=70;
	cout<<"value: "<<age<<endl;
	cout<<"address: "<<&age<<endl;//address of variable age stored in memory

	cout<<"value: "<<weight<<endl;
	cout<<"address: "<<&weight<<endl;//address of variable weight stored in memory
	//NOTE:useful in pointer concepts
	return 0;
}

#include<iostream>
using namespace std;

int main()
{
	int age=20;
	bool human=true;

	int *ageptr; //syntax: datatype *ptr_name  NOTE:datatype->which type of data is stored in d address
	bool *humanptr;// here humanptr-> points to a variable human which contains a bool value
	
	ageptr=&age;//initializing a pointer by giving the address of variable
	humanptr=&human;//NOTE:no need to put * b4 d ptr_name

	cout<<age<<"-->"<<ageptr<<endl;
	cout<<human<<"-->"<<humanptr<<endl;//gives u d address 

	cout<<age<<"-->"<<*ageptr<<endl;
	cout<<human<<"-->"<<*humanptr<<endl;// gives u d value stored
	return 0; 
}
//NOTE: pointers useful in DYNAMIC MEMORY ALLOCATION

#include<iostream>
using namespace std;

void show(int[],int);//ftn prototype

int main()
{
	int arr[]={22,33,44,55,66};
	int l=5;
	show(arr,l);//call d ftn by passing an array to d ftn 
	return 0;
}


void show(int num[], int len){//array arr[] is passed 2 d ftn

	int i;
	for(i=0;i<len;i++)
		cout<<num[i]<<endl;

}

#include<iostream>
using namespace std;

void display(int *);//ftn prototype


int main()
{
	int weight=50;
	cout<<"value b4 chnged by ptr in pass_by_ref --> "<<weight<<endl;
	display(&weight);
	cout<<endl<<"value afte' chnged by ptr in pass_by_ref --> "<<weight<<endl;
	return 0;
}

void display(int *ptr){

	cout<<endl<<"pass by reference --> "<<*ptr<<endl;
	/*pass by ref= passing a pointer 2 a ftn
	NOTE:value changed using d ptr'll affect d actual value*/
	*ptr=100;
}

#include<iostream>
using namespace std;

int main()
{
	int arr[]={22,33,44,55,66};
	cout<<arr[0]<<endl;//prints 1st element
	cout<<*arr<<endl;//prints 1st element

	cout<<arr[2]<<endl;//prints 3rd element
	cout<<*(arr+2)<<endl;//prints 3rd element
	//NOTE:array element can be accessed thru' ARRAY INDEX or *VALUE @

	return 0;
}

#include<iostream>
using namespace std;
/*const--> keep pgming elements constant i.e.,Variables,Pointers, array,ftn arguments,return values,class data members,member ftns,objects +protect array elements */
void display(const int[],int);

int main()
{
	const float pi=3.14;//constant variable, cant be changed
NOTE:const variable should be initialized while declaring..!!!
	cout<<"pi--> "<<pi<<endl;
	//pi=2.1; //ERROR,u cant assign to a variable that is const

	int number[]={22,33,44,55,66};
	display(number,5);
return 0;
}

/*protect array elements*/
void display(const int arr[],int len){
	int counter;
	cout<<"array elements:"<<endl;
	for(counter=0;counter<len;counter++){
	cout<<arr[counter]<<endl;
	}
	//arr[counter]=99;//ERROR,u cant assign to a variable that is const
}

#include<iostream>
using namespace std;

void display(const int *,const int *);

int main()
{
	int arr[]={11,22,33,44,55,66,77,88,99};
	display(arr+3,arr+7);//calls array element from range (4-7)
	return 0;
}

void display(const int *start,const int *end){

	const int *ptr;
	for(ptr=start;ptr!=end;ptr++){
	cout<<*ptr<<endl;
	}

}

/*arraysame data_type under one group; structuresdiff. data_type under one group*/

#include<iostream>
using namespace std;

struct student{ //structure name(GLOBAL SCOPE, can be accessed thru’out our pgm)
	int rollno;//structure member,it can be a VARIABLE, another STRUCTURE or UNION
	char sex;//structure member
}bamu,randomGuy;//structure variables(GLOBAL SCOPE)
NOTE:student is a user-defined data_type..!!!

int main()
{
	student AuthorRS,ajju;//structure variables(LOCAL SCOPE)
	AuthorRS.rollno=123;//assign value to structure variable member
	ajju.rollno=456;
	
	bamu.rollno=111;
	randomGuy.rollno=222;

	cout<<bamu.rollno<<endl<<randomGuy.rollno<<endl;
	cout<<AuthorRS.rollno<<endl<<ajju.rollno<<endl;;
	return 0;
}

#include<iostream>
using namespace std;

struct student{
	int rollno;//structure member
	char sex;
};

int main()
{
	student AuthorRS;//structure variable
	student *AuthorRSptr;//pointer

	AuthorRSptr=&AuthorRS; //ptr pointing to the structure variable
	AuthorRS.rollno=123;
	AuthorRSptr->sex='m';//->ARROW OPERATOR,to access structMember through POINTER to the structVariable
	
	cout<<AuthorRSptr->rollno<<endl;
	cout<<AuthorRS.sex<<endl;  //. DOT OPERATOR, to access structMember through structVariable
	return 0;
}

/*PASS BY VALUE & PASS BY REFERENCE*/
#include<iostream>
using namespace std;

struct student{
	int rollno;
	char sex;
};

void display(student );//ftn prototype MUST BE done after structure definition
void show(student *);

int main()
{
	student AuthorRS;
	AuthorRS.rollno=111;
	AuthorRS.sex='M';
	display(AuthorRS);//struc variable is passed->passing struc to ftn by value
	show(&AuthorRS);//address of the struct.var is passed-> passing struc to ftn by ref
	return 0;
}

/*pass by value- pass struc variable to a ftn*/
/*NOTE:changes DOES NOT affect d main ftn*/
void display(student s){
	cout<<"pass by value"<<endl;
	cout<<s.rollno<<endl<<s.sex<<endl;
}

/*pass by reference-pass struc var ADDRESS to a ftn*/
/*NOTE:changes affect d main ftn*/
void show(student *sptr){
	cout<<"pass by ref"<<endl;
	cout<<sptr->rollno<<endl<<sptr->sex<<endl;
}

#include<iostream>
#include<string>//header to use strings
using namespace std;

struct address{
	int house_no;//members
	string street_name;
};

struct student{
	string name;//members
	int roll_no;
	address addr;//user-defined data_type 'address' variable ->'addr'
};

int main()
{
	student AuthorRS;//struct variable
	/*assigning value to the struc variables*/
	AuthorRS.name="AuthorRS";
	AuthorRS.roll_no=123;
	AuthorRS.addr.house_no=18;//LOOK CLOSER 🙂
	AuthorRS.addr.street_name="DummyPlace";

	/*accessing values stored in the struc variable*/
	cout<<AuthorRS.name<<endl;
	cout<<AuthorRS.roll_no<<endl;
	cout<<AuthorRS.addr.house_no<<endl;//LOOK CLOSER
	cout<<AuthorRS.addr.street_name<<endl;
	
	return 0;
}

#include<iostream>
#include<string>
using namespace std;

struct address{
	int house_no;
	string street;
};

struct student{
	string name;
	int roll_no;
	address addr;//nested structure
};

int main()
{
	student AuthorRS;//structure variable
	student *AuthorRSptr;//structure pointer
	AuthorRSptr=&AuthorRS;//ptr pointing to variable

	/*assigning value to variables*/
	AuthorRSptr->name="AuthorRS";
	AuthorRSptr->roll_no=123;
	AuthorRSptr->addr.house_no=18;//AuthorRSptr is a POINTER, so ->ARROW OP  addr is a variable, so . DOT OP
	AuthorRSptr->addr.street="DummyPlace";

	/*accessing d variables*/
	cout<<AuthorRSptr->name<<endl;
	cout<<AuthorRSptr->roll_no<<endl;
	cout<<AuthorRSptr->addr.house_no<<endl;//LOOK CLOSER
	cout<<AuthorRSptr->addr.street<<endl;

	return 0;
}

#include<iostream>
#include<string>
using namespace std;

struct address{
	int house_no;
	string street;
};

struct student{
	string name;
	int roll_no;
	address *addr;//addr is a POINTER
};

int main()
{
	student AuthorRS;//structure variable
	student *AuthorRSptr;//structure pointer
	AuthorRSptr=&AuthorRS;//ptr pointing to variable

	/*assigning value to variables*/
	AuthorRSptr->name="AuthorRS";
	AuthorRSptr->roll_no=123;
	
	/*ATTENTION PLS*/
	address assign_addr={18,"kk nagar"};//to assign value to the pointer addr
	AuthorRSptr->addr=&assign_addr;//!!! LOOK CLOSER !!!

	/*accessing d variables*/
	cout<<AuthorRSptr->name<<endl;
	cout<<AuthorRSptr->roll_no<<endl;
	cout<<AuthorRSptr->addr->house_no<<endl;//LOOK CLOSER
	cout<<AuthorRSptr->addr->street<<endl;

	return 0;
}

#include<iostream>
#include<string>
using namespace std;

struct address{
	int house_no;
	string street;
};

struct student{
	string name;
	int roll_no;

	address *addr;//pointer
	
};

int main()
{
	student rs;//variable
	
	address assign_ad={18,"kk nagar"};//to assign value to the pointer addr
	rs.addr=&assign_ad;//ptr points to the variable

	cout<<rs.addr->house_no<<endl;
	cout<<rs.addr->street<<endl;
	return 0;
}

#include<iostream>
using namespace std;
/*sizeof is compiler operator*/

struct student{
	int roll_no;
	char gender;
};//see also:compiler optimization

int main()
{
	char sex='M';
	cout<<"int -->"<<sizeof(int)<<endl;//data_type
	cout<<"short int -->"<<sizeof(short int)<<endl;//data_type
	cout<<"variable -->"<<sizeof(sex)<<endl;//variable
	cout<<"structure -->"<<sizeof(student)<<endl;//structure

	return 0;
}

#include <iostream>
using namespace std;

union emp{
int id;
float salary; //both id and salary share same memory
}rs,bamu; //variables can be created here
/*note: only 4 byte is reserved for this union and both the members share the same block*/
int main()
{
    emp AuthorRS; //var can be created here also
    AuthorRS.id=891401;
    cout << AuthorRS.id<< endl;
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int *pointer;    //to return the address of memory allocated
    /*syntax: ptr=new datatype*/
    pointer=new int;
    *pointer=123;
    cout<<*pointer<<endl;
    delete pointer;    //deallocate memory
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int *pointer=NULL; //pointer points to null
    int input,temp,counter;

    cout<<"enter how many elements: ";
    cin>>input;

    pointer=new int[input];//dyn.mem.alloc

    for(counter=0;counter<input;counter++){
    cout<<"enter element "<<counter+1<<endl;
    cin>>temp;
    *(pointer+counter)=temp;
    }
    cout<<"elements are: "<<endl;
    for(counter=0;counter<input;counter++){
    cout<<"element "<<counter+1<<"-> "<<*(pointer+counter)<<endl;
    }

    delete []pointer;//dealloc mem
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int *pointer=nullptr; //c++11 feature(nullptr)
    pointer=new int; //dyn mem alloc

    if(pointer!=nullptr){
    *pointer=10;
    cout<<*pointer<<endl;
    delete pointer;//deallocates mem
    pointer=nullptr;//avoid dangling pointer
    }else{
    cout<<"memory not allocated"<<endl;
    }
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    /*note:initialise immediatly MUST!!!*/
    auto qty=10;/*compiler automatically deduce 
    the datatype ,by looking at the initialiser*/
    cout<<qty<<endl;
    return 0;
}

#include <iostream>
using namespace std;
int sum(){ //function can be anything,with or without arg
	int i,j,res;
	i=10,j=5;
	res=i+j;
	return res;//ftn can return any datatype
}

int main()
{
    /*note:initialise immediatly MUST!!!*/
    auto qty=sum();/*compiler automatically deduce 
    the datatype ,by looking at the RETURN TYPE OF THE FUNCTION sum()*/
    cout<<qty<<endl;
    return 0;
}

#include <iostream>
using namespace std;
int main()
{
    /*note:initialise immediatly MUST!!!*/
    auto qty;//ERROR
    qty=10;//ERROR it should be iniatialised, where it is declared
    cout<<qty;
    return 0;
}

#include <iostream>
using namespace std;
int main()
{
    int marks[]={77,88,99,55,66};
    for(int ele:marks)//syntax: for(variable:collection) /*but throws ERROR bcoz C++ 11 feature !!!*/
    {cout<<ele<<endl;}
    return 0;
}     

#include <iostream>
using namespace std;
int main()
{
    for(int ele:{77,88,99,55,66}) //we can directly pass range 
    {cout<<ele<<endl;}
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
int main()
{
    //string copy
    string name="AuthorRS"; //strcpy string copy of c
    string lastname="rs";
    cout<<name<<" "<<lastname<<endl;

    //string concatenate
    cout<<name+lastname<<endl;//strcat of c

    //string compare
    if(name=="AuthorRS")//strcmp of c
    cout<<"name matched"<<endl;

    return 0;
}

#include <iostream>
using namespace std;
int factorial(int n){
    if(n==1)
        return 1;
    else
        return n*factorial(n-1);//recursive ftn
}

int main()
{
    cout<<factorial(3)<<endl; //3*2*1=6
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

void display();
void display(string);//overloaded ftn
/*same ftn_name,return type BUT diff set of parameters*/
/*NOTE: diff return types doesnt mean ftn overloading!!!*/
int main()
{
    display();
    display("AuthorRS");
    return 0;
}

void display(){
cout<<"hi..."<<endl;
}
void display(string name){
cout<<"hi "<<name<<endl;
}