RTTI and Namespaces.pptx ppt of c++ programming language

typeid
• It is used to obtain an object's type. You must include the header <typeinfo>
in order to use typeid.
• Its typeid returns a reference to an object of type type_info that describes the
type of object.
• The type_info class defines the following public members:
bool operator = = (const type_info &ob);
bool operator !=(const type_info &ob);
bool before(const type_info &ob);
const char *name();
• The overloaded = = and != provide for the comparison of types.
• The before() function returns true if the invoking object is before the object
used as a parameter in collation order. (This function is mostly for internal
use only. Its return value has nothing to do with inheritance or class
hierarchies) .
• The name() function returns a pointer to the name of the type

Example: Using typeid
#include <iostream>
#include <typeinfo>
using namespace std;
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 typeof f is: " << typeid(f).name() << endl;
cout << "The type of p is: " << typeid(p).name() << endl;
cout << "The type of ob1 is: " << typeid(ob1).name() << endl;
cout << "The type of ob2 is: " << typeid(ob2).name() << "n";
if(typeid(i) == typeid(j))
cout << "The types of i and j are the samen";
if(typeid(i) != typeid(f))
cout << "The types of i and f are not the samen";
if(typeid(ob1) != typeid(ob2))
cout << "ob1 and ob2 are of differing typesn";
return 0;
}
Output:
The type of i is: i
The typeof f is: f
The type of p is: Pc
The type of ob1 is: 8myclass1
The type of ob2 is: 8myclass2
The types of i and j are the same
The types of i and f are not the same
ob1 and ob2 are of differing types

Using typeid, one can determine at run time the type of the object that is being pointed
to by a base-class pointer. The following program demonstrates this principle.
#include <iostream>
#include <typeinfo>
class Mammal
{
public:
virtual bool lays_eggs()
{ return false; }
};
class Cat: public Mammal
{
public:
};
class Platypus: public Mammal
{
public:
bool lays_eggs()
{ return true; }
};

Cont.
int main()
{
Mammal *p, mammal;
Cat cat;
Platypus platypus;
p = &mammal;
cout << "p is pointing to an object of type ";
cout << typeid(*p).name() << endl;
p = &cat;
p = &platypus;
return 0;
}
Output:
p is pointing to an object of type 6Mammal
p is pointing to an object of type 3Cat
p is pointing to an object of type 8Platypus

Use a reference with typeid
#include <iostream>
#include <typeinfo>
class Mammal
{
public:
virtual bool lays_eggs() { return false; } // Mammal is polymorphic
};
{
public:
};
{
public:
bool lays_eggs() { return true; }
};

Cont.
// Demonstrate typeid with a reference parameter.
void WhatMammal(Mammal &ob)
{
cout << "ob is referencing an object of type ";
cout << typeid(ob).name() << endl;
}
int main()
{
Mammal AnyMammal;
Cat cat;
Platypus platypus;
WhatMammal(AnyMammal);
WhatMammal(cat);
WhatMammal(platypus);
return 0;
}
Output:
b is referencing an object of type 6Mammal
ob is referencing an object of type 3Cat
ob is referencing an object of type 8Platypus

Example: Demonstrating run-time type id.
#include <iostream>
class Mammal
{
public:
virtual bool lays_eggs() // Mammal is polymorphic
{
return false;
}
};
{
public:
};
{
public:
bool lays_eggs()
{
return true;
}
};

Cont.
class Dog: public Mammal
{
public:
};
// A factory for objects derived from Mammal.
Mammal *factory()
{
switch(rand() % 3 )
{
case 0:
return (new Dog);
case 1:
return (new Cat);
case 2:
return (new Platypus);
}
return 0;
}

Cont.
int main()
{
Mammal *ptr; // pointer to base class
int c=0, d=0, p=0;
// Generate and count objects
for(int i=0; i<10; i++)
{
ptr = factory(); // Generate an object
cout << "Object is " <<
typeid(*ptr).name();
cout << endl;
// count it
if(typeid(*ptr) == typeid(Dog)) d++;
if(typeid(*ptr) == typeid(Cat)) c++;
if(typeid(*ptr) == typeid(Platypus)) p+
+;
}
cout << endl;
cout << "Animals generated:n";
cout << " Dogs: " << d << endl;
cout << " Cats: " << c << endl;
cout << " Platypuses: " << p << endl;
return 0;
Output:
Object is 3Cat
Object is 3Cat
Object is 3Dog
Object is 3Cat
Object is 8Platypus
Object is 3Cat
Object is 3Cat
Object is 3Dog
Object is 3Dog
Object is 3Cat
Animals generated:
Dogs: 3
Cats: 6
Platypuses: 1

typeid and Template Classes
#include <iostream>
template <class T>
class myclass
{
private:
T a;
public:
myclass(T i)
{
a = i;
}
};

Cont.
int main()
{
myclass<int> o1(10), o2(9);
myclass<double> o3(7.2);
cout << "nType of o1 is ";
cout << typeid(o1).name() << endl;
if(typeid(o1) == typeid(o2))
cout << "no1 and o2 are the same type
n";
if(typeid(o1) == typeid(o3))
cout << "nErrorn";
else
cout << "no1 and o3 are different types
n";
return 0;
}
Output:
Type of o1 is 7myclassIiE
Type of o2 is 7myclassIiE
Type of o3 is 7myclassIdE
o1 and o2 are the same type
o1 and o3 are different types

Example:
#include <iostream>
#include <typeinfo>
class Shape
{
public:
virtual void enterData() = 0;
virtual void displayData() = 0;
};
class Rectangle : public Shape
{
int length, breadth;
public:
void enterData()
{
cout << "n Enter the length: ";
cin >> length;
cout << "n Enter the breadth: ";
cin >> breadth;
}
void displayData()
{
cout << "n Area = " << (length*breadth);
}
};

Cont.
int main()
{
Shape *p = nullptr;
Rectangle r ;
p = &r; // Upcasting
p->enterData();
p->displayData();
Rectangle *rec_ptr = nullptr;
rec_ptr = (Rectangle *)p; // Downcasting
rec_ptr->enterData();
rec_ptr->displayData();
return 0;
}

Cont.
• Note that down casting requires explicit casts, such as
(Rectangle *) p
• The code given above may compile and run without any problem.
• However, this is not a very good idea to cast a base class pointer to a derived type in
this manner.
• Derived classes are an extension of the base class and usually contain more
information than the base class. This can result in an unexpected loss of information
during casting.
• Therefore, we must ensure that no such loss of information occurs or necessary error
flag is raised if the casting cannot be done in a proper manner.
• This is where we need the mechanism of dynamic cast.

• We can use dynamic_cast for safe down casting of a base class pointer or a reference to
a subclass in an inheritance hierarchy.
• On successful casting, it returns a pointer of the converted type and, if we try to cast a
invalid type such as a object pointer which is not of the type of the desired subclass, it
fails but does it without creating a major problem.
• The syntax of dynamic_cast with pointer and reference respectively are:
<type> *ptr_derived = dynamic_cast<<type> *>(ptr_obj);
<type> ref_derived = dynamic_cast<<type> &> (ref_obj);
• Because it is not possible to return nullptr as an indication of an error when casting a
reference, dynamic_cast throws an exception as defined in the typeinfo header called
std::bad_cast.
• Therefore, it is a good programming practice to wrap dynamic cast operations within a
try/catch block.
Using dynamic_cast

Example: Using dynamic_cast
int main()
{
Shape *s = nullptr;
Rectangle r ;
s = &r;
s->enterData();
s->displayData();
Rectangle *r_ptr = nullptr;
// r_ptr = (Rectangle *)p;
try
{
r_ptr = dynamic_cast <Rectangle *> (s);
}
catch (std::bad_cast &bc)
{
cerr<<bc.what() << endl;
}
r_ptr->enterData();
r_ptr->displayData();
return 0;
}

namespace
• The namespace keyword allows you to partition the
global namespace by creating a declarative region.
• In essence, a namespace defines a scope.
• The general form of namespace is:
namespace name
{
// declarations
}
• Anything defined within a namespace statement is
within the scope of that namespace.

Example: namespace
#include <iostream>
namespace first_space // first name space
{
void func()
{
cout << "Inside first_space" << endl;
}
}
namespace second_space // second name space
{
void func()
{
cout << "Inside second_space" << endl;
}
}
using namespace first_space;
int main ()
{
func(); // This calls function from first name space.
return 0;
}
Output:
Inside first_space

Nested Namespaces
#include <iostream>
namespace first_space // first name space
{
void func()
{
cout << "Inside first_space" << endl;
}
namespace second_space // second name space
{
void func()
{
cout << "Inside second_space" << endl;
}
}
}
using namespace first_space :: second_space;
int main ()
{
func(); // This calls function from second name space.
return 0;
}
Output:
Inside second_space

Example: Another way of accessing (without using keyword)
#include <iostream>
namespace first_space
{
void func()
{ cout << "Inside first_space" << endl; }
}
namespace second_space
{
void func()
{ cout << "Inside second_space" << endl; }
}
int main ()
{
first_space :: func();
second_space :: func();
return 0;
}
Inside first_space
Inside second_space

Example: Identifying local and globar variables
#include <iostream>
namespace first // Variable created inside namespace
{
int val = 500;
}
int val = 100; // Global variable
int main()
{
int val = 200; // Local variable
cout <<"first :: val = " << first :: val ;
cout << "nval = " << val;
cout << first :: val ;
return 0;
}
Output:
first :: val = 500
val = 200

Example: Defining a class inside a namespace
#include <iostream>
#include <typeinfo>
namespace ns
{
class Sample
{
public:
void display()
{
cout<<"Inside ns::Sample::display()"<< endl;
}
}; // End of the class
} // End of the namespace
int main()
{
ns::Sample s;
s.display();
return 0;
}

Example: Declaring a class inside a namespace and defining it outside the
namespace.
#include <iostream>
namespace ns
{
class Sample; // Declaring class inside the namespace
}
class ns :: Sample // Defining class outside the namespace
{
public:
void display()
{
cout << “n Inside function display() ";
}
};
int main()
{
ns::Sample s ;
s.display();
return 0;
}

Example: Declaring two methods (one member function and other non-member
function) with same signatures inside a namespace
#include <iostream>
namespace ns
{
void display();
class Sample
{
public:
void display();
};
}
// Defining methods of namespace
void ns :: Sample :: display()
{
cout << "n Inside display() function of Sample class";
}
void ns :: display()
{
cout << “n Inside non-member function display()";
}
int main()
{
ns::Sample s;
ns::display();
s.display();
return 0;
}

Nesting of namespaces (with two examples)
#include <iostream>
namespace ns1
{
namespace ns2
{
namespace ns3
{
int var = 10;
}
using namespace ns3;
} // namespace ns2
using namespace ns2;
} // namespace ns1
int main()
{
cout << ns1 :: var;
return 0;
}
Output:
10
#include <iostream>
namespace ns1
{
namespace ns2
{
namespace ns3
{
int var = 10;
}
}
}
using namespace ns1 :: ns2 :: ns3;
int main()
{
cout << var;
return 0;
}
Output:
10

Inline namespace
#include <iostream>
namespace ns1
{
inline namespace ns2
{
inline namespace ns3
{
int var = 10;
}
}
}
int main()
{
cout << ns1::var << endl;
cout << ns1 :: ns2 :: var << endl;
cout << ns1 :: ns2 :: ns3 :: var << endl;
return 0;
}
Output:
10
10
10

Namespace Aliasing
#include <iostream>
namespace ns1
{
namespace ns2
{
namespace ns3
{
int var = 42;
}
}
}
namespace ns = ns1 :: ns2 :: ns3; // Aliasing
int main()
{
std::cout << ns :: var ;
}

Example: Illustrating the use of namespace
namespace CounterNameSpace
{
int upperbound, lowerbound;
class Counter
{
int count;
public:
Counter(int n)
{
if(n <= upperbound) count = n;
else count = upperbound;
}
void reset(int n)
{
if(n <= upperbound) count = n;
}
int run()
{
if(count > lowerbound) return count--;
else return lowerbound;
}
}; // End of the class
} // End of the namespace

Cont.
int main()
{
CounterNameSpace::upperbound = 100;
CounterNameSpace::lowerbound = 0;
CounterNameSpace::Counter ob1(10);
int i;
do
{
i = ob1.run();
cout << i << " ";
} while(i > CounterNameSpace::lowerbound);
CounterNameSpace::Counter ob2(20);
do
{
i = ob2.run();
cout << i << " ";
cout << endl;
ob2.reset(100);
Notice that the declaration of a counter object
and the references to upperbound and
lowerbound are qualified by
CounterNameSpace. However, once an object
of type counter has been declared, it is not
necessary to further qualify it or any of its
members. Thus, ob1.run( ) can be called
directly; the namespace has already been
resolved.
CounterNameSpace::lowerbound = 90;
do
{
i = ob2.run();
cout << i << " ";
return 0;
}
0 9 8 7 6 5 4 3 2 1 0 20 19 18 17 16 15 14 13 12
11 10 9 8 7 6 5 4 3 2 1 0 100 99 98 97 96 95 94
93 92 91 90

RTTI and Namespaces.pptx ppt of c++ programming language

Recommended

More Related Content

Similar to RTTI and Namespaces.pptx ppt of c++ programming language (20)

Recently uploaded (20)

RTTI and Namespaces.pptx ppt of c++ programming language