CPP

C++ Topics
1. C++ Basic Concepts.
1.1 cin.
1.2 cout.
1.3 Reference Variable.
2. Classes.
3. More on Classes.
3.1 Member Functions.
3.2 Data Members.
3.3 Namespaces.
3.4 Friend Class.
3.5 Default Member functions of a class
4. Constructors & Destructors.
4.1 Copy constructors
4.2 Assignment
4.3 Constructors
4.4 Destructors
5. Inheritance.
6. Polymorphism.
6.1 Compile time
6.1.1 Function overloading
6.1.2 Function overriding
6.1.3 Operator overloading
6.2 Run time
6.2.1 Virtual functions
6.2.2 Virtual Base Class
6.2.3 Virtual Destructors
7. Exception Handling.
8. RTTI.
8.1 typeid
8.2 Typecasting.
8.3 “SET_NEW_HANDLER”
9. Templates.
10. STL.
11. Miscellaneous.
11.1 Smart pointers.
11.2 Hash Table
11.3 Object Slicing
11.4 Array vs STL Vector
11.5 Singleton class
11.6 Zombie objects
11.7 this Pointer
11. 8 Namemangling
11. 9 'asm' Keyword
11.10 extern “C”
12. IO Streams
New : new() = malloc() + constructor()
Delete: delete() = destructor() + free()
3. More on Classes.
3.1 Types of Member Functions.
3.1.1 Nested Member Functions
3.1.2 Overloaded member functions
3.1.3 Member functions with Default arguments
3.1.4 Constant member functions
3.1.5 In-line member functions
3.1.6 Static member functions
3.2 Types of Data Members.
3.2.1 Constant Data member
3.2.2 Mutable Data member
3.2.3 Static data member
3.3 Namespace.
3.4 Friend Class.
4. Constructors & Destructor's

eg1:
#include <iostream>
using namespace std;
class Line
public:
int getLength( void );
Line( int len ); // simple constructor
Line( const Line &obj); // copy constructor
Line& operator=( const Line &obj)
cout << "Copy Assignment allocating ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
return *this;
};
~Line(); // destructor
private:
int *ptr;
};
// Member functions definitions including constructor
Line::Line(int len)
cout << "Normal constructor allocating ptr" << endl;
// allocate memory for the pointer;
ptr = new int;
*ptr = len;
Line::Line(const Line &obj)
cout << "Copy constructor allocating ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
// Line::Line& operator=(const Line &obj)
// {
// cout << "Copy constructor allocating ptr." << endl;
// ptr = new int;

// *ptr = *obj.ptr; // copy the value
// return *this;
// }
Line::~Line(void)
cout << "Freeing memory!" << endl;
delete ptr;
int Line::getLength( void )
return *ptr;
void display(Line obj)
cout << "Length of line : " << obj.getLength() <<endl;
// Main function for the program
int main( )
Line line1(10); // Normal Constructor
Line line2 = line1; // Copy Constructor
line2=line1; // Copy Assignment
//display(line1);
//display(line2);
return 0;
eg2:
#include<iostream>
#include<cstring>
class String
private:
char *s;
int size;
public:
String(const char *str = NULL); // constructor

~String() { delete [] s; } // destructor
String(const String&); // copy constructor
void print(){cout<< s << endl;} // Function to print string
void change(const char *); // Function to change
};
String::String(const char *str)
size = strlen(str);
s = new char[size+1];
strcpy(s, str);
void String::change(const char *str)
delete [] s;
size = strlen(str);
strcpy(s, str);
String::String(const String& old_str)
size = old_str.size;
strcpy(s, old_str.s);
int main()
String str1("GeeksQuiz");
String str2 = str1;
str1.print(); // what is printed ?
str2.print();
str2.change("GeeksforGeeks");
str1.print(); // what is printed now ?
str2.print();
return 0;
}
4.1.1 Explicit Constructors
Whenever you create a constructor that takes one argument, you are also implicitly creating
a conversion from the type of that argument to the type of the class. But there may be
times when you do not want this automatic conversion to take place. For this purpose, C++
defines the keyword explicit.
#include <iostream>
class myclass {
int a;
public:
myclass(int x) { a = x; }
int geta() { return a; }
};
int main()
myclass ob = 4; // automatically converted into myclass(4)
cout << ob.geta();
return 0;
If you do not want this implicit conversion to be made, you can prevent it by using explicit.
The explicit specifier applies only to constructors. A constructor specified as explicit will
only be used when an initialization uses the normal constructor syntax. It will not perform
any automatic conversion. For example, by declaring the myclass constructor as explicit, the
automatic conversion will not be supplied. Here is myclass( ) declared as explicit.

#include <iostream>
class myclass
int a;
public:
explicit myclass(int x)
a = x;
int geta() { return a; }
};
Now, only constructors of the form
myclass ob(4);
will be allowed and a statement like
myclass ob = 4; // now in error
will be invalid
4.2 Destructor
4.3 Copy constructors
4.4 Assignment
7. Exception Handling
Standard library exceptions:
8. RTTI
8.1 typeid(obj)
In polymorphism there can be situations in which the type of an object is unknown at
compile time because the precise nature of that object is not determined until the program
is executed. C++ implements polymorphism through the use of class hierarchies, virtual
functions, and base-class pointers. Since base-class pointers may be used to point to
objects of the base class or any object derived from that base, it is not always possible to
know in advance what type of object will be pointed to by a base pointer at any given
moment in time. This determination must be made at run time, using run-time type
identification. To obtain an object's type, use typeid. You must include the header
<typeinfo> in order to use typeid. Its most commonly used form is shown here:
typeid(object) ;
Here, object is the object whose type you will be
// A simple example that uses typeid.

#include <iostream>
#include <typeinfo>
class myclass1 { // ... };
class myclass2 { // ... };
int main()
int i, j;
float f;
char *p;
myclass1 ob1;
myclass2 ob2;
cout << "The type of i is: " << typeid(i).name()<<endl;
cout<<"The type of f is: " << typeid(f).name()<<endl;
cout<<"The type of p is: " << typeid(p).name()<<endl;
cout<<“Type of ob1 is: " << typeid(ob1).name()<<endl;
cout<<"The type of ob2 is: " << typeid(ob2).name()<<endl;
if(typeid(i) == typeid(j))
cout << "The types of i and j are the same\n";
if(typeid(i) != typeid(f))
cout << "The types of i and f are not the same\n";
if(typeid(ob1) != typeid(ob2))
cout << "ob1 and ob2 are of differing types\n";
return 0;
8.2 Type cast in C++
1. const_cast
const_cast(expression) The const_cast<>() is used to add/remove
const(ness) (or volatile-ness) of a variable.

/*
* Constant member function can't modify its data members. Data members are read only.
* If we want remove constantness
* 1. Remove const key word from member function.
* 2. Use const_cast as shown below.
*/
#include <iostream>
class A
{
int a=10;
public:
void print(int b)const
{
//a++;
const_cast<A*>(this)->a++;
cout<<a<<endl;
//a=b;
const_cast<A*>(this)->a=b;
cout<<a<<endl;
}
};
int main()
{
cout << "Hello World" << endl;
A a1;
a1.print(20);
return 0;
}
2. static_cast
The dynamic_cast operator carries out a run time check to ensure a valid conversion
,but static_cast operator does no perform such a check. If an invalid conversion takes place
the static_cast operator does not produce any error , but results in erratic output
eg:
#include <iostream>
class A
{
};
class B: public A
{
int p;
public:
void set_p(const int x)
{
cout<<”Set_p called”<<endl;
p=x;
}
int get_p()
{
return p;
}
};
class C: public A
{
int q;
public:
void set_q(const int y)
{
cout<<”Set_q called”<<endl;
}
int get_q()
{
return q;
}
};
int main()
{
A *aptr;
B b1, *bptr;
C c1,*cptr;
aptr=&b1;
bptr = static_cast<B *>(aptr); // Valid conversion
bptr->set_p(1);
cout<<b1.get_p()<<endl;
aptr=&c1;
bptr = static_cast<B *>(aptr); // invalid conversion, but no error
bptr->set_p(2);
cout<< c1.get_q()<<endl;
return 0;
}
'static_cast' operator performs a non polymorphic cast. It can be used for any standard conversion. As earlier told
it does not perform any run time errors checking. Look at this eg
// Use static_cast.
#include <iostream>
int main()
{
int i=10;
double d;
d = static_cast<double>(i)/9;
cout << d << endl;
return 0;
}
3. dynamic_cast
Dynamic cast is used to convert pointers and references at run-time, generally for the
purpose of casting a pointer or reference up or down an inheritance chain (inheritance
hierarchy). dynamic_cast(expression) The target type must be a pointer or reference type,
and the expression must evaluate to a pointer or reference. Dynamic cast works only when
the type of object to which the expression refers is compatible with the target type and
the base class has at least one virtual member function. If not, and the type of expression
being cast is a pointer, NULL is returned, if a dynamic cast on a reference fails, a bad_cast
exception is thrown. When it doesn't fail, dynamic cast returns a pointer or reference of
the target type to the object to which expression referred.
4. reinterpret_cast
Reinterpret cast simply casts one type bitwise to another. Any pointer or integral type can
be casted to any other with reinterpret cast, easily allowing for misuse. For instance, with
reinterpret cast one might, unsafely, cast an integer pointer to a string pointer.
dynamic_cast in C++
dynamic_cast in C++ can be used to perform type safe down casting. dynamic_cast
is run time polymorphism. The dynamic_cast operator, which safely converts from a pointer
(or reference) to a base type to a pointer (or reference) to a derived type.
eg 1:
#include <iostream>
class A
{
public:
virtual void f(){cout << "A::f()" << endl;}
};
class B : public A
{
public:
void f(){cout << "B::f()" << endl;}
};
int main()
{
A a;
B b;
a.f(); // A::f()
b.f(); // B::f()
A *pA = &a;
B *pB = &b;
pA->f(); // A::f()
pB->f(); // B::f()
pA = &b;
//pB = &a; // not allowed
pB = dynamic_cast<B*>(&a); // allowed but it returns NULL
if(pB == NULL)
cout<<"NULL";
return 0;
}
eg 2: dyncast.cpp
#include <iostream>
class A
{
public:
virtual void print()const {cout << " A\n";}
};
class B
{
public:
virtual void print()const {cout << " B\n";}
};
class C: public A, public B
{
public:
void print()const {cout << " C\n";}
};
int main()
{
A* a = new A;
B* b = new B;
C* c = new C;
a -> print();
b -> print();
c -> print();
b = dynamic_cast< B*>(a); //fails
if (b)
b -> print();
else
cout << "no B\n";
a = c;
a -> print(); //C prints
b = dynamic_cast< B*>(a); //succeeds
if (b)
b -> print();
else
cout << "no B\n";
/*
try
{
b = dynamic_cast< B*>(a); //succeeds
b -> print();
}
catch (std::bad_cast& bc)
{
cout << "no B\n";
}
*/
}
eg3:
// dynamic_cast
#include <iostream>
#include <exception>
class Base_Class { virtual void dummy() {} };
class Derived_Class: public Base_Class { int a; };
int main ()
{
try
{
Base_Class * ptr_a = new Derived_Class;
Base_Class * ptr_b = new Base_Class;
Derived_Class * ptr_c;
ptr_c = dynamic_cast< Derived_Class *>(ptr_a);

if (ptr_c ==0)
cout<<"Null pointer on first type-cast"<< endl;
ptr_c = dynamic_cast< Derived_Class *>(ptr_b);
if (ptr_c ==0)
cout<<"Null pointer on 2nd type-cast"<< endl;
}
catch (exception& my_ex)
{
cout << "Exception: " << my_ex.what();
}
return 0;
}
8.3 “SET_NEW_HANDLER”
What happens when “new” operator cannot find contiguous block of memory large
enough to hold the desired object? At this point a special function called 'st_new_handler'
is called.
By default “new” operator returns a NULL if it fails to allocate memory. This default
behaviour can be changed i.e. if “new” operator fails to allocate the desired memory for an
object instead returning NULL we could write a function which prints error message and
exits program for debugging purpose.
There is an internal function pointer '_new_handler' which usually contains a NULL
value which is called by “new” when it fails and hence the failed 'new' operator returns a
NULL value. We can point the '_new_handler' function pointer to any user defined function
so that next time when 'new' fails the user defined function is called. To make the
'_new_handler' function pointer to point to some user defined function definition , C++
provides a built in function by name 'set_new_handler()' functon.
Eg:
# include <iostream>
# include <cstdlib>
# include <new>
int cnt = 0;
void my_handler()
cerr << “Memory exhuasted after “<<cnt<<”allocations<<endl;
exit(1);
int main()
set_new_handler(my_handler);
while(1)
cnt++;
int *p = new int(1000000);
return 0;
}
10. Standard Template Library
The Standard Template Libraries (STL's) are a set of C++ template
classes to provide common programming data structures and functions such
as doubly linked lists (list), paired arrays (map), expandable arrays (vector),
large string storage and manipulation (rope), etc. The STL library is available
from the STL home page. This is also your best detailed reference for all of
the STL class functions available.
Also see our C++ Templates tutorial
STL can be categorized into the following groupings:
Container classes:
Sequences:
vector: (this tutorial) Dynamic array of variables, struct or
objects. Insert data at the end.
(also see the YoLinux.com tutorial on using and STL list
and boost ptr_list to manage pointers.)
deque: Array which supports insertion/removal of elements
at beginning or end of array
list: (this tutorial) Linked list of variables, struct or
objects. Insert/remove anywhere.
Associative Containers:
set (duplicate data not allowed in set), multiset (duplication
allowed): Collection of ordered data in a balanced binary
tree structure. Fast search.

map (unique keys), multimap (duplicate keys allowed):
Associative key-value pair held in balanced binary tree
structure.
Container adapters:
stack LIFO
queue FIFO
priority_queue returns element with highest priority.
String:
string: Character strings and manipulation
rope: String storage and manipulation
bitset: Contains a more intuitive method of storing and
manipulating bits.
Operations/Utilities:
iterator: (examples in this tutorial) STL class to represent
position in an STL container. An iterator is declared to be
associated with a single container class type.
algorithm: Routines to find, count, sort, search, ... elements in
container classes
auto_ptr: Class to manage memory pointers and avoid memory
leaks.
Also see the YoLinux.com GDB tutorial on dereferencing STL containers.
File IO Streams
https://www.codingunit.com/cplusplus-tutorial-file-io-in-cplusplus-text-and-
binary-files
By default, C++ opens the files in text mode.
In the tables below we will see the various steps and operations that can be performed
to use files in C++
1)Creating or opening a file
For writing data
Text Files Binary Files

ofstream out (“myfile.txt”); ofstream out (“myfile.txt”,ios::binary);
or or
ofstream out; ofstream out;
out.open(“myfile.txt”); out.open(“myfile.txt”, ios::binary);
For Appending (adding text at the end of the existing file)

ofstream out(“myfile.txt”,ios::app); ofstream out
or (“myfile.txt”,ios::app|ios::binary);
ofstream out; or
out.open(“myfile.txt”, ios::app); ofstream out;
out.open(“myfile.txt”, ios::app | ios::binary);
For reading data

ifstream in (“myfile.txt”); ifstream in (“myfile.txt”, ios::binary);
or or
ifstream in ; ifstream in ;
in.open(“myfile.txt”); in.open(“myfile.txt”, ios::binary);
2) Closing Files (after reading or writing)
ofstream object “out” Ifstream object “in”

out.close(); in.close();
3) Reading / Writing Data to and from files
Data Functions for reading file Function for writing into file
char get(); put();
1 word >>(extraction operator) <<(insertion operator)
>=1 word getline(); <<(insertion operator)
Objects read() write()
Binary data Same as above Same as above
4) Functions that can be used to perform special tasks
Operation function Description

Checking end of file. eof() Used to check eof during
the reading of file
Check if an operation bad() Returns true
fails. if a reading or writing operation fails.
Check if an operation Fail() Returns true

fails. in the same cases as bad(), but also in the case that
a format error
happens.
Checking for opened is_open(); Checks if the file is

file. opened or not, returns true if the file is opened else
false
Number of bytes gcount() Returns count of the
already bytes read from the file
read.
Ignoring characters ignore() Ignores n bytes from the
during file read. file. (get pointer is positioned after n
character)
Checking next peek() Checks the next available
character. character, will not increase the get pointer to next
character.
Random access (only seekg() In case of binary files random access is performed
for seekp() using these functions. They either give or set the
binary files). tellg() position of get and put pointers on the particular
tellp() location
Eg1: Write to filename
#include <fstream>
int main()
ofstream SaveFile("cpp-home.txt");
SaveFile << "Hello World, from www.cpp-home.com and Loobian!";
SaveFile.close();
return 0;
eg2: Reading a filename
#include <fstream.h>
void main() //the program starts here
ifstream OpenFile("cpp-home.txt");
char ch;
while(!OpenFile.eof())
OpenFile.get(ch);
cout << ch;

}
OpenFile.close();
eg3: Append a file
void main()
ofstream SaveFile("file1.txt", ios::ate);
SaveFile << "That's new!\n";
SaveFile.close();
eg 4:
void main()
fstream File("test.txt",ios::in | ios::out);
File << "Hi!"; //put “Hi!” in the file
static char str[10]; //when using static, the array is automatically
//initialized, and very cell NULLed
File.seekg(ios::beg); //get back to the beginning of the file
//this function is explained a bit later
File >> str;
cout << str << endl;
File.close();
eg 5: Using put & get
void main()
{
fstream File("test_file.txt",ios::out | ios::in | ios::binary);
char ch;
ch='o';
File.put(ch); //put the content of ch to the file
File.seekg(ios::beg); //go to the beginning of the file
File.get(ch); //read one character
cout << ch << endl; //display it
File.close();
eg 6: Using Read & write
#include <string.h>
void main()
fstream File("test_file.txt",ios::out | ios::in | ios::binary);
char arr[13];
strcpy(arr,"Hello World!"); //put Hello World! into the array
File.write(arr,5); //put the first 5 symbols into the file- "Hello"
File.seekg(ios::beg); //go to the beginning of the file
static char read_array[10]; //I will put the read data, here
File.read(read_array,3); //read the first 3 symbols- "Hel"
cout << read_array << endl; //display them
File.close();
eg 7: Current file pointers
void main()
{
//if we have "Hello" in test_file.txt
ifstream File("test_file.txt");
char arr[10];
File.read(arr,10);
//this should return 5, as Hello is 5 characters long
cout << File.tellg() << endl;
File.close();
eg 9: Getline
void main()
//if we have "Hello World" in test_file.txt
static char arr[10];
/*read, until one of these happens:
1) You have read 10
2) You met the letter "o"
3) There is new line
*/
File.getline(arr,10,'o');
cout << arr << endl; //it should display "Hell"
File.close();
eg 10:
void main()
{
//if we have "Hello World" in test_file.txt
char ch;
File.get(ch);
cout << ch << endl; //should display "H"
cout << char(File.peek()) << endl; //should display "e"
cout << char(File.peek()) << endl; //should display "e" again
File.get(ch);
cout << ch << endl; //should display "e" again
File.close();
eg 11:
#include <fstream.h>#include <io.h>
void main()
ofstream File;
File.open("delete_test.txt"); //creates the file
File.close();
_unlink("delete_test.txt"); //deletes the file
//tries to open the file, but if it does not exists
//the function will rreturn error ios::failbit
File.open("delete_test.txt",ios::nocreate);
//see if it returned it
if(File.rdstate() == ios::failbit)
cout << "Error...!\n"; //yup,it did
File.close();
}
eg 12:
void main()
//test_file.txt should have this text- "Hello World"
char ch;
File.get(ch);
cout << ch << endl; //it will display "H"
File.putback(ch);
cout << ch << endl; //it will again display "H"
File.get(ch);
cout << ch << endl; //it will display "H" again
File.close();
11.9 'asm' Keyword
To accommodate special situations, C++ provides a "trap door" that allows you to
drop into assembly code at any time, bypassing the C++ compiler entirely. This "trap door" is
the asm statement. Using asm, you can embed assembly language directly into your C++
program. This assembly code is compiled without any modification, and it becomes part of
your program's code at the point at which the asm statement occurs.
The general form of the asm keyword is shown here:
asm ("op-code");
where op-code is the assembly language instruction that will be embedded in your program.
However, several compilers also allow the following forms of asm:
asm instruction ;
asm instruction newline
asm {
instruction sequence
Here, instruction is any valid assembly language instruction. Because of the implementation-
specific nature of asm, you must check the documentation that came with your compiler for
details. At the time of this writing, Microsoft's Visual C++ uses _ _asm for embedding
assembly code. It is otherwise similar to asm. Here is a simple (and fairly "safe") example
that uses the asm keyword:
#include <iostream>
int main()
asm int 5; // generate intertupt 5
return 0;
Types of errors
1. Syntax error:-
This error occurs due to following reason.
I. Not following the grammatical rules used in declaration of identifier.
II. Not declaring an identifier used in program.
III. Not terminating statement by semicolon.
IV. Not providing equal number of opening and closing braces etc.
These errors can be rectified by the user as it is displayed while compiling the program.
2. Logical error:-
This error won’t be displayed on the screen. However it will lead to display wrong
results. Example: An infinite loop. This error lead to abnormal termination of a program or
infinite loop.
3. Runtime error:-
This error occurs while running a program by displaying the message listed below.
I. Division by 0.
II. Overflow
III. Underflow
3.1 Fatal errors
A fatal error is basically when the executable crashes.
Example 1: The program divided by zero, as in:
int scores = 500;
int num = 0;
int avg;
avg = scores / num;
The program would crash saying:
Floating exception
Example 2: Segmentation faults, Bus errors.
These occur when you try to access memory that your program is not allowed to use
or that doesn't exist in the computer (i.e., there is only so much memory in the
computer).
3.2 Logical errors

4. Linker error
These are errors generated when the executable of the program cannot be
generated. This may be due to wrong function prototyping, incorrect header files.
5. Execution error
These errors occur at the time of execution. Looping and arithmetic errors falls
Data Abstraction in C++
Data abstraction refers to, providing only essential information to the outside world
and hiding their background details, i.e., 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.
Data Abstraction Example:
Any C++ program where you implement a class with public and private members is an example
of data abstraction. Consider the following example:
#include <iostream>
class Adder
public:
//Constructor
Adder(int i = 0)
total = i;
void addNum(int num)
total += num;
int getTotal()
return total;
}
private:
//hidden data from outside
int total;
};
int main()
Adder a;
a.addNum(10);
a.addNum(20);
a.addNum(30);
cout<<”Total”<<a.getTotal()<<endl;
return 0;
Output:
Total 60
Above class adds numbers together, and returns the sum. The public
members addNumand getTotal are the interfaces to the outside world and a user needs to
know them to use the class. The private member total is something that the user doesn't
need to know about, but is needed for the class to operate properly.
Characteristics of abstract class
1. Abstract class cannot be instantiated, but pointers and refrences of Abstract
class type can be created.
2. Abstract class can have normal functions and variables along with a pure virtual
function.
3. Abstract classes are mainly used for Upcasting, so that its derived classes can
use its interface.
4. Classes inheriting an Abstract Class must implement all pure virtual functions, or
else they will become Abstract too.

* Why can't we create Object of Abstract Class ?
When we create a pure virtual function in Abstract class, we reserve a slot for a function in
the VTABLE(studied in last topic), but doesn't put any address in that slot. Hence the
VTABLE will be incomplete. As the VTABLE for Abstract class is incomplete, hence the
compiler will not let the creation of object for such class and will display an errror message
whenever you try to do so.
Virtual base class (Diamond Problem)
Because a class can be an indirect base class to a derived class more than once, C++ provides
a way to optimize the way such base classes work. Virtual base classes offer a way to save
space and avoid ambiguities in class hierarchies that use multiple inheritance. Each non
virtual object contains a copy of the data members defined in the base class. This
duplication wastes space and requires you to specify which copy of the base class members
you want whenever you access them. When a base class is specified as a virtual base, it can
act as an indirect base more than once without duplication of its data members. A single
copy of its data members is shared by all the base classes that use it as a virtual base.
When declaring a virtual base class, the virtual keyword appears in the base lists of the
derived classes. When two or more objects are derived from a common base class, we can
prevent multiple copies of the base class being present in an object derived from those
objects by declaring the base class as virtual when it is being inherited. Such a base class is
known as virtual base class. This can be achieved by preceding the base class’ name with the
word virtual.
Find the below example:
#include<iostream>
class A
public:
int i;
};
class B : virtual public A

{
public:
int j;
};
class C: virtual public A
public:
int k;
};
class D: public B, public C
public:
int sum;
};
int main()
D ob;
ob.i=10;//unambiguous since only 1 copy of i is inherited.
ob.j = 20;
ob.k = 30;
ob.sum = ob.i + ob.j + ob.k;
cout << “Value of i is : ”<< ob.i<<”\n”;
cout << “Value of j is : ”<< ob.j<<”\n”; cout << “Value of k is :”<< ob.k<<”\n”;
cout << “Sum is : ”<< ob.sum <<”\n”;
return 0;
Singleton class in C++
A class whose number of instances that can be instantiated is limited to one is called a
singleton class. Thus, at any given time only one instance can exist, no more.
Singleton class uses:
The singleton design pattern is used whenever the design requires only one instance of a
class. Some examples:

Application classes. There should only be one application class.
(Note: Please bear in mind, MFC class 'CWinApp' is not implemented as a
singleton class)
Logger classes. For logging purposes of an application there is usually one logger
instance required.
Singleton
Singleton is a creational design pattern.
A design pattern to provide one and only instance of an object.
Make the constructors of the class private.
Store the object created privately.
Provide access to get the instance through a public method.
Can be extended to create a pool of objects.
Singleton example:
#include <iostream>
// Singleton class
class MySingleton {
public:
static MySingleton* iInstance;
public:
static MySingleton* GetInstance();
private:
// private constructor
MySingleton();
};
MySingleton* MySingleton::iInstance = NULL;
MySingleton::MySingleton()
cout << "In construtor ..." << endl;
MySingleton* MySingleton::GetInstance()
{
if ( iInstance == NULL )
iInstance = new MySingleton();
return iInstance;
void main()
MySingleton* obj;
obj = MySingleton::GetInstance();
OUTPUT:
In construtor ... //(displayed only once)
A Singleton is an elegant way of maintaining global state, but we should always question
whether we need global state. Singleton pattern offers several advantages over global
variables because it does the following:Enforces that only one instance of the class can be
instantiated.Allows control over the allocation and destruction of the object.Provides
thread-safe access to the object's global state.Prevents the global namespace from being
polluting.
Singleton example 2:
#include <iostream>
class Singleton
public:
static Singleton *getInstance();
private:
Singleton(){}
static Singleton* instance;
};
Singleton* Singleton::instance = 0;
Singleton* Singleton::getInstance()
if(!instance)
instance = new Singleton();
cout << "getInstance(): First instance\n";
return instance;
else
cout << "getInstance(): previous instance\n";
return instance;
int main()
Singleton *s1 = Singleton::getInstance();
Singleton *s2 = Singleton::getInstance();
return 0;
11.6 What are zombie objects in C++?
An object creation of a class is failed before executing its constructor. As a
constructor would not return a value, there is no confirmation that whether the constructor
is executed completely or not.
An object that is freed does not crash the applications. The application debugging is
allowed by making the all states of the object intact.
Encapsulation Vs Abstraction
Encapsulation:--Information hiding.
Abstraction:-- Implementation hiding.

Static Class Members
Static Data Members
Data member is declared both inside shared and outside of it. As mentioned earlier,
this is necessary because the declaration of a inside shared does not allocate storage.
One use of a static member variable is to provide access control to some shared
resource used by all objects of a class. Another interesting use of a static member variable
is to keep track of the number of objects of a particular class type that are in existence.
For example,
#include <iostream>
class Counter
{
public:
static int count;
Counter()
{
count++;
}
~Counter()
count--;
};
int Counter::count;
void f();
int main(void)
{
Counter o1;
cout << "Objects in existence: ";
cout << Counter::count << "\n";
Counter o2;
f();
return 0;
void f()
Counter temp;
// temp is destroyed when f() returns
This program produces the following output.
Objects in existence: 1
Static Member Functions
Member functions may also be declared as static. There are several
restrictions placed on static member functions. They may only directly refer to other
static members of the class. (Of course, global functions and data may be accessed by
static member functions.). A static member function does not have a this pointer. There
cannot be a static and a non-static version of the same function. A static member function
may not be virtual. Finally, they cannot be declared as const or volatile.
Actually, static member functions have limited applications, but one good use
for them is to "preinitialize" private static data before any object is actually created. For
example, this is a perfectly valid C++ program:
#include <iostream>
class static_type
{
static int i;
public:
static void init(int x) {i = x;}
void show() {cout << i;}
};
int static_type::i; // define i
int main()
// init static data before object creation

static_type::init(100);
static_type x;
x.show(); // displays 100
return 0;
Passing Objects to Functions
Objects may be passed to functions in just the same way that any other type of variable
can. Objects are passed to functions through the use of the standard call-by- value
mechanism. This means that a copy of an object is made when it is passed to a function.
// Passing an object to a function.

#include <iostream>
class myclass
{
int i;
public:
myclass(int n);
~myclass();
void set_i(int n) { i=n; }
int get_i() { return i; }
};
myclass::myclass(int n)
{
i = n;
cout << "Constructing " << i << "\n";

}
myclass::~myclass()
{
cout << "Destroying " << i << "\n";

}
void f(myclass ob);
int main()
myclass o(1); // Object is created
f(o); // Object is passed to function f()

cout << "This is i in main: ";
cout << o.get_i() << "\n";
return 0;
void f(myclass ob)

{
ob.set_i(2);
cout << "This is local i: " << ob.get_i();
cout << "\n";

}
This program produces this output:
Constructing 1
This is local i: 2
Destroying 2
This is i in main: 1
Destroying 1
Notice that two calls to the destructor function are executed, but only one call is
made to the constructor function. As the output illustrates, the constructor function is not
called when the copy of o(inmain())is passed to ob(withinf()).
Although the constructor function is not called when an object is passed to a
function, it is necessary to call the destructor when the copy is destroyed. (The copy is
destroyed like any other local variable, when the function terminates.) Remember, a new
copy of the object has been created when the copy is made. This means that the copy could
be performing operations that will require a destructor function to be called when the copy
is destroyed. For example, it is perfectly valid for the copy to allocate memory that
must be freed when it is destroyed. For this reason, the destructor function must be
executed when the copy is destroyed.
Functions Returning Objects
A function may return an object to the caller. For example, this is a valid C++ program:
// Returning objects from a function.

#include <iostream>
class myclass
{
int i;
public:
};
myclass f();
//func prototyope which return object of type myclass
int main()
myclass o;
o = f();
cout << o.get_i() << "\n";

return 0;
myclass f()
myclass x;
x.set_i(1);
return x;
}
When an object is returned by a function, a temporary object is automatically
created that holds the return value. It is this object that is actually returned by
the function. After the value has been returned, this object is destroyed. The destruction
of this temporary object may cause unexpected side effects in some situations. For
example, if the object returned by the function has a destructor that frees dynamically
allocated memory, that memory will be freed even though the object that is receiving the
return value is still using it.
Object Assignment
Assuming that both objects are of the same type, you can assign one object to another. This
causes the data of the object on the right side to be copied into the data of the object on
the left.
// Assigning objects.
#include <iostream>
class myclass
{
int i;
public:
};
int main()
myclass ob1, ob2;
ob1.set_i(99);
ob2 = ob1; // assign data from ob1 to ob2
cout << "This is ob2's i: " << ob2.get_i();
return 0;
}
By default, all data from one object is assigned to the other by use of a bit-by-bit
copy. However, it is possible to overload the assignment operator and define some other
assignment procedure
Arrays of Objects
In C++, it is possible to have arrays of objects. The syntax for declaring and using an object
array is exactly the same as it is for any other type of array. For example, this program
uses a three-element array of objects:
#include <iostream>
class cl
{
int i;
public:
void set_i(int j) { i=j; }
};
int main()
cl ob[3];
int i;
for(i=0; i<3; i++)
ob[i].set_i(i+1);
for(i=0; i<3; i++)

cout << ob[i].get_i() << "\n";
return 0;
This program displays the numbers 1, 2, and 3 on the screen.
#include <iostream>
class cl
{
int i;
public:
cl(int j) { i=j; } // constructor
};
int main()
cl ob[3] = {1, 2, 3}; // initializers

// Also initialisation can be done this way
// cl ob[3] = { cl(1), cl(2), cl(3) };
int i;
for(i=0; i<3; i++)

cout << ob[i].get_i() << "\n";
return 0;
Note: Initialized vs. Uninitialized Arrays
cl(int j) { i=j; } // constructor which requires initializers
cl a[9]; // error, constructor requires initializers
cl() { i=0; } // constructor called for non-initialized arrays
cl(int j) { i=j; } // constructor called for initialized arrays
Pointers to Objects
1. #include <iostream>
class cl
{
int i;
public:
cl(int j) { i=j; }
};
int main()
cl ob(88), *p;
p = &ob; // get address of ob
cout << p->get_i(); // use -> to call get_i()

return 0;
2. #include <iostream>
class cl
{
int i;
public:
cl() { i=0; }
cl(int j) { i=j; }
};
int main()
cl ob[3] = {1, 2, 3};

cl *p;
int i;
p = ob; // get start of array

for(i=0; i<3; i++)
cout << p->get_i() << "\n";
p++; // point to next object

}
return 0;
3.
#include <iostream>
class cl
{
public:
int i;
cl(int j) { i=j; }
};
int main()
cl ob(1);
int *p;
p = &ob.i; // get address of ob.i
cout << *p; // access ob.i via p
return 0;
Type Checking C++ Pointers
You may assign one pointer to another only if the two pointer types are compatible. For
example, given:
int *pi;
float *pf;
in C++, the following assignment is illegal:
pi = pf; // error -- type mismatch
Of course, you can override any type incompatibilities using a cast, but doing so bypasses C+
+'s type-checking mechanism.
Pointers to Derived Types
#include <iostream>
class base
{
int i;
public:
void set_i(int num) { i=num; }
};
class derived: public base

{
int j;
public:
void set_j(int num) { j=num; }
int get_j() { return j; }
};
int main()
base *bp;
derived d;
bp = &d; // base pointer points to derived object
// access derived object using base pointer

bp->set_i(10);
cout << bp->get_i() << " ";
/* The following won't work. You can't access element of a derived class using a base class
pointer.
bp->set_j(88); // error
cout << bp->get_j(); // error
*/
return 0;
As you can see, a base pointer is used to access an object of a derived class. Although you
must be careful, it is possible to cast a base pointer into a pointer of the derived type to
access a member of the derived class through the base pointer. For example, this is valid C+
+ code:
// access now allowed because of cast
((derived *)bp)->set_j(88);
cout << ((derived *)bp)->get_j();
Pointers to Class Members
The type of pointer that "points" generically to a member of a class, not to a specific
instance of that member in an object.
#include <iostream>
class cl
{
public:
cl(int i) { val=i; }
int val;
int double_val() { return val+val; }
};
int main()
int cl::*data; // data member pointer

int (cl::*func)(); // function member pointer
cl ob1(1), ob2(2); // create objects
data = &cl::val; // get offset of variable val

func=&cl::double_val;//get offset of function double_val()
cout << "Here are values: ";

cout << ob1.*data << " " << ob2.*data << "\n";
cout << "Here they are doubled: ";

cout << (ob1.*func)() << " ";
cout << (ob2.*func)() << "\n";
return 0;
When you are accessing a member of an object by using an object or a reference (discussed
later in this chapter), you must use the .* operator. However, if you are using a pointer to
the object, you need to use the –>* operator, as illustrated in this version of the preceding
program:
#include <iostream>
class cl
{
public:
cl(int i) { val=i; }
int val;
int double_val() { return val+val; }
};
int main()
int cl::*data; // data member pointer

int (cl::*func)(); // function member pointer
cl ob1(1), ob2(2); // create objects
cl *p1, *p2;
p1 = &ob1; // access objects through a pointer
p2 = &ob2;
data = &cl::val; // get offset of val

func = &cl::double_val; // get offset of double_val()
cout << "Here are values: ";

cout << p1->*data << " " << p2->*data << "\n";
cout << "Here they are doubled: ";
cout << (p1->*func)() << " ";

cout << (p2->*func)() << "\n";
return 0;
References
A reference is essentially an implicit pointer. There are three ways that a
reference can be used:
as a function parameter.
as a function return value.
as a stand-alone reference.
1. Reference Parameters
It allow you to create functions that automatically use call-by-reference parameter passing.
Call-by-reference passes the address of the argument to the function. By default, C++ uses
call-by-value, but it provides two ways to achieve call-by-reference parameter passing.
1. // Manually create a call-by-reference using a pointer.
#include <iostream>
void neg(int *i);
int main()
{
int x;
x = 10;
cout << x << " negated is ";
neg(&x);
cout << x << "\n";
return 0;
void neg(int *i)

{
*i = -*i;
2. // Use a reference parameter.

#include <iostream>
void neg(int &i); // i now a reference
int main()
int x;
x = 10;
cout << x << " negated is ";
neg(x); // no longer need the & operator

cout << x << "\n";
return 0;
void neg(int &i)

{
i = -i; // i is now a reference, don't need *

}
2. Passing References to Objects
when an object is passed as an argument to a function, a copy of that object is made. When
the function terminates, the copy's destructor is called. If for some reason you do not want
the destructor function to be called, simply pass the object by reference. (Later in this
book you will see examples where this is the case.) When you pass by reference, no copy of
the object is made. This means that no object used as a parameter is destroyed when the
function terminates, and the parameter's destructor is not called. For example, try this
program:
#include <iostream>
class cl
{
int id;
public:
int i;
cl(int i);
~cl();
void neg(cl &o){ o.i = -o.i; }// no temporary created
};
cl::cl(int num)
{
cout << "Constructing " << num << "\n";
id = num;
cl::~cl()
{
cout << "Destructing " << id << "\n";
int main()
cl o(1);
o.i = 10;
o.neg(o);
cout << o.i << "\n";
return 0;
Here is the output of this program:
Constructing 1
-10
Destructing 1
As you can see, only one call is made to cl's destructor function. Had o been passed by
value, a second object would have been created inside neg( ), and the destructor would
have been called a second time when that object was destroyed at the time neg( )
terminated
3. Returning References
A function may return a reference. This has the rather startling effect of allowing a
function to be used on the left side of an assignment statement! For example, consider this
simple program:
#include <iostream>
char &replace(int i); // return a reference

char s[80] = "Hello There";
int main()
replace(5) = 'X'; // assign X to space after Hello
cout << s;
return 0;
char &replace(int i)
{
return s[i];
}
This program replaces the space between Hello and There with an X. That is, the program
displays HelloXthere. Take a look at how this is accomplished. First, replace( ) is declared
as returning a reference to a character. As replace( ) is coded, it returns a reference to
the element of s that is specified by its argument i. The reference returned by replace( )
is then used in main( ) to assign to that element the character X.
Bitwise copy vs memberwise copy in C++
1. shallow copy = bitwise copy and deep copy = memberwise copy

The compiler will give us a default copy constructor if needed when we do not provide it.
And this constructor is memberwise copy.
Bitwise copy means copy an whole object directly. Where it will be used? I don't know,
maybe it is an concept in implementation detail, and memcpy() could be used
to achieve it.
Memberwise copy means copy one member of an object at a time.
Deep Copy = memberwise copy
class MyClass {
int *p;
public:
MyClass() : p(new int) {}
MyClass(MyClass const &) : p(new int) {}
};
int main()
MyClass obj1,obj2;
obj2 = obj1; /* Deep Copy */
C++ always do memberwise copy by default.
What is Shallow Copy?
Shallow copy is a bit-wise copy of an object. A new object is created that has an exact
copy of the values in the original object. If any of the fields of the object are references
to other objects, just the reference addresses are copied i.e., only the memory address is
copied.
In this figure, the MainObject1 have fields "field1" of int type, and "ContainObject1" of
ContainObject type. When you do a shallow copy of MainObject1, MainObject2 is created
with "field3" containing the copied value of "field1" and still pointing to ContainObject1
itself. Observe here and you will find that since field1 is of primitive type, the values of it
are copied to field3 but ContainedObject1 is an object, so MainObject2 is still pointing to
ContainObject1. So any changes made to ContainObject1 in MainObject1 will reflect in
MainObject2.
What is Deep Copy?
A deep copy copies all fields, and makes copies of dynamically allocated memory pointed to
by the fields. A deep copy occurs when an object is copied along with the objects to which
it refers.
In this figure, the MainObject1 have fields "field1" of int type, and "ContainObject1" of
ContainObject type. When you do a deep copy of MainObject1, MainObject2 is created with
"field3" containing the copied value of "field1" and "ContainObject2" containing the copied
value of ContainObject1.So any changes made to ContainObject1 in MainObject1 will not
reflect in MainObject2.
Copy constructor vs Assignment operator
A a;
A a2=a; //copy constructor call
A a3(a); //copy constructor call
A a4=a2=a1; //assignment operator for a2, the copy ctor for a4
a1=a2; //memberwise copy
Separate Header and Implementation Files
// TestTemp.h
#ifndef _TESTTEMP_H_
#define _TESTTEMP_H_
template<class T>
class TestTemp
{
public:
TestTemp();
void SetValue( T obj_i );
T Getalue();
private:
T m_Obj;
};
// TestTemp.cpp
#include "TestTemp.h"
template <class T>
TestTemp<T>::TestTemp()
{
template <class T>

void TestTemp<T>::SetValue( T obj_i )
{
}
template <class T>
T TestTemp<T>::Getalue()
{
return m_Obj;
}
The advantages of storing class definition in separate file are
1. The class is reusable
2. The clients of the class know what member functions the class provides, how to call them
and what return types to expect
3. The clients do not know how the class's member functions are implemented.
pointer variable vs reference variable in C++?
Pointers and references are equivalent, except:
A reference is a name constant for an address. You need to initialize the reference
during declaration.
int & iRef; // Error: 'iRef' declared as reference but not initialized
Once a reference is established to a variable, you cannot change the reference to
reference another variable.
To get the value pointed to by a pointer, you need to use the dereferencing operator * (e.g.,
if pNumber is a int pointer, *pNumber returns the value pointed to by pNumber. It is
calleddereferencing or indirection). To assign an address of a variable into a pointer, you
need to use the address-of operator & (e.g., pNumber = &number). On the other hand,

referencing and dereferencing are done on the references implicitly. For example,
if refNumber is a reference (alias) to another int variable, refNumber returns the value of
the variable. No explicit dereferencing operator * should be used. Furthermore, to assign an
address of a variable to a reference variable, no address-of operator & is needed.
/* Pass-by-reference using pointer (TestPassByPointer.cpp) */ #include <iostream>

void square(int *);
int main()
{
int number = 8;
cout << "In main(): " << &number << endl; // 0x22ff1c
cout << number << endl; // 8
square(&number); // Explicit referencing to pass an address
}
//Function takes an int pointer (non-const)

void square(int * pNumber)
{
cout << "In square(): " << pNumber << endl; // 0x22ff1c
*pNumber *= *pNumber;// Explicit de-referencing to get the value pointed-to
}
/* Pass-by-reference using reference(TestPassByReference.cpp) */

#include <iostream>
void square(int &);
int main()
{
int number = 8;
cout << "In main(): " << &number << endl; // 0x22ff1c
square(number); // Implicit referencing (without '&')
}
// Function takes an int reference (non-const)

void square(int & rNumber)
{
cout << "In square(): " << &rNumber << endl; // 0x22ff1c
rNumber *= rNumber;//Implicit de-referencing (without '*')
}
Both references and pointers can be used to change local variables of one function
inside another function. Both of them can also be used to save copying of big objects when
passed as arguments to functions or returned from functions, to get efficiency gain.

Despite above similarities, there are following differences between references and
pointers.
References are less powerful than pointers
1) Once a reference is created, it cannot be later made to reference another object; it
cannot be reseated. This is often done with pointers.
2) References cannot be NULL. Pointers are often made NULL to indicate that they are not
pointing to any valid thing.
3) A reference must be initialized when declared. There is no such restriction with pointers
Due to the above limitations, references in C++ cannot be used for implementing data
structures like Linked List, Tree, etc. In Java, references don’t have above restrictions, and
can be used to implement all data structures. References being more powerful in Java, is
the main reason Java doesn’t need pointers.
References are safer and easier to use:
1) Safer: Since references must be initialized, wild references like wild pointers are unlikely
to exist. It is still possible to have references that don’t refer to a valid location
2) Easier to use: References don’t need dereferencing operator to access the value. They
can be used like normal variables. ‘&’ operator is needed only at the time of declaration.
Also, members of an object reference can be accessed with dot operator (‘.’), unlike
pointers where arrow operator (->) is needed to access members.
Together with the above reasons, there are few places like copy constructor argument
where pointer cannot be used. Reference must be used pass the argument in copy
constructor. Similarly references must be used for overloading some operators like ++.
Passing arguments by reference to functions
Advantages of passing by reference:
It allows a function to change the value of the argument, which is sometimes useful.
Otherwise, const references can be used to guarantee the function won’t change the
argument.
Because a copy of the argument is not made, it is fast, even when used with large structs or
classes.
References can be used to return multiple values from a function.

References must be initialized, so there’s no worry about null values.
Disadvantages of passing by reference:
Because a non-const reference cannot be made to an rvalue (e.g. a literal or an expression),
reference arguments must be normal variables.
It can be hard to tell whether a parameter passed by non-const reference is meant to be
input, output, or both. Judicious use of const and a naming suffix for out variables can help.
It’s impossible to tell from the function call whether the argument may change. An
argument passed by value and passed by reference looks the same. We can only tell whether
an argument is passed by value or reference by looking at the function declaration. This can
lead to situations where the programmer does not realize a function will change the value of
the argument.
When to use pass by reference:
When passing structs or classes (use const if read-only).
When you need the function to modify an argument.
When not to use pass by reference:
When passing arrays (use pass by address).
When passing fundamental types (use pass by value).
Vtable, vptr & vfunc
1. Virtual Table is a lookup table of function pointers used to dynamically bind the virtual
functions to objects at runtime.
2. It is not intended to be used directly by the program, and as such there is no
standardized way to access it.
3. Every class that uses virtual functions (or is derived from a class that uses virtual
functions) is given it's own virtual table as a secret data member.
4. This table is set up by the compiler at compile time. A virtual table contains one entry as
a function pointer for each virtual function that can be called by objects of the class.
5. Virtual table stores NULL pointer to pure virtual functions in ABC.
Note: Virtual Table is created even for classes that have virtual base classes. In this case,
the vtable has pointer to the shared instance of the base class along with the pointers to
the classe's virtual functions if any.
vpointer:
This vtable pointer or _vptr, is a hidden pointer added by the Compiler to the base class.
And this pointer is pointing to the virtual table of that particular class. This _vptr is
inherited to all the derived classes. Each object of a class with virtual functions
transparently stores this _vptr.
Programme to get vptr:

#include<iostream>
//#include<conio.h>
class Base
{
public:
virtual void display() //virtual function
{
cout<<"\nBase : display()..";
}
virtual void goodMorning() //virtual function
{
cout<<"\nBase : Good morning..";
}
};
class Derived:public Base
{
public:
void display() //virtual by default
{
cout<<"\nDerived : display()..";
}
//Derived does not override goodMorning()
};
int main()
{
Derived d1;
int *vptr=(int *)&d1; //vptr points to Derived object
cout<<vptr;
/Virtual pointer is stored in first 2 bytes of object
vptr=(int *)*vptr; //copy virtual pointer (first 2 bytes) into vptr
cout<<vptr;
//Now content of vptr is nothing but address of VTABLE
//call display()
((void (*)()) *vptr )();
//*vptr is address of first virtual function in VTABLE viz. display()
//and we cast VPTR to a function pointer
++vptr; //move 2 bytes ahead
//access second function in Derived's VTABLE viz.Base::goodMorning()
((void (*)()) *vptr )();
//getch();
return 0;
}
class base
{
virtual void funct1(void);
virtual void funct2(void);
};
base b;
/* C++ Compiler internally Does this*/
b.vptr = address of b.vtable;
b.vtable[0]= &base::funct1;
b.vtable[1]= &base::funct2;
VFPTR VFTABLE FUNCTION

b.vfptr -> Vftable[0] -> base::funct1()
Vftable[1] -> base::funct2()
namespace
• using: You are going to use it.
• namespace: To use what? A namespace.
• std:
The std namespace (where features of the C++ Standard Library, suc h as string or vector ,
are declared). A namespace is a declarative region that provides a scope to the identifiers
(the names of types, functions, variables, etc) inside it. Namespaces are used to organize
code into logical groups and to prevent name collisions that can occur especially when your
code base includes multiple libraries. All identifiers at namespace scope are visible to one
another without qualification. Identifiers outside the namespace can access the members by
using the fully qualified name for each identifier, for example std::vector<std::string> vec;,
or else by a using Declaration for a single identifier (using std::string), or a using Directive
(C++) for all the identifiers in the namespace (using namespace std;).
The std namespace is special; it is short for the word "standard." The built in C++ library
routines are kept in the standard namespace. That includes stuff like cout, cin, string,
vector, map, etc. Because these tools are used so commonly, it's popular to add "using
namespace std" at the top of your source code so that you won't have to type the std::
prefix constantly. And because these functions are kept in a namespace, if you really want
to use "vector" as a variable name, you still can. Namespaces give you more freedom to use
short, accurate names. One side note: it is bad manners to put "using namespace"
declarations in header files. It forces all includers of that header file to use that
namespace, which might result in naming ambiguities that are hard to fix. This practice is
called "namespace pollution." Instead, always use the fully prefixed names in header files
(std::string not string) and save the using declarations for the source files. std::cout
searches in std library and get cout
#include <iostream>
int main()
{
std::cout<<"Hello, world!\n";
}
If you don't tell C++ which drawer to look in, it won't find what you want.
#include <iostream>
int main()
{
cout<<"Hello, world!\n";
}
Now, it's somewhat tedious to keep typing std:: in front of everything, so you can also tell C++ to assume what
drawer to look in
#include <iostream>
int main()
{
using std::cout;
cout<<"Hello, world!\n";
}
Creating Namespaces
#include<iostream>
namespace myconstants
{
const double pi = 3.141592;
}
namespace myshapes
{
double area;
double perimeter;
void AreaOfCircle(double radius)
{
area = myconstants::pi * radius * radius;
}
void PerimeterOfCircle(double radius)
{
perimeter = 2 * myconstants::pi * radius;
}
}
int main(int argc, char * argv[])
{
double r;
cout << endl << "Enter Radius:";
cin >> r;
myshapes::AreaOfCircle(r);
cout << endl << "Area of the Circle is :" << myshapes::area;
myshapes::PerimeterOfCircle(r);
cout << endl << "Perimeter of the Circle is :" << myshapes::perimeter;
}
Using Namespaces
Namespaces are used with the ‘using’ keyword, which makes all the members of the
namespace available inthe current program and the members can be used directly, without
taking reference of the namespace.

#include<iostream>
namespace mynamespace
{
int i,j;
}
using namespace mynamespace;
int main(int argc, char *argv[])
{
cout<<endl<<i<<","<<j;
}
without the ‘using’ keyword:
#include<iostream>
namespace mynamespace
{
int i,j;
}
int main(int argc, char *argv[])
{
std::cout<<endl<<mynamespace::i<<","<<mynamespace::j;
}
'inline' function
C++ inline function is powerful concept that is commonly used with classes. If a function is
inline, the compiler places a copy of the code of that function at each point where the
function is
called at compile time. Any change to an inline function could require all clients of the
function to be recompiled because compiler would need to replace all the code once again
otherwise it will continue with old functionality. A function definition in a class definition is
an automatic inline function definition, even without the use of the inline specifier. features
of inline
1.We must keep inline functions small, small inline functions have better efficiency.
2.Inline functions do increase efficiency, but we should not make all the functions inline.
Because if we make large functions inline, it may lead to code bloat, and might affect the
speed too.
3.Hence, it is adviced to define large functions outside the class definition using scope
resolution ::operator, because if we define such functions inside class definition, then they
become inline automatically.
4.Inline functions are kept in the Symbol Table by the compiler, and all the call for such
functions is taken care at compile time.
Limitations of Inline Functions
1. The compiler is unable to perform inlining if the function is too complicated. So we must
avoid big looping conditions inside such functions. In case of inline functions, entire function
body is inserted in place of each call, so if the function is large it will affect speed and
memory badly.
2. Also, if we require address of the function in program, compiler cannot perform inlining
on such functions. Because for providing address to a function, compiler will have to allocate
storage to it. But inline functions doesn't get storage, they are kept in Symbol table.
Compiler may not perform inlining in such circumstances like:
1) If a function contains a loop. (for, while, do-while)
2) If a function contains static variables.
3) If a function is recursive.
4) If a function return type is other than void, and the return statement doesn’t exist in
function body.
5) If a function contains switch or goto statement.
Advantages :-
1. It does not require function calling overhead.
2. It also save overhead of variables push/pop on the stack, while function calling.
3. It also save overhead of return call from a function.
4. It increases locality of reference by utilizing instruction cache.
5. After in-lining compiler can also apply intra-procedural optimization if specified. This is
the
most important one, in this way compiler can now focus on dead code elimination, can give
more stress on branch prediction, induction variable elimination etc..
static_cast
/*
* The static_cast operator can be used for operations such as
* 1. Converting a pointer of a base class to a pointer of a
* derived class,
* 2. Convert numeric data types such as enums to ints or ints to floats.
* However, static_cast conversions are not necessarily
* safe as no run-time type check is done which can cause* casting between incompatible data types(non related
class/objects), for example pointers.
*/
#include <iostream>
class A
{
};
class B : public A
{
int a=10;
public:
void f(const string b)
{
//cout << "Class B::f()" << endl;
//a=b;
cout << b << endl;
}
};
class C : public A
{
int a=20;
public:
void f(const string b)
{
//cout << "Class C::f()" << endl;
//a=b;
cout << b << endl;
}
};
int main()
{
A a;
B b;
C c;
b.f("Class B");
c.f("Class C");
// B::f()
// C::f()
A *pA = &a;
B *pB = &b;
C *pC = &c;
pB = static_cast<B *>(&a);
pB->f("A 2 B");
pA=pB;
//pC=pA; // Not Allowed, C & A are non related.
pC=static_cast<C *>(pA); // no error: results in errotic
pC->f("B 2 C");
}
Sizeof class objects
There are many factors that decide the size of an object of a class in C++. These factors
are:
1. Size of all non-static data members
2. Order of data members
3. Byte alignment or byte padding
4. Size of its immediate base class
5. The existence of virtual function(s)(Dynamic polymorphism using virtual
functions).
6. Compiler being used
7. Mode of inheritance (virtual inheritance)
http://www.cprogramming.com/tutorial/size_of_class_object.html
Virtual Function
Virtual Function is a function in base class, which is overrided in the derived class, and
which tells the compiler to perform Late Binding on this function.

class Base
//Abstract base class
{
public:
virtual void show() = 0;
};
//Pure Virtual Function

void Base :: show()
//Pure Virtual definition
{
cout << "Pure Virtual definition\n";
}
class Derived:public Base

{
public:
void show()
{
cout<<"Implementationof Virtual Function in Derived class";
}
};
int main()
{
Base *b;
Derived d;
b = &d;
b->show();
}
Also, the Pure Virtual function must be defined outside the class definition. If you will
define it inside the class definition, complier will give an error. Inline pure virtual definition
is Illegal.
* Smart pointer
A smart pointer is an abstract data type that simulates a pointer while providing additional
features, such as automatic memory management or bounds checking. These additional
features are intended to reduce bugs caused by the misuse of pointers while retaining
efficiency. Smart pointers typically keep track of the memory they point to. They may also
be used to manage other resources, such as network connections and file handles. Smart
pointers originated in the C++ programming language.
1. Using smart pointers, we can make pointers to work in way that we don’t need to explicitly
call delete. Smart pointer is a wrapper class over a pointer with operator like * and ->
overloaded. The objects of smart pointer class look like pointer, but can do many things that
a normal pointer can’t like automatic destruction (yes, we don’t have to explicitly use
delete), reference counting and more. The idea is to make a class with a pointer, destructor
and overloaded operators like * and ->. Since destructor is automatically called when an
object goes out of scope, the dynamically allocated memory would automatically deleted (or
reference count can be decremented). Consider the following simple smartPtr class.
Eg:
#include<iostream>
class SmartPtr
{
int *ptr; // Actual pointer
public:
//Constructor:Referhttp://www.geeksforgeeks.org/g-fact-93/
// for use of explicit keyword
explicit SmartPtr(int *p = NULL) { ptr = p; }
// Destructor
~SmartPtr() { delete(ptr); }
// Overloading dereferencing operator
int &operator *() { return *ptr; }
int *operator ->() { return ptr; }
};
int main()
{
//SmartPtr ptr(new int());
//*ptr = 20;
SmartPtr ptr(new int(20));
cout<<*ptr;
/* We don't need to call delete ptr:when the object
ptr goes out of scope, destructor for it is automatically called and destructor does delete ptr. */
return 0;
}
2. Can we write one smart pointer class that works for all types? Yes, we can use templates
to write a generic smart pointer class. Following C++ code demonstrates the same.
#include<iostream>
// A generic smart pointer class
template <class T>
class SmartPtr
{
T *ptr; // Actual pointer
public:
// Constructor
explicit SmartPtr(T *p = NULL) { ptr = p; }
// Destructor
~SmartPtr() { delete(ptr); }
// Overloading dereferncing operator
T & operator * ()
{
return *ptr;
}
// Overloding arrow operator so that members of T can be accessed
// like a pointer (useful if T represents a class or struct or
// union type)
T * operator -> ()
{
return ptr;
}
};
int main()
{
SmartPtr<int> ptr(new int());
*ptr = 20;
cout << *ptr;
return 0;
}
Virtual memory
Virtual memory is a feature of an operating system (OS) that allows a computer to
compensate for shortages of physical memory by temporarily transferring pages of data
from random access memory(RAM) to disk storage.
Page fault
A page fault (sometimes called #PF or PF) is a type of interrupt, called trap, raised by
computer hardware when a running program accesses a memory page that is mapped into the
virtual address space, but not actually loaded into main memory. An interrupt that occurs
when a program requests data that is not currently in real memory. The interrupt triggers
the operating system to fetch the data from a virtual memory and load it into RAM. An
invalid page fault or page fault error occurs when the operating system cannot find the data
in virtual memory. This usually happens when the virtual memory area, or the table that
maps virtual addresses to real addresses, becomes corrupt.
A page fault is the sequence of events occurring when a program attempts to access
data (or code) that is in its address space, but is not currently located in the system's RAM.
The operating system must handle page faults by somehow making the accessed data
memory resident, allowing the program to continue operation as if the page fault had never
occurred. In the case of our hypothetical application, the CPU first presents the desired
address (12374) to the MMU. However, the MMU has no translation for this address. So, it
interrupts the CPU and causes software, known as a page fault handler, to be executed. The
page fault handler then determines what must be done to resolve this page fault. It can:
•Find where the desired page resides on disk and read it in (this is normally the case
if the page fault is for a page of code)
•Determine that the desired page is already in RAM (but not allocated to the
current process) and reconfigure the MMU to point to it
•Point to a special page containing nothing but zeros and later allocate a page only if
the page is ever written to (this is called a copy on write page, and is often used for
pages containing zero-initialized data)
•Get it from somewhere else (which is discussed in more detail later)
Swapping
Swapping is exchanging data between the hard disk and the RAM . The Purpose Of Swapping
. So, we can say that the purpose of swapping, or paging, is to access data being stored in
hard disk and to bring it into the RAM so that it can be used by the application program.
Remember that swapping is only necessary when that data is not already in the RAM.While
swapping (writing modified pages out to the system swap space) is a normal part of a
system's operation, it is possible to experience too much swapping. The reason to be wary of
excessive swapping is that the following situation can easily occur, over and over again:
•Pages from a process are swapped
•The process becomes runnable and attempts to access a swapped page
•The page is faulted back into memory(most likely forcing some other processes' pages to
be swapped out)
•A short time later, the page is swapped out again
What is object slicing?

"Slicing" is where you assign an object of a derived class to an instance of a base class,
thereby losing part of the information - some of it is "sliced" away.

For example,
class A
{
int foo;
};
class B : public A
{
int bar;
};
So an object of type B has two data members, foo and bar .
Then if you were to write this:
B b;
A a = b;
Then the information in b about member bar is lost in a .
Copy Constructor
A copy constructor is a member function which initializes an object using another object of
the same class. A copy constructor has the following general function prototype:
#include<iostream>
class Point
{
private:
int x, y;
public:
Point(int x1, int y1) { x = x1; y = y1; }
// Copy constructor
Point(const Point &p2) {x = p2.x; y = p2.y; }
int getX()
{return x; }
int getY()
{return y; }
};
int main()
{
Point p1(10, 15); // Normal constructor is called here
Point p2 = p1; // Copy constructor is called here
// Let us access values assigned by constructors
cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
cout << "\np2.x = " << p2.getX() << ", p2.y = " << p2.getY();
return 0;
}
When is copy constructor called?
In C++, a Copy Constructor may be called in following cases:
1. When an object of the class is returned by value.

2. When an object of the class is passed (to a function) by value as an argument.
3. When an object is constructed based on another object of the same class.
4. When compiler generates a temporary object.
It is however, not guaranteed that a copy constructor will be called in all these cases,
because the C++ Standard allows the compiler to optimize the copy away in certain cases,
one example being the return value optimization (sometimes referred to as RVO).
Source: http://www.geeksforgeeks.org/g-fact-13/
When is user defined copy constructor needed?If we don’t define our own copy constructor,
the C++ compiler creates a default copy constructor for each class which does a member
wise copy between objects. The compiler created copy constructor works fine in general.
We need to define our own copy constructor only if an object has pointers or any run time
allocation of resource like file handle, a network connection..etc.
Copy constructor vs Assignment Operator
Which of the following two statements call copy constructor and which one calls assignment
operator?
MyClass t1=t2;
MyClass t3 = t1; // ---->(1);
t2 = t1; // ---->(2);
1. Copy constructor is called when a new object is created from an existing object, as a copy
of the existing object. Assignment operator is called when an already initialized object is
assigned a new value from another existing object. In the above example (1) calls copy
constrictor and (2) calls assignment operator. See this for
more details
Write an example class where copy constructor is needed?
Following is a complete C++ program to demonstrate use of Copy constructor. In the
following String class,
we must write copy constructor.

#include<iostream>
#include<cstring>
class String
{
private:
char *s;
int size;
public:
String(const char *str = NULL); // constructor
~String() { delete [] s; }// destructor
String(const String&); // copy constructor
void print() {cout<<s<<endl; } // Function to print string
void change(const char *); // Function to change
};
String::String(const char *str)
{
size = strlen(str);
strcpy(s, str);
}
void String::change(const char *str)
{
delete [] s;
size = strlen(str);
strcpy(s, str);}
String::String(const String& old_str)
{
size = old_str.size;
strcpy(s, old_str.s);
}
int main()
{
String str1("GeeksQuiz");
String str2 = str1;
str1.print(); // what is printed ?
str2.print();
str2.change("GeeksforGeeks");
str1.print(); // what is printed now ?
str2.print();
return 0;
}
Array vs STL Vector
std::vector is a template class that encapsulate a dynamic array 1 , stored in the heap, that
grows
and shrinks automatically if elements are added or removed. It provides all the hooks
( begin() , end() , iterators, etc) that make it work fine with the rest of the STL. It also has
several useful methods that let you perform operations that on a normal array would be
cumbersome, like e.g. inserting elements in the middle of a vector (it handles all the work of
moving the following

elements behind the scenes). Since it stores the elements in memory allocated on the heap,
it has some overhead in respect to static arrays. std::array is a template class that
encapsulate a statically-sized array, stored inside the object itself, which means that, if
you instantiate the class on the stack, the array itself will be on the stack. Its size has to
be known at compile time (it's passed as a template parameter), and it cannot grow or
shrink.
It's more limited than std::vector , but it's often more efficient, especially for
small sizes, because in practice it's mostly a lightweight wrapper around a C-style array.
However, it's more secure, since the implicit conversion to pointer is disabled, and it
provides much of the STL-related functionality of std::vector and of the other containers,
so you can use it easily with STL
algorithms & co. Anyhow, for the very limitation of fixed size it's much less flexible than
std::vector .
map vs. hash_map in C++
They are implemented in very different ways. hash_map ( unordered_map in TR1 and Boost;
use those instead) use a hash table where the key is hashed to a slot in the table and the
value is stored in a list tied to that key.map is implemented as a balanced binary search tree
(usually a red/black tree). An unordered_map should give slightly better performance for
accessing known elements of the collection, but a map will have additional useful
characteristics (e.g. it is stored in sorted order, which allows traversal from start to
finish). unordered_map will be faster on insert and delete than a map .
Default (Implicitly Declared) Member functions of a class
1. the compiler will generate a default constructor for you unless you declare any
constructor of your own.
2. the compiler will generate a copy constructor for you unless you declare your own.
3. the compiler will generate a copy assignment operator for you unless you declare your
own.
4. the compiler will generate a destructor for you unless you declare your own.
class Thing
{
public:
Thing();
// default constructor
Thing(const Thing&);
// copy c'tor
Thing& operator=(const Thing&); // copy-assign
~Thing();
// d'tor
// C++11:
Thing(Thing&&);
// move c'tor
Thing& operator=(Thing&&);
// move-assign
};
MyClass fn(); // function returning a MyClass object
MyClass foo; // default constructor
MyClass bar = foo; // copy constructor
MyClass baz = fn(); // move constructor
foo = bar;
// copy assignment
baz = MyClass();
// move assignment
Move constructor and assignment
Similar to copying, moving also uses the value of an object to set the value to another
object. But, unlike copying, the content is actually transferred from one object (the source)
to the other (the destination): the source loses that content, which is taken over by the
destination. This moving only happens when the source of the value is an unnamed object.
Unnamed objects are objects that are temporary in nature, and thus haven't even been
given a name. Typical examples of unnamed objects are return values of functions or type-
casts. Using the value of a temporary object such as these to initialize another object or to
assign its value, does not really require a copy: the object is never going to be used for
anything else, and thus, its value can be moved into the destination object. These cases
trigger the move constructor and move assignments: The move constructor is called when an
object is initialized on construction using an unnamed temporary. Likewise, themove
assignment is called when an object is assigned the value of an unnamed temporary:
// move constructor/assignment
#include <iostream>#include <string>
class Example6
{
string* ptr;
public:
Example6 (const string& str) : ptr(new string(str)) {}
~Example6 () {delete ptr;}
// move constructor
Example6 (Example6&& x) : ptr(x.ptr) {x.ptr=nullptr;}
// move assignment
Example6& operator= (Example6&& x)
{
delete ptr;
ptr = x.ptr;
x.ptr=nullptr;
return *this;
}
// access content:
const string& content() const
{
return *ptr;
}// addition:
Example6 operator+(const Example6& rhs)
{
return Example6(content()+rhs.content());
}
};
int main ()
{
Example6 foo ("Exam");
Example6 bar = Example6("ple"); // move-construction
foo = foo + bar;
// move-assignment
cout << "foo's content: " << foo.content() << '\n';
return 0;
}
Dequeue vs List
vector:
•Contiguous memory.
•Pre-allocates space for future elements, so extra space required beyond what's necessary
for the
elements themselves.
•Each element only requires the space for the element type itself (no extra pointers).
•Can re-allocate memory for the entire vector any time that you add an element.•Insertions
at the end are constant, amortized time, but insertions elsewhere are a costly O(n).
•Erasures at the end of the vector are constant time, but for the rest it's O(n).
•You can randomly access its elements.
•Iterators are invalidated if you add or remove elements to or from the vector.
•You can easily get at the underlying array if you need an array of the elements.
list:
•Non-contiguous memory.
•No pre-allocated memory. The memory overhead for the list itself is constant.
•Each element requires extra space for the node which holds the element, including pointers
to the
next and previous elements in the list.
•Never has to re-allocate memory for the whole list just because you add an element.
•Insertions and erasures are cheap no matter where in the list they occur.
•It's cheap to combine lists with splicing.
•You cannot randomly access elements, so getting at a particular element in the list can be
expensive.
•Iterators remain valid even when you add or remove elements from the list.
•If you need an array of the elements, you'll have to create a new one and add them all to it,
since
there is no underlying array.Processes vs. Programs
• A process is different than a program.
• Program: Static code and static data.
• Process: Dynamic instance of code and data.
• No one-to-one mapping between programs and processes.
• Can have multiple processes of the same program Example: many users can run “ls” at the
same time.
One program can invoke multiple processes Example: “make” runs many processes to
accomplish its work.
• A program is sometimes referred as passive entity as it resides on a secondary memory.
• A process is sometimes referred as active entity as it resides on the primary memory and
leaves the memory if the system is rebooted.
Process control block (PCB)

Process Control Block (PCB, also called Task Controlling Block,process table, Task Struct, or
Switchframe) is a data structure in the operating system kernel containing the information
needed to manage a particular process.
1. Process state (new, ready, running, waiting, finish ...)
2. CPU registers (e.g., %eip, %eax)
3. Scheduling information
4. Memory-management information
5. Accounting information
6. I/O status information
• The current state of the process i.e., whether it is ready, running, waiting, or whatever.
• Unique identification of the process in order to track "which is which" information.
• A pointer to parent process.
• Similarly, a pointer to child process (if it exists).
• The priority of process (a part of CPU scheduling information).
• Pointers to locate memory of processes.
• A register save area.
• The processor it is running on.7.
What is a zombie?
a zombie processor defunct process is a process that has completed execution (via the exit
system call) but still has an entry in the process table: it is a process in the "Terminated
state".
Zombie is a process state when the child dies before the parent process. In this case the
structural information of the process is still in the process table....... When a program forks
and the child finishes before the parent, the kernel still keeps some of its information
about the child in case the parent might need it - for example, the parent may need to
check the child's exit status. To be able to get this information, the parent calls 'wait()'; In
the interval between the child terminating and the parent calling 'wait()', the child is said to
be a 'zombie' (If you do 'ps', the child will have a 'Z' in its status field to indicate this.)
Zombie : The process is dead but have not been removed from the process table.
How to kill zombie process

A zombie is already dead, so you cannot kill it. To clean up a zombie, it must be waited on by
its
parent, so killing the parent should work to eliminate the zombie. (After the parent dies,
the zombie will be inherited by init, which will wait on it and clear its entry in the process
table.) If your daemon is spawning children that become zombies, you have a bug. Your
daemon should notice when its children die and wait on them to determine their exit status.
kill $(ps -A -ostat,ppid | awk '/[zZ]/{print $2}')

kill -HUP $(ps -A -ostat,ppid | grep -e '[zZ]'| awk '{ print $2 }')
type2:
$ ps aux | grep Z
$
ps -p 20736 -o ppid
PPID
20735
$ kill -17 20735
orphan process
An orphan process is a computer process whose parent process has finished
or terminated, though it remains running itself. In a Unix-like operating
system any orphaned process will be immediately adopted by the special init
system process. Daemon Process . In Unix and other multitasking computer
operating systems, a daemon is a computer program that runs as a
background process, rather than being under the direct control of an
interactive user. Zombies hardly take any memory. Orphans are regular
processes, they can take a lot of memory and cpu cycles.
What is the difference between Swapping and Paging?
Swapping:
Whole process is moved from the swap device to the main memory for
execution. Process size must be less than or equal to the available main
memory. It is easier to implementation and overhead to the system.

Swapping systems does not handle the memory more flexibly as compared to
the paging systems.
Paging:
Only the required memory pages are moved to main memory from the swap
device for execution. Process size does not matter. Gives the concept of the
virtual memory. It provides greater flexibility in mapping the virtual address
space into the physical memory of the machine. Allows more number of
processes to fit in the main memory simultaneously. Allows the greater
process size than the available physical memory. Demand paging systems
handle the memory more flexibly.
What is the difference between UDP and TCP?
TCP is a Transmission Control Protocol.
UDP is a User Datagram Protocol.
There are four major differences between UDP and TCP:
1. TCP can establish a Connection and UDP cannot.
2. TCP provides a stream of unlimited length, UDP sends Small packets.
3.TCP gurantees that as long as you have a connection data sent will arrive at
the destination, UDP provides not guarantee delivery.
4.UDP is faster for sending small amounts of data since no connection setup
is required, the data can be sent in less time then it takes for TCP to
establish a connection.
What is an inode?ext2 and ext3 file systems keep a list of the files they
contain in a table called an inode table. The inode is referenced
by its number. This is unique within a file system.

The inode contains the metadata about files. Among the data stored in the
inode is
File type
File permissions
Link count
User ID number of the file owner and the group ID number of the
associated group
Last modification time
Location of the data on the hard disk
Other metadata about the file
ls -li – view inode number only
stat /etc/passwd – view inode details
Section Numbers
The section numbers of the manual are listed below. While reading
documentation, if you see a
command name followed by a number in parentheses, the number refers to
one of these sections.
For example, man is the documentation of man found in section number1.
Some commands may
have documentation in more than one section, so the numbers after the
command name may direct you to the correct section to find a specific type
of information. The section numbers, and the topics they cover, are as
follows:
section # topic
1 Executable programs or shell commands

2 System calls (functions provided by the kernel)
3 Library calls (functions within program libraries)
4 Special files (usually found in /dev)
5 File formats and conventions eg /etc/passwd
6 Games
7 Miscellaneous (including macro packages and conventions), e.g. man, groff
8 System administration commands (usually only for root)
9 Kernel routines [Non standard]
Link are of two types Soft links (symbolic links ) or Hard link
1.Soft Links (symbolic links )
◦ You can make links for files & folder & you can create link (shortcut) on
different
partition & got different inode number from original.
◦ If real copy is deleted the link will not work.
2.Hard Links
◦ For files only & you cannot create on different partition ( it should be on
same partition )
& got same inode number as original
◦ If the real copy is deleted the link will work ( because it act as original file
What is a Soft Link or Symbolic Link or Symlink ?
• Soft links are very similar to what we say “Shortcut” in windows, is a way
to link to a file or directory.
• Symlinks doesn’t contain any information about the destination file or
contents of the file, instead of

that, it simply contains the pointer to the location of the destination file.
In more technical words, in soft link, a new file is created with a new inode,
which have the pointer to
the inode location of the original file. This can be better explained with a
diagram:
Symbolic links are created with the “ln” command in linux. The syntax of the
command is:
$ ln -s
-s = This flag tells to create a symlink (if you don’t use this it will create a
hard link, which we will talk aboutsoon).
$ ln -s /usr/bin/gedit ~/Desktop/gedit
What is a Hard Link ?

• Hard link is a bit different object when compared to a symlink.
• In softlink a new file and a new Inode is created, but in hard link, only an entry into
directory
structure is created for the file, but it points to the inode location of the original file.
• Which means there is no new inode creation in the hard link which shares same inode
number. This
can be explained like this:
# ln
# ln /usr/bin/gedit ~/Desktop/gedit
When to use Soft Link:
1.Link across filesystems: If you want to link files across the filesystems, you can only use
symlinks/soft
links.
2.Links to directory: If you want to link directories, then you must be using Soft links, as
you can’t create

a hard link to a directory.
When to use Hard Link:
1. Storage Space: Hard links takes very negligible amount of space, as there are no new
inodes created while creating hard links. In soft links we create a file which consumes space
(usually 4KB, depending upon the filesystem)
2. Performance: Performance will be slightly better while accessing a hard link, as you are
directly accessing the disk pointer instead of going through another file.
3. Moving file location: If you move the source file to some other location on the same file
system, the hard link will still work, but soft link will fail.
4. Redundancy: If you want to make sure safety of your data, you should be using hard link,
as in hard link, the data is safe, until all the links to the files are deleted, instead of that in
soft link, you will lose the data if the master instance of the file is deleted.
Soft Links:
•Issue the ln -s [original filename] [link name] command to create a soft link
•Similar to shortcut feature in Windows Operating system
•Original File and Hard Linked file contain different inode values
•Each soft link file points to the original file’s inode
•Any changes to either original file or soft linked file are reflected in the other file
•Benefit – soft linked file can cross different file systems
•Negative – if original file is deleted or moved, the soft link is broken (hanging link)
Hard Links:
• Issue the ln [original filename] [link name] command to create a hard link
• Original File and Hard Linked file contain the same inode value
• Creates a mirror copy of the file
• Any changes to either original file or hard linked file are reflected in the other file
• Benefit – more flexible and remain linked if either the original or hard linked file is moved
• Negative – unable to cross different file systems
Linux Commands to check Hardware information
1. lscpu
The lscpu command reports information about the cpu and processing units. It does
not have any further options or functionality.
2. lshw - List Hardware
A general purpose utility, that reports detailed and brief information about multiple
different hardware units such as cpu, memory, disk, usb controllers, network adapters etc.
Lshw extracts the information from different /proc files.
3. hwinfo - Hardware Information
Hwinfo is another general purpose hardware probing utility that can report detailed
and brief information about multiple different hardware components, and more than
what lshw can report.
4. lspci - List PCI
The lspci command lists out all the pci buses and details about the devices
connected to them. The vga adapter, graphics card, network adapter, usb ports, sata
controllers, etc all fall under this category.
5. lsscsi - List scsi devices
Lists out the scsi/sata devices like hard drives and optical drives.
6. lsusb - List usb buses and device details
This command shows the USB controllers and details about devices connected to
them. By default brief information is printed. Use the verbose option "-v" to print detailed
information about each usb port
7. Inxi
Inxi is a 10K line mega bash script that fetches hardware details from multiple
different sources and commands on the system, and generates a beautiful looking report
that non technical users can read easily.
8. lsblk - List block devices
List out information all block devices, which are the hard drive partitions and other
storage devices like optical drives and flash drives
9. df - disk space of file systems
Reports various partitions, their mount points and the used and available space on
each.
10. Pydf - Python df

An improved df version written in python, that displays colored output that looks
better than df
11. fdisk
Fdisk is a utility to modify partitions on hard drives, and can be used to list out the
partition information as well.
12. mount
The mount is used to mount/unmount and view mounted file systems.
13. free - Check RAM
Check the amount of used, free and total amount of RAM on system with the free
command.
14. dmidecode
The dmidecode command is different from all other commands. It extracts
hardware information byreading data from the SMBOIS data structures (also called DMI
tables).
15. /proc files
Many of the virtual files in the /proc directory contain information about hardware
and configurations.
Here are some of them
# cpu information
$ cat /proc/cpuinfo
# memory information
$ cat /proc/meminfo
$ cat /proc/version
Linux version 3.11.0-12-generic (buildd@allspice) (gcc version 4.8.1
(Ubuntu/Linaro 4.8.1-10ubuntu7) ) #19-Ubuntu SMP Wed Oct 9 16:20:46 UTC 2013
16. hdparm
The hdparm command gets information about sata devices like hard disks.
As a slightly more realistic program in C++: a class in its own header
(IPv4.h) and implementation (IPv4.cpp) and a program which uses the

class functionality. The class converts an IP address in integer format
to the known quad format.
https://www.linuxcounter.net/toolbox/
//IPv4 class
//IPv4.h:
#ifndef IPV4_H
#define IPV4_H
#include <string>
namespace GenericUtils
{
// create a namespace
class IPv4
{ // class definition
public:
IPv4(); ~Ipv4();
std::string IPint_to_IPquad(unsigned long ip);
// member interface
};
} //namespace GenericUtils
#endif
// IPV4_HIPv4.cpp:
#include "Ipv4.h"
#include <string>
#include <sstream>
// use the namespaces
using namespace GenericUtils;
IPv4::IPv4() {}
// default constructor/destructor
IPv4::~IPv4() {}
string IPv4::IPint_to_IPquad(unsigned long ip)
{
// member implementation
ostringstream ipstr; // use a stringstream
ipstr << ((ip &0xff000000) >> 24) // Bitwise right shift
<< "." << ((ip &0x00ff0000) >> 16)
<< "." << ((ip &0x0000ff00) >> 8)
<< "." << ((ip &0x000000ff));
return ipstr.str();
}
//simplecpp.cpp
#include "Ipv4.h"
#include <iostream>
#include <string>
int main (int argc, char* argv[])
{
string ipstr; // define variables
unsigned long ipint = 1347861486; // The IP in integer form
GenericUtils::IPv4 iputils;
// create an object of the class
ipstr = iputils.IPint_to_IPquad(ipint);
// call the class member
cout << ipint << " = " << ipstr << endl;
// print the result
return 0;
}
Compile and execute with:
# g++ -c IPv4.cpp simplecpp.cpp
# Compile in objects
# g++ IPv4.o simplecpp.o -o simplecpp.exe # Link objects to final executable# ./simplecpp.exe
1347861486 = 80.86.187.238
Simple Makefile
CC = g++
CFLAGS = -O
OBJS = IPv4.o simplecpp.o
simplecpp: ${OBJS}
${CC} -o simplecpp ${CFLAGS} ${OBJS}
clean:
rm -f ${TARGET} ${OBJS}
fork vs vfork
http://www.badprog.com/unix-gnu-linux-system-calls-difference-between-fork-
and-vfork
The fork() and vfork() syscalls are different.
The fork() syscall generates two identical processes with separate memory.
The vfork() syscall generates two processes that share the same memory.
With vfork() the parent will wait for the child terminates.
The parent inherites from the variables that the program is sharing.
So after the child was called, all variables modified inside the child will still be modified
inside the parent.
## BadproG.com
## Makefile
## Variables
NAME = forkIt
SRC = main.c
OBJ = $(SRC:.c=.o)
CFLAGS
CC
= -Wall -Werror -Wextra -pedantic -ansi -D_BSD_SOURCE
= gcc## Rules
$(NAME) : $(OBJ)
$(CC) $(OBJ) -o $(NAME)
all : $(NAME)
clean :
rm -f $(OBJ)
fclean
: clean
rm -f $(NAME)
re
r
: fclean all
: re
rm -f *~
rm -f *.o
/**
* Badprog.com
* h.h
*/
#ifndef H_H_
#define H_H_
typedef struct s_forky
{
int value;
} t_forky;
#endif /* H_H_ */
/*
* Badprog.com
* main.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "h.h"
int
main()
{
int i;
int status;
pid_t f;
t_forky forky;
forky.value = 0;
i = 0;
status = 1;
f = fork();
if (f < 0){
fprintf(stderr, "Error: %s - fork() < 0 (%d)\n", strerror(errno), f);
}
else if (f > 0)
{
printf("\n===== Begin Parent =====\n\n");
printf("fork() = %d\n", f);
printf("getpid() = %d\n", getpid());
while (i < 10)
{
printf(" Parent - forky.value = %d\n", forky.value);
++forky.value;
++i;
}
}
else
{
printf("\n===== Begin Child =====\n\n");
while (i < 10)
{
printf(" Child - forky.value = %d\n", forky.value);
++forky.value;
++i;
}
}
printf("status = %d\n", status);printf("forky.value = %d\n\n", forky.value);
printf("===== End =====\n\n");
return 0;
}
output:
===== Begin Parent =====
fork() = 18938
getpid() = 18937
Parent - forky.value = 0
status = 1
forky.value = 10
===== End =====
===== Begin Child =====fork() = 0
getpid() = 18938
Child - forky.value = 0
status = 1
forky.value = 10
===== End =====
/**
* Badprog.com
* main.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>#include <string.h>
#include <errno.h>
#include "h.h"
int
main()
{
int i;
int status;
pid_t f;
t_forky forky;
forky.value = 0;
i = 0;
status = 1;
f = vfork();
if (f < 0)
{
fprintf(stderr, "Error: %s - fork() < 0 (%d)\n", strerror(errno), f);
}
else if (f > 0)
{
printf("\n===== Begin Parent =====\n\n");
while (i < 10)
{
printf(" Parent - forky.value = %d\n", forky.value);+
+forky.value;
++i;
}
}
else
{
printf("\n===== Begin Child =====\n\n");
while (i < 10)
{
printf("Child- forky.value = %d\n", forky.value);
++forky.value;
++i;
}
_exit(status);
}
printf("status = %d\n", status);
printf("forky.value = %d\n\n", forky.value);
printf("===== End =====\n\n");
return 0;
}
compiling:
make r ; ./forkIt
output:===== Begin Child =====
fork() = 0
getpid() = 19013
===== Begin Parent =====
fork() = 19013
getpid() = 19012
status = 1
forky.value = 10
===== End =====
Fork(): create a completely new process
Clone(): creates a new thread within a processint clone(int (*fn)(void *), void *child_stack,
int flags, void *arg, ... /* pid_t *pid, struct
user_desc *tls ", pid_t *" ctid " */ );"
Unlike fork(2), these calls allow the child process to share parts of its execution context
with the calling process, such as the memory space, the table of file descriptors, and the
table of signal handlers. (Note that on this manual page, "calling process" normally
corresponds to "parent process". But see the description of CLONE_PARENT below.) The
main use of clone() is to implement threads: multiple threads of control in a program that
run concurrently in a shared memory space. When the child process is created with clone(),
it executes the function application fn(arg). (This differs from fork(), where execution
continues in the child from the point of the fork() call.) The fn argument is a pointer to a
function that is called by the child process at the beginning of its execution. The arg
argument is passed to the fn function.

TCP/IP stack
The most common protocol on the internet is the Transmission Control Protocol/Internet
Protocol (TCP/IP). To send data over a TCP/IP network requires four steps or layers:
Layer
Name
Description
Application Encodes the data being sent
Transport Splits the data into manageable chunks, adds port number information Internet
Adds IP addresses stating where the data is from and where it is going Link Adds MAC
address information to specify which hardware device the message came from, and which
hardware device the message is going to Successive encapsulation (wrapping) of application
data descending through the protocol stack before transmission on the local network linko
show you how the TCP/IP stack works we going to use the following data as an example:
Application[edit]
The application layer makes sure that the data is sent in a format that will be
understandable by the recipient. This will mean formatting data to be sent in a standard
way applicable to that application, for
example HTTP, FTP etc. In this case we are going to wrap each piece of data in XML tags.
Transport[edit]
The transport layer looks at the data to be sent and splits it into chunks that can fit into
data packets. It then attaches a number to each, specifying that packet's order, this allows
the recipient to place the data back together correctly at the other end. To each packet it
then attaches a port number dependent on the application being used. For the example we'll
send data to port 60 Splits the data into chunks and adds order number
Adds port numbers
Transport Header
Data
:60 | 1/4 <gospel>Matt</gospel>
:60 | 2/4 <gospel>Mark</gospel>
:60 | 3/4 <gospel>Luke</gospel>

:60 | 4/4 <gospel>John</gospel>
Network/Internet[edit]
The network layer attaches the IP address of the sender, so that the recipient will know
who sent it and who to send a confirmation message to. It must also attach the IP address
of the host that it is sending the data to so it doesn't get lost! In this case we are sending
to 102.231.4.189 and sending from 98.1.232.99. Combined with the port number this creates
asocket that data is being sent from and a socket that data is being sent to, namely
102.231.4.189:60 •Attaches sender IP address
•Attaches destination IP address to create a socket
Network Header
Transport Header
Data
102.231.4.189
98.1.232.99 :60 | 1/4 <gospel>Matt</gospel>
102.231.4.189
98.1.232.99 :60 | 2/4 <gospel>Mark</gospel>
102.231.4.189
98.1.232.99 :60 | 3/4 <gospel>Luke</gospel>
102.231.4.189
98.1.232.99 :60 | 4/4 <gospel>John</gospel>
Link[edit]
Finally the link layer attaches the MAC address of the sender and the recipient, allowing
the packets to be
directed to a specific network interface on the IP Address host machine. In this case the
sender is using a
wireless card with MAC address: 00-17-4F-08-5D-69 and the destination
MAC address is: 11-22-33-44-55
•Attaches sender MAC address
•Attaches destination MAC address

Link Header
Network Header
Transport Header
Data11-22-33-44-55
102.231.4.189
00-17-4F-08-5D-69 98.1.232.99 :60 | 1/4 <gospel>Matt</gospel>
11-22-33-44-55
102.231.4.189
00-17-4F-08-5D-69 98.1.232.99 :60 | 2/4 <gospel>Mark</gospel>
11-22-33-44-55
102.231.4.189
00-17-4F-08-5D-69 98.1.232.99 :60 | 3/4 <gospel>Luke</gospel>
11-22-33-44-55
102.231.4.189
00-17-4F-08-5D-69 98.1.232.99 :60 | 4/4 <gospel>John</gospel>
These four packets can then be sent across the internet holding enough
information for them to:
1.reach their destination (socket from the Network and Transport Layers)
2.find the correct network interface (MAC address from the Link Layer)
3.find the correct service(Port number from the Transport Layer)
4.be reassembled in the correct order (Order information from the
Transport Layer)
5.deliver the intended message (data from the Application Layer)
Combined, the IP address and Port Number make up a what?
Answer :
Socket
What is the MAC Address for in the TCP/IP stack?
A MAC address is a unique identifier assigned to a network device. It is used
by the Link layer to direct messages to a
particular network interface at the designated IP address
Show the steps involved in sending the following data:
• data = Hello (this will fit in one packet)
• from IP = 12.32.72.2 | MAC = 43.65.FF.23
• to IP = 98.125.43.88 | Port = 80 | MAC = A0.3D.EF.00
• Answer :
Application
"Hello"
Transport
:80
1/1
"Hello"
Internet
To=98.125.43.88
From=12.32.72.2
:80
1/1
"Hello"
Link
From MAC = 43.65.FF.23
To MAC = A0.3D.EF.00
To=98.125.43.88
From=12.32.72.2
:80
1/1
"Hello"Convert an IP address to a human-readable string in C

#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
// ...
char buffer[INET6_ADDRSTRLEN];
int err=getnameinfo((struct sockaddr*)&addr,addr_len,buffer,sizeof(buffer),
0,0,NI_NUMERICHOST);
if (err!=0)
{
die("failed to convert address to string (code=%d)",err);
}
printf("Remote address: %s\n",buffer);
Hash Table
Note:
http://proprogramming.org/program-to-implement-hash-tables-c/
http://pumpkinprogrammer.com/2014/06/21/c-tutorial-intro-to-hash-
tables/
#include<iostream>#include<cstdlib>
#include<string>
#include<cstdio>
const int TABLE_SIZE = 128;
/*
* HashEntry Class Declaration
*/
class HashEntry
{
public:
int key;
int value;
HashEntry(int key, int value)
{
this->key = key;
this->value = value;
}
};
/*
* HashMap Class Declaration
*/
class HashMap
{
private:
HashEntry **table;
public:
HashMap()
{
table = new HashEntry * [TABLE_SIZE];
for (int i = 0; i< TABLE_SIZE; i++)
{
table[i] = NULL;
}
}
/*
* Hash Function
*/
int HashFunc(int key)
{
return key % TABLE_SIZE;
}
/*
* Insert Element at a key
*/
void Insert(int key, int value)
{
int hash = HashFunc(key);
while (table[hash] != NULL && table[hash]->key != key)
{hash = HashFunc(hash + 1);
}
if (table[hash] != NULL)
delete table[hash];
table[hash] = new HashEntry(key, value);
/*
* Search Element at a key
*/
int Search(int key)
{
hash = HashFunc(hash + 1);
if (table[hash] == NULL)
return -1;
else
return table[hash]->value;
/*
* Remove Element at a key
*/
void Remove(int key)
while (table[hash] != NULL)
if (table[hash]->key == key)
break;
cout<<"No Element found at key "<<key<<endl;
return;
else
{
delete table[hash];
cout<<"Element Deleted"<<endl;
~HashMap()
for (int i = 0; i < TABLE_SIZE; i++)
if (table[i] != NULL)
delete table[i];
delete[] table;}
};
/*
* Main Contains Menu
*/
int main()
HashMap hash;
int key, value;
int choice;
hash.Insert(1, 10);
hash.Insert(2, 20);
hash.Insert(3, 30);
hash.Insert(4, 40);
if (hash.Search(2) == -1)
{
cout<<"No element found at key "<<key<<endl;
//continue;
/*
while (1)
cout<<"n----------------------"<<endl;
cout<<"Operations on Hash Table"<<endl;
cout<<"n----------------------"<<endl;
cout<<"1.Insert element into the table"<<endl;
cout<<"2.Search element from the key"<<endl;
cout<<"3.Delete element at a key"<<endl;
cout<<"4.Exit"<<endl;
cout<<"Enter your choice: ";
cin>>choice;
switch(choice)
case 1:
cout<<"Enter element to be inserted: ";
cin>>value;
cout<<"Enter key at which element to be inserted: ";
cin>>key;
hash.Insert(key, value);
break;
case 2:
cout<<"Enter key of the element to be searched: ";
cin>>key;
if (hash.Search(key) == -1)
continue;
}else
cout<<"Element at key "<<key<<" : ";
cout<<hash.Search(key)<<endl;
break;
case 3:
cout<<"Enter key of the element to be deleted: ";
cin>>key;
hash.Remove(key);
break;
case 4:
exit(1);
default:
cout<<"nEnter correct optionn";
*/
return 0;
}
2.
#include<iostream>
#include<cstdlib>
#include<string>
#include<cstdio>
const int TABLE_SIZE = 128;
/*
* HashEntry Class Declaration
*/
class HashEntry
public:
int key;
int value;
HashEntry(int key, int value)
this->key = key;
this->value = value;
};
/*
* HashMap Class Declaration
*/
class HashMap
{
private:HashEntry **table;
public:
HashMap()
table = new HashEntry * [TABLE_SIZE];
for (int i = 0; i< TABLE_SIZE; i++)
table[i] = NULL;
~HashMap()
for (int i = 0; i < TABLE_SIZE; i++)
if (table[i] != NULL)
delete table[i];
delete[] table;
int HashFunc(int key);
void Insert(int key, int value);
int Search(int key);
void Remove(int key);
};
/*
* Hash Function
*/
int HashMap::HashFunc(int key)
return key % TABLE_SIZE;
/*
* * Insert Element at a key
*/
void HashMap::Insert(int key, int value)
if (table[hash] != NULL)
delete table[hash];
table[hash] = new HashEntry(key, value);
/*
* * Search Element at a key*/
int HashMap::Search(int key)
{
}
return -1;
else
return table[hash]->value;
}
/*
* Remove Element at a key
*/
void HashMap::Remove(int key)
{
while (table[hash] != NULL)
{
if (table[hash]->key == key)
break;
}
{
cout<<"No Element found at key "<<key<<endl;
return;
}
else
{
delete table[hash];
}
cout<<"Element Deleted"<<endl;
}
/*
* Main Contains Menu
*/
int main()
{
HashMap hash;
int key, value;
int choice;
hash.Insert(1, 10);
hash.Insert(2, 20);
hash.Insert(3, 30);hash.Insert(4, 40);
if (hash.Search(2) == -1)
{
//continue;
}
/*
while (1)
{
cout<<"n----------------------"<<endl;
cout<<"Operations on Hash Table"<<endl;
cout<<"n----------------------"<<endl;
cout<<"1.Insert element into the table"<<endl;
cout<<"2.Search element from the key"<<endl;
cout<<"3.Delete element at a key"<<endl;
cout<<"4.Exit"<<endl;
cout<<"Enter your choice: ";
cin>>choice;
switch(choice)
{
case 1:
cout<<"Enter element to be inserted: ";
cin>>value;
cout<<"Enter key at which element to be inserted: ";
cin>>key;
hash.Insert(key, value);
break;
case 2:
cout<<"Enter key of the element to be searched: ";
cin>>key;
if (hash.Search(key) == -1)
{
continue;
}
else
{
cout<<"Element at key "<<key<<" : ";
cout<<hash.Search(key)<<endl;
}
break;
case 3:
cout<<"Enter key of the element to be deleted: ";
cin>>key;
hash.Remove(key);
break;
case 4:
exit(1);
default:
cout<<"nEnter correct optionn";
}}
*/
return 0;
}
Note:
1. Destructor cant be overloaded but constructor can be overloaded.
2. Yes, as C is the subset of C++, we can all the functions of C in C++ too.
2. Can I use ‘delete’ operator to release the memory which was allocated using malloc()
function of C language?
No, we need to use free() of C language for the same.

//Are there any special rules about inlining?
Yes, there are a few rules about inlining :
1. Any source files that used the inline function must contain the function’s definition.
2. An inline function must be defined everywhere. The easier way to deal with this to define
the function once in the class header file and include the definition as required. The harder
way is to redefine the function everywhere and learn the one-definition rule.
3. Main() can not be inline.
//Explain container class.
-Class to hold objects in memory or external storage. It acts as a generic holder.
- It has a predefined behaviour and a known interface.
- It is used to hide the topology used for maintaining the list of objects in memory.
- The container class can be of two types:
1. Heterogeneous container : Here the container class contains a group of mixed objects
2. Homogeneous container : Here the container contains all the same objects.
//Differentiate between late binding and early binding. What are the advantages of early
binding?
- Late binding refers to function calls that are not resolved until run time while early
binding refers to the events that occur at compile time.
- Late binding occurs through virtual functions while early binding takes place when all the
information needed to call a function is known at the time of compiling.
- Early binding increases the efficiency. Some of the examples of early binding are normal
function calls, overloaded function calls, and overloaded operators etc.
//When do you call copy constructors?
Copy constructors are called in these situations :
1. When compiler generates a temporary object.
2. When a function returns an object of that class by value .
3. When the object of that class is passed by value as an argument to a function .
4. When you construct an object based on another object of the same class.
//Name the implicit member functions of a class.
1. default constructor
2. copy constructor
3. assignment operator
4. default destructor
5. address operator
//Explain Stack unwinding.
Stack unwinding is a process during exception handling when the destructor is called for all
local objects between the place where the exception was thrown and where it is caught.
//How does code-bloating occur in C++?
- Improper use of Inline functions and templates may lead to code bloating.
- Multiple Inheritance may also lead to code bloating.

- Inline functions and templates, if not used properly, may lead to code bloating.
- Multiple Inheritance may also lead to code bloating (this is because the sub classes will
end up getting members from all the base classes even if only few members will suffice).
//Explain following storage classes in C++.
a. Auto :
- This is the default storage class.
- Variables in this class are automatically created and initialized when they are defined.
- These variable are then destroyed at the end of the block containing their definition.
They are not visible outside that block.
b. Register :
- This is a type of auto variable.
- It gives a suggestion to the compiler to use a CPU register for performance.
c. Static :
- A variable that is known only in the function that contains its definition.
- It is never destroyed and retains its value between calls to that function.
d. Extern :
- This is a static variable.
- Its definition and placement is determined when all object and library modules are
combined (linked) to form the executable code file.
- It can be visible outside the file where it is defined.

//What happens when you make call “delete this;”?
The two pit-falls exist here,
1. If it executes in a member function for an extern, static, or automatic object, the

program will probably crash as soon as the delete statement gets executed.
2. When an object finishes like this, the using program might not know about this end. As
far as the instantiating program is concerned, the object remains in scope and continues to
exist even though the object is finished. Subsequent dereferencing of the pointer can lead
to disaster.
//Explain deep copy and a shallow copy.
a. Deep copy :
It involves using the contents of one object to create another instance of the same class.
Here, the two objects may contain the same information but the target object will have its
own buffers and resources. The destruction of either object will not affect the remaining
objects.
b. Shallow copy :
It involves copying the contents of one object into another instance of the same class. This
creates a mirror image. The two objects share the same externally contained contents of
the other object to be unpredictable.This happens because of the straight copying of
references and pointers.
//What are the four partitions in which C++ compiler divides the RAM?
1. Stack Area :
This part of memory is used to store formal parameters, local variables, return addresses
of function call etc.
2. Program Code Area :
This part of memory is used to store the object code of the program.
3. Global Variable Section :
This part of memory is used to store global variables defined in the program.
4. Heap Area or Free Storage Pool :
It consists of unallocated memory locations which are allocated dynamically during program
execution using new operator.
//What are the various situations where a copy constructor is invoked?
Various situations where a copy constructor is invoked are as follows :
- When an object is defined and initializes with the values of another object of the same
type, then copy constructor is invoked.
- When an object is passed by value method, then copy constructor is invoked to create the
copy of the passed object for the function.
- When a function returns an object, then copy constructor is invoked to create a

temporary object to hold the return value in the memory.
//vtable
//smart pointer
//object slicing
//zombie objects
//set new handler
//typecasting
1. static_cast
2. dynamic_cast
3. const_cast
4. reinterpret_cast
//this pointer
//reference pointer
//What is the difference between a deep copy and a shallow copy?
Deep copy involves using the contents of one object to create another instance of the same
class. In a deep copy, the two objects may contain ht same information but the target
object will have its own buffers and resources. the destruction of either object will not
affect the remaining object. The overloaded assignment operator would create a deep copy
of objects.
Shallow copy involves copying the contents of one object into another instance of the same
class thus creating a mirror image. Owing to straight copying of references and pointers,
the two objects will share the same externally contained contents of the other object to be
unpredictable.
Using a copy constructor we simply copy the data values member by member. This method
of copying is called shallow copy. If the object is a simple class, comprised of built in types
and no pointers this would be acceptable. This function would use the values and the objects
and its behavior would not be altered with a shallow copy, only the addresses of pointers
that are members are copied and not the value the address is pointing to. The data values of
the object would then be inadvertently altered by the function. When the function goes out
of scope, the copy of the object with all its data is popped off the stack. If the object has
any pointers a deep copy needs to be executed. With the deep copy of an object, memory is
allocated for the object in free store and the elements pointed to are copied. A deep copy
is used for objects that are returned from a function.
// Vector vs Lists
Lists:
Each item contains an address to the next or previous element, so with this feature, you can
randomize the items, even if they aren't sorted, the order won't change: it's efficient if
you memory is fragmented. But it also has an other very big advantage: you can easily
insert/remove items, because the only thing you need to do is change some pointers.
Drawback: To read a random single item, you have to jump from one item to another until
you find the correct address.
Vectors:
When using vectors, the memory is much more organized like regular arrays: each n-th
items is stored just after (n-1)th item and before (n+1)th item. Why is it better than list ?
Because it allow fast random access. Here is how: if you know the size of an item in a vector,
and if they are contiguous in memory, you can easily predict where the n-th item is; you
don't have to browse all the item of a list to read the one you want, with vector, you
directly read it, with a list you can't. On the other hand, modify the vector array or change
a value is much more slow.
Lists are more appropriate to keep track of objects which can be added/removed in
memory. Vectors are more appropriate when you want to access an element from a big
quantity of single items.
I don't know how lists are optimized, but you have to know that if you want fast read
access, you should use vectors, because how good the STL fasten lists, it won't be as fast in
read-access than vector.
vector:
- Contiguous memory.
- Pre-allocates space for future elements, so extra space required beyond what's
necessary for the elements themselves.
- Each element only requires the space for the element type itself (no extra pointers).
- Can re-allocate memory for the entire vector any time that you add an element.
- Insertions at the end are constant, amortized time, but insertions elsewhere are a
costly O(n).
- Erasures at the end of the vector are constant time, but for the rest it's O(n).
- You can randomly access its elements.
- Iterators are invalidated if you add or remove elements to or from the vector.
- You can easily get at the underlying array if you need an array of the elements.
list:
- Non-contiguous memory.
- No pre-allocated memory. The memory overhead for the list itself is constant.
- Each element requires extra space for the node which holds the element, including
pointers to the next and previous elements in the list.
- Never has to re-allocate memory for the whole list just because you add an element.
- Insertions and erasures are cheap no matter where in the list they occur.
- It's cheap to combine lists with splicing.
- You cannot randomly access elements, so getting at a particular element in the list can
be expensive.
- Iterators remain valid even when you add or remove elements from the list.
- If you need an array of the elements, you'll have to create a new one and add them all
to it, since there is no underlying array.
// Why virtual constructor not possible?
Virtual functions are used in order to invoke functions based on the type of object pointed
to by the pointer, and not the type of pointer itself. But a constructor is not "invoked". It is
called only once when an object is declared. So, a constructor cannot be madevirtual in C++.
//Singleton pattern Applicability & Examples
According to the definition the singleton pattern should be used when there must be
exactly one instance of a class, and when it must be accessible to clients from a global
access point. Here are some real situations where the singleton is used:
Example 1 - Logger Classes
The Singleton pattern is used in the design of logger classes. This classes are ussualy
implemented as a singletons, and provides a global logging access point in all the application
components without being necessary to create an object each time a logging operations is
performed.
Example 2 - Configuration Classes
The Singleton pattern is used to design the classes which provides the configuration
settings for an application. By implementing configuration classes as Singleton not only that
we provide a global access point, but we also keep the instance we use as a cache object.
When the class is instantiated( or when a value is read ) the singleton will keep the values in
its internal structure. If the values are read from the database or from files this avoids
the reloading the values each time the configuration parameters are used.
Example 3 - Accesing resources in shared mode
It can be used in the design of an application that needs to work with the serial port. Let's
say that there are many classes in the application, working in an multi-threading
environment, which needs to operate actions on the serial port. In this case a singleton with
synchronized methods could be used to be used to manage all the operations on the serial
port.
Example 4 - Factories implemented as Singletons
Let's assume that we design an application with a factory to generate new objects(Acount,
Customer, Site, Address objects) with their ids, in an multithreading environment. If the
factory is instantiated twice in 2 different threads then is possible to have 2 overlapping
ids for 2 different objects. If we implement the Factory as a singleton we avoid this
problem. Combining Abstract Factory or Factory Method and Singleton design patterns is a
common practice.

CPP

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CPP

Uploaded by

Copyright:

Available Formats

C++ Topics

1. C++ Basic Concepts.

1.3 Reference Variable.

3.1 Member Functions.

3.2 Data Members.

3.4 Friend Class.

3.5 Default Member functions of a class

4. Constructors & Destructors.

4.1 Copy constructors

6.1 Compile time

6.1.1 Function overloading

6.1.2 Function overriding

6.1.3 Operator overloading

6.2 Run time

6.2.1 Virtual functions

6.2.2 Virtual Base Class

6.2.3 Virtual Destructors

11.2 Hash Table

11.3 Object Slicing

11.4 Array vs STL Vector

11.5 Singleton class

11.6 Zombie objects

11.7 this Pointer

11. 9 'asm' Keyword

11.10 extern “C”

Delete: delete() = destructor() + free()

3.1 Types of Member Functions.

3.1.1 Nested Member Functions

3.1.2 Overloaded member functions

3.1.3 Member functions with Default arguments

3.1.4 Constant member functions

3.1.5 In-line member functions

3.1.6 Static member functions

3.2 Types of Data Members.

3.2.1 Constant Data member

3.2.2 Mutable Data member

3.2.3 Static data member

3.4 Friend Class.

4. Constructors & Destructor's

using namespace std;

int getLength( void );

Line( int len ); // simple constructor

Line( const Line &obj); // copy constructor

Line& operator=( const Line &obj)

cout << "Copy Assignment allocating ptr." << endl;

ptr = new int;

*ptr = *obj.ptr; // copy the value

// Member functions definitions including constructor

cout << "Normal constructor allocating ptr" << endl;

// allocate memory for the pointer;

ptr = new int;

Line::Line(const Line &obj)

cout << "Copy constructor allocating ptr." << endl;

ptr = new int;

*ptr = *obj.ptr; // copy the value

// Line::Line& operator=(const Line &obj)

// cout << "Copy constructor allocating ptr." << endl;

// ptr = new int;

cout << "Freeing memory!" << endl;

int Line::getLength( void )

void display(Line obj)

cout << "Length of line : " << obj.getLength() <<endl;

ptr = obj.ptr; // copy the value

ptr = obj.ptr; // copy the value