listing 1

// A simple example that uses typeid.

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

class myclass {
// ...
};

int main()
{
int i, j;
float f;
myclass ob;

cout << "The type of i is: " << typeid(i).name();

cout << endl;
cout << "The type of f is: " << typeid(f).name();
cout << endl;
cout << "The type of ob is: " << typeid(ob).name();
cout << "\n\n";

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";

return 0;
}

listing 2
// An example that uses typeid on a polymorphic class heirarchy.
#include <iostream>
#include <typeinfo>
using namespace std;

class Base {
virtual void f() {}; // make Base polymorphic
// ...
};

class Derived1: public Base {

// ...
};

class Derived2: public Base {

// ...
};

int main()
{
Base *p, baseob;
Derived1 ob1;
Derived2 ob2;

p = &baseob;
 cout << "p is pointing to an object of type ";
cout << typeid(*p).name() << endl;

p = &ob1;
cout << "p is pointing to an object of type ";
cout << typeid(*p).name() << endl;

p = &ob2;
cout << "p is pointing to an object of type ";
cout << typeid(*p).name() << endl;

return 0;
}

listing 3
// Use a reference with typeid.
#include <iostream>
#include <typeinfo>
using namespace std;

class Base {
virtual void f() {}; // make Base polymorphic
// ...
};

class Derived1: public Base {

// ...
};

class Derived2: public Base {

// ...
};

// Demonstrate typeid with a reference parameter.

void WhatType(Base &ob)
{
cout << "ob is referencing an object of type ";
cout << typeid(ob).name() << endl;
}

int main()
{
int i;
Base baseob;
Derived1 ob1;
Derived2 ob2;

WhatType(baseob);
WhatType(ob1);
WhatType(ob2);

return 0;
}

listing 4
cout << typeid(int).name();

listing 5
// Demonstrating run-time type id.
#include <iostream>
using namespace std;

class figure {
protected:
double x, y;
public:
figure(double i, double j) {
x = i;
y = j;
}
virtual double area() = 0;
} ;

class triangle : public figure {

public:
triangle(double i, double j) : figure(i, j) {}
double area() {
return x * 0.5 * y;
}
};

class rectangle : public figure {

public:
rectangle(double i, double j) : figure(i, j) {}
double area() {
return x * y;
}
};

class circle : public figure {

public:
circle(double i, double j=0) : figure(i, j) {}
double area() {
return 3.14 * x * x;
}
} ;

// A factory for objects derived from figure.

figure *factory()
{
switch(rand() % 3 ) {
case 0: return new circle(10.0);
case 1: return new triangle(10.1, 5.3);
case 2: return new rectangle(4.3, 5.7);
}
return 0;
}

int main()
{
figure *p; // pointer to base class
int i;

int t=0, r=0, c=0;

// generate and count objects

for(i=0; i<10; i++) {
 p = factory(); // generate an object

cout << "Object is " << typeid(*p).name();

cout << ". ";

// count it
if(typeid(*p) == typeid(triangle)) t++;
if(typeid(*p) == typeid(rectangle)) r++;
if(typeid(*p) == typeid(circle)) c++;

// display its area

cout << "Area is " << p->area() << endl;
}

cout << endl;

cout << "Objects generated:\n";
cout << " Triangles: " << t << endl;
cout << " Rectangles: " << r << endl;
cout << " Circles: " << c << endl;

return 0;
}

listing 6
// Using typeid with templates.
#include <iostream>
using namespace std;

template <class T> class myclass {

T a;
public:
myclass(T i) { a = i; }
// ...
};

int main()
{
myclass<int> o1(10), o2(9);
myclass<double> o3(7.2);

cout << "Type of o1 is ";

cout << typeid(o1).name() << endl;

cout << "Type of o2 is ";

cout << typeid(o2).name() << endl;

cout << "Type of o3 is ";

cout << typeid(o3).name() << endl;

cout << endl;

if(typeid(o1) == typeid(o2))
cout << "o1 and o2 are the same type\n";

if(typeid(o1) == typeid(o3))
cout << "Error\n";
else
cout << "o1 and o3 are different types\n";
 return 0;
}

listing 7
// Template version of the figure heirarchy.
#include <iostream>
using namespace std;

template <class T> class figure {

protected:
T x, y;
public:
figure(T i, T j) {
x = i;
y = j;
}
virtual T area() = 0;
} ;

template <class T> class triangle : public figure<T> {

public:
triangle(T i, T j) : figure<T>(i, j) {}
T area() {
return x * 0.5 * y;
}
};

template <class T> class rectangle : public figure<T> {

public:
rectangle(T i, T j) : figure<T>(i, j) {}
T area() {
return x * y;
}
};

template <class T> class circle : public figure<T> {

public:
circle(T i, T j=0) : figure<T>(i, j) {}
T area() {
return 3.14 * x * x;
}
} ;

// A factory for objects derived from figure.

figure<double> *generator()
{
switch(rand() % 3 ) {
case 0: return new circle<double>(10.0);
case 1: return new triangle<double>(10.1, 5.3);
case 2: return new rectangle<double>(4.3, 5.7);
}
return 0;
}

int main()
{
figure<double> *p;
int i;
int t=0, c=0, r=0;
 // generate and count objects
for(i=0; i<10; i++) {
p = generator();

cout << "Object is " << typeid(*p).name();

cout << ". ";

// count it
if(typeid(*p) == typeid(triangle<double>)) t++;
if(typeid(*p) == typeid(rectangle<double>)) r++;
if(typeid(*p) == typeid(circle<double>)) c++;

cout << "Area is " << p->area() << endl;

}

cout << endl;

cout << "Objects generated:\n";
cout << " Triangles: " << t << endl;
cout << " Rectangles: " << r << endl;
cout << " Circles: " << c << endl;

return 0;
}

listing 8
Base *bp, b_ob;
Derived *dp, d_ob;

bp = &d_ob; // base pointer points to Derived object

dp = dynamic_cast<Derived *> (bp); // cast to derived pointer OK
if(dp) cout << "Cast OK";

listing 9
bp = &b_ob; // base pointer points to Base object
dp = dynamic_cast<Derived *> (bp); // error
if(!dp) cout << "Cast Fails";

listing 10
// Demonstrate dynamic_cast.
#include <iostream>
using namespace std;

class Base {
public:
virtual void f() { cout << "Inside Base\n"; }
// ...
};

class Derived : public Base {

public:
void f() { cout << "Inside Derived\n"; }
};

int main()
{
Base *bp, b_ob;
Derived *dp, d_ob;
dp = dynamic_cast<Derived *> (&d_ob);
if(dp) {
cout << "Cast from Derived * to Derived * OK.\n";
dp->f();
} else
cout << "Error\n";

cout << endl;

bp = dynamic_cast<Base *> (&d_ob);

if(bp) {
cout << "Cast from Derived * to Base * OK.\n";
bp->f();
} else
cout << "Error\n";

cout << endl;

bp = dynamic_cast<Base *> (&b_ob);

if(bp) {
cout << "Cast from Base * to Base * OK.\n";
bp->f();
} else
cout << "Error\n";

cout << endl;

dp = dynamic_cast<Derived *> (&b_ob);

if(dp)
cout << "Error\n";
else
cout << "Cast from Base * to Derived * not OK.\n";

cout << endl;

bp = &d_ob; // bp points to Derived object

dp = dynamic_cast<Derived *> (bp);
if(dp) {
cout << "Casting bp to a Derived * OK\n" <<
"because bp is really pointing\n" <<
"to a Derived object.\n";
dp->f();
} else
cout << "Error\n";

cout << endl;

bp = &b_ob; // bp points to Base object

dp = dynamic_cast<Derived *> (bp);
if(dp)
cout << "Error";
else {
cout << "Now casting bp to a Derived *\n" <<
"is not OK because bp is really \n" <<
"pointing to a Base object.\n";
}

cout << endl;

 dp = &d_ob; // dp points to Derived object
bp = dynamic_cast<Base *> (dp);
if(bp) {
cout << "Casting dp to a Base * is OK.\n";
bp->f();
} else
cout << "Error\n";

return 0;
}

listing 11
Base *bp;
Derived *dp;
// ...
if(typeid(*bp) == typeid(Derived)) dp = (Derived *) bp;

listing 12
dp = dynamic_cast<Derived *> (bp);

listing 13
// Use dynamic_cast to replace typeid.
#include <iostream>
#include <typeinfo>
using namespace std;

class Base {
public:
virtual void f() {}
};

class Derived : public Base {

public:
void derivedOnly() {
cout << "Is a Derived Object\n";
}
};

int main()
{
Base *bp, b_ob;
Derived *dp, d_ob;

// ************************************
// use typeid
// ************************************
bp = &b_ob;
if(typeid(*bp) == typeid(Derived)) {
dp = (Derived *) bp;
dp->derivedOnly();
}
else
cout << "Cast from Base to Derived failed.\n";

bp = &d_ob;
if(typeid(*bp) == typeid(Derived)) {
dp = (Derived *) bp;
dp->derivedOnly();
 }
else
cout << "Error, cast should work!\n";

// ************************************
// use dynamic_cast
// ************************************
bp = &b_ob;
dp = dynamic_cast<Derived *> (bp);
if(dp) dp->derivedOnly();
else
cout << "Cast from Base to Derived failed.\n";

bp = &d_ob;
dp = dynamic_cast<Derived *> (bp);
if(dp) dp->derivedOnly();
else
cout << "Error, cast should work!\n";

return 0;
}

listing 14
// Demonstrate const_cast.
#include <iostream>
using namespace std;

void f(const int *p)

{
int *v;

// cast away const-ness.

v = const_cast<int *> (p);

*v = 100; // now, modify object through v

}

int main()
{
int x = 99;

cout << "x before call: " << x << endl;

f(&x);
cout << "x after call: " << x << endl;

return 0;
}

listing 15
// Use static_cast.
#include <iostream>
using namespace std;

int main()
{
int i;
float f;

f = 199.22F;
 i = static_cast<int> (f);

cout << i;

return 0;
}

listing 16
// An example that uses reinterpret_cast.
#include <iostream>
using namespace std;

int main()
{
int i;
char *p = "This is a string";

i = reinterpret_cast<int> (p); // cast pointer to integer

cout << i;

return 0;
}