C++ reference FAQ interview questions

//1.References are nothing but constant pointer.
//2.So,references once initialized can not refer to other.
//2.1 Reference to reference not allowed.No error but. it will start pointing to the first variable
//3. reference arithmatic not allowed.No error in reference arithmatic but changes reflected in referant not in reference.
//4.Reference to array allowed.//int (&r)[5];
//5.Array of reference not allowed because we can not find the address of array. ultimately refer to first variable.
//6.Unlike pointers,refernce are automatically gets dereferenced.No need to use *(value at address).
//7.Unlike pointers, reference arithmatic like increment will increase the referant's value and not the address
//8.Reference are used to pass by reference to get the changes reflected in calling function.
//9.Pass by reference avoids copy of large value when structure like data are passed as arguments.
//10. Its unsafe to return local variable by value because variable goes out of scope once conrol returns out of the function defintion.
//Solution is us local static variable or dynamic memory allocation so that scope of the variable will through out the program.
#include<iostream>
using namespace std;
int gv;
int main()
{
//reference nothing but constant pointer means once initialized can not be reinitialized.
int s=10;
int *const h=&s;//s is const pointer so can not hold another address
//h=&m;//error: assignment of read-only variable ‘h’


int i=10,m=2;
int &j=i;// j is reference to a

//reference to refernce not allowed. No error but points to the first variable
int &k=j;//reference to reference no error but//point 2.1
k=20;
cout<<i<<endl;//20

//pointer arithmatic are not allowed. no error but changes gets reflected in first variable
k++;//point 7
cout<<i<<endl;//21

//referece can not be reinitialized but direct values can be given
int a=1;
k=1;
cout<<k<<endl;

//pass by reference to get the values reflected in calling function
int x=10,y=20;
swap(x,y);
cout<<x<<" " <<y<<endl;//20,10

//if return type is reference then function call can be made in left side
int &f();
f()=5;
cout<<"gv="<<gv<<endl;//5//instead of returned reference 100, f() is assigned to 5

//problem of local ovariable returning by value
int d;
int ff(d);
cout<<"d="<<d<<endl;//Garbage, because return value went out of scope in definition itself.
return 0;
}
void swap(int x, int y)
{
int t;
t=x;
x=y;
y=x;
}
//return by reference
int &f()
{
gv=100;
return gv;
}
//problem of returning local variable by value
int ff(int t)
{
int& lv=t;
lv=lv+44;
return lv;//returning local variable by value.
}//scope of lv over here
You may also like.

Find and remove loop in linked list code in cpp linux

//Remove Loop in a linked list1.
//Find the loop and pass the loop node to removeLoop function.
//assign pointer ptr1=start.
//start infinite loop.
//assign pointer ptr2=loopnode.
//in loop traverse till ptr2->next!=loopnode && ptr2->next!=ptr1
//loop is found when ptr2->next=ptr1 ; break the loop
//else increment ptr1//most important
#include<stdio.h>
#include<malloc.h>
struct node
{
int data;
struct node *next;
};
struct node *start=NULL;
//Inserting at start
void insert(struct node** ref,int d)
{
struct node *newnode=(struct node*)malloc(sizeof(struct node));
newnode->data=d;
newnode->next=(*ref);
*ref=newnode;//mind it
}
//displaying
void display(struct node *ref)
{
struct node *ptr=ref;
while(ptr!=NULL)
{
printf("%d\t",ptr->data);
ptr=ptr->next;
}
printf("\n");
}
//Detecting Loop
void loopDetect()
{
struct node* slow=start;
struct node* fast=start;
while(start->next !=NULL)
{
slow=slow->next;
fast=fast->next->next;
if(slow==fast)
{
printf("LoopDetected\n");
removeLoop(slow);
break;//else infinite time LoopDetected gets printed
}
}
}
void removeLoop(struct node *loopnode)
{
printf("\nRemoveLoop Called.\n");
struct node *ptr1;
struct node *ptr2;
ptr1=start;
while(1)
{
ptr2=loopnode;
while(ptr2->next != loopnode && ptr2->next!=ptr1)
{
ptr2=ptr2->next;
}
if(ptr2->next==ptr1)//mind the next
break;
else
ptr1=ptr1->next;
}
ptr2->next=NULL;
}
int main()
{
insert(&start,10);
insert(&start,20);
insert(&start,30);
insert(&start,40);
insert(&start,50);
display(start);
//create a loop
start->next->next->next->next=start->next;
//display(start);//infinite loop means loop created.
loopDetect();
display(start);//No infinite loop means No loop now.

return 0;
}
/*
50 40 30 20 10
LoopDetected
50 40 30 20
*/
--------------------------
//Remove Loop in a linked list1.

C Linux code to insert in middle of Linked list

//Inserting After given node of Single Linked List
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
struct node
{
        int data;
        struct node* next;
};
struct node *start=NULL;
void push(struct node** ref,int d)
{
        struct node *newnode=(struct node *)malloc(sizeof(struct node));
        newnode->data=d;
        newnode->next=(*ref);
        (*ref)=newnode;
}
void display(struct node *start)
{
        struct node *ptr=start;
        while(ptr)
        {
                printf("%d\t",ptr->data);
                ptr=ptr->next;
        }
        printf("\n");
}
struct node* insertAfterNode(struct node *start,int d, int afternode)
{
int i;
struct node *newnode=(struct node *)malloc(sizeof(struct node));
newnode->data=d;
struct node* current=start;
while(current!=NULL)
{
if(current->data==afternode)
{
newnode->next=current->next;
current->next=newnode;
//return start;
}
current=current->next;
}
}
int main()

Singleton Design Pattern example in C++

//Singleton is a creational design pattern.
//A design pattern to provide one and only instance of an object.
//Declare the constructors of the class private.
//Declatre a static public instance of class type.
//Provide a static public method to get the instance
//If instance is NULL then only once create a object else
//return the already created instance
#include<stdio.h>
using namespace std;
class singleton
{
private:
singleton(){printf("Constructor called only once.\n");}
public:
static singleton* instance;
static singleton* getinstance();
};
singleton* singleton::instance=NULL;

singleton* singleton::getinstance()
{
if(instance==NULL)
{
instance = new singleton;//mind the syntax//no singleston s;
}
else
{
return instance;
}
}
int main()
{
//singleton s1;//singleton() is private within this context
singleton *sptr;
sptr=singleton::getinstance();
sptr=singleton::getinstance();
sptr=singleton::getinstance();
sptr=singleton::getinstance();
sptr=singleton::getinstance();
return 0;
}
/*
Constructor called only once.
*/

Observer Design Pattern example in C++


Observer Design Pattern example in C++

//Observer Design pattern Best Example.
//Observer Design pattern is implemented using two classes.
//First is observable or subject class: in this class even occurs and to be notified to the registered observers.
//subject class contains attachObserver(), notifyObserver(),and other task.
//Second class is observer class: class which wants to be notified when some even occurs in observable or subject class.
//observer class contains a pure viryual function notify().
//Example:
//When any event like new blog/article is available in a website it should notify to all the registered users.
//So here Blog will derived from subject class and
//users want to get notified of new articles. So User will be derived from class observer
#include<iostream>
using namespace std;
#include <vector>
#include <typeinfo>
#include <string>

class Subject;//forward declaration

class Observer//class which are interested to get notified
{
public:
    virtual void notify(Subject* s) = 0;//pure virtual function
    virtual ~Observer() {};
};

class Subject//Class in which even take place
{
    vector<Observer *> observers;
protected:
    void notify_observers()
    {
        vector<Observer *>::iterator iter;
        for (iter = observers.begin(); iter != observers.end(); ++iter)
            (*iter)->notify(this);
    }

public:
    virtual ~Subject() {};
    void register_observer(Observer* o)//pusshing the attached observers in a vector
    {
        observers.push_back(o);
    }
};

class Blog : public Subject
{
public:
    Blog()
    {
        cout << "New Article Posted." << "\n";
    }

    void eventTriggerNewArticle()
    {
        cout << "The new article event is triggered." << "\n";
        notify_observers();
    }

int const get_Blog_id()
//int get_Blog_id()
{
return 21022015;
}
};

class User : public Observer
{
public:
    virtual void notify(Subject* s)
    {
        Blog *a;
        a = dynamic_cast<Blog*>(s);
       cout << a->get_Blog_id() << "\n";
    }
};

int main ()
{
    Blog newArticle = Blog();
    User u = User();
    newArticle.register_observer(&u);
    newArticle.eventTriggerNewArticle();
    return 0;
}
/*OUTPUT:
New Article Posted.
The new article event is triggered.
21022015
*/

C++ program to overload operator+ for string concatenation

//operator overloading for concatenating two strings in C++
#include<iostream>
using namespace std;
#include<string.h>

class sample
{
private:
char str[20];
public:
sample()
{
cout<<"def constructor."<<endl;
strcpy(str,"C++ Linux Code.");
}
sample(char s[])
{
cout<<"a arg constructor."<<endl;
strcpy(str,s);
}
sample operator+(const sample& ref )
{
cout<<"overloaded + called"<<endl;
sample temp;//def constructor
strcpy(temp.str,str);
strcat(temp.str,ref.str);
return temp;
}
//return *this;//seg fault
void display(){cout<<str<<endl;}
};
int main()
{
sample s1;//def constructor
s1.display();
sample s2("blogspot.com");//1 arg constructor
s2.display();
sample s3;//def constructor
s3=s1+s2;
s3.display();
//cout<<str<<endl;//str was not declared in this scope. As str is private and only mf can access
//cout<<s1.str<<endl;//aaa
//cout<<'m'<<endl;//a
return 0;
}
/*
def constructor.
C++ Linux Code.
a arg constructor.
blogspot.com
def constructor.
overloaded + called
def constructor.
C++ Linux Code.blogs
*/

Copy constructor Overloaded assignment operator Destructor and default constructor implementation in C++

C++ program to implement:Default constructor, One argument constructor, Copy constructor, overloaded assignment operator, destructor and overload + operator to concatenate two strings in a single program.
#include<iostream>
using namespace std;
#include<string.h>

class sample
{
private:
char *name;
public:
sample(){cout<<"\n Default constructor called."<<endl;}
sample(const char *p);
sample(const sample &ref);
sample& operator=(const sample &obj);
sample& operator+(const sample& obj);
~sample();
};
sample::sample(const char* p)
{
cout<<" One argument constructor called."<<endl;
name = new char[strlen(p)+1];
strcpy(name,p);
cout<<"name: "<<name<<endl;
}
sample::sample(const sample &ref)
{
cout<<"copy constructor called."<<endl;
name=new char[strlen(ref.name)+1];
strcpy(name,ref.name);
}
sample& sample::operator=(const sample &ref)
{
cout<<"overloaded = operator called.\n";
//if(this==&ref)
//return *this;

//delete[] name;//Seg fault
name=new char[strlen(ref.name)+1];
strcpy(this->name,ref.name);
return *this;
}
sample& sample::operator+(const sample &obj)
{
cout<<"overloaded + called.\n";
//name=new char[strlen(obj.name)+1];
strcat(name,obj.name);
cout<<"cancatename is: "<<name<<endl;
}
sample::~sample()
{
cout<<"Destructor called.\n";
//delete[] name;
}
int main()
{
sample s1;//def constr.//destr
sample s2("Hello");//1 arg constr.//destr
sample s3(s2);//copy constr.//destr
sample s4=s3;//copy constr.//destr
sample s5;//def constr.//destr
s5=s1;//overloaded = opr.//No destructor
s2+s3;//overloaded + called//No destr
//cout<<s2.name<<endl;//name is private and accessible only by mf
return 0;
}
/*OUTPUT:
 Default constructor called.
 One argument constructor called.
name: Hello
copy constructor called.
copy constructor called.

 Default constructor called.
overloaded = operator called.
overloaded + called.
cancatename is: HelloHello
Destructor called.
Destructor called.
Destructor called.
Destructor called.
Destructor called.

*/

Purpose of run time Polymorphism in C++/CPP.

What is the main purpose of run time polymorphism? Why run time polymorphism is used in object oriented programming like C++? What is the main reason to use polymorphism in C++? Why late binding is used in C++?
These are the most frequently asked questions in interviews for C++ walkins or face to face interviews. If you are fresher then telling the definition alone is enough but by experienced professionals it is not acceptable. So what should be the answer?
If you are able to mention a real time scenario where it is used in proper manner then your work is done.
One such example is to create array of base class pointer which holds addresses of related derived class objects. I.e. Suppose an employee management system. Employee is base class and derived classes are employees like trainee, junior software engineer, senior. Software engineer, Lead engineer, manager etc.
Employee base class has virtual/pure virtual function like salaryIncrement, empPromotion.
Each derived class has its own implementation of these function. If management wants to use salaryIncrement then run time polymorphism allows to create array of base class pointers each having address of different derived class object and in a loop with same call syntax it can increment all employees salary at once without knowing the derived class object type at compile time.

C++ program to implement:Default constructor, One argument constructor, Copy constructor, overloaded assignment operator, destructor and overload + operator to concatenate two strings in a single program.