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

class Shape { public: virtual ~Shape() {}; };
class Circle : public Shape {};
class Square : public Shape {};
class Other {};

int main() {
  Circle c;
  Shape* s = &c; // Upcast: normal and OK
  // More explicit but unnecessary:
  s = static_cast<Shape*>(&c);
  // (Since upcasting is such a safe and common
  // operation, the cast becomes cluttering)
  Circle* cp = 0;
  Square* sp = 0;
  // Static Navigation of class hierarchies
  // requires extra type information:
  if(typeid(s) == typeid(cp)) // C++ RTTI
    cp = static_cast<Circle*>(s);
  if(typeid(s) == typeid(sp))
    sp = static_cast<Square*>(s);
  if(cp != 0)
    cout << "It's a circle!" << endl;
  if(sp != 0)
    cout << "It's a square!" << endl;
  // Static navigation is ONLY an efficiency hack;
  // dynamic_cast is always safer. However:
  // Other* op = static_cast<Other*>(s);
  // Conveniently gives an error message, while
  Other* op2 = (Other*)s;
  // does not

I copy pasted the code from a book's source,yet I see nothing writen in the console! Why is that?

s is of type Shape*. cp is of type Circle*. sp is of type Square*. Hence the type ids are different and you get no output.

Verify this by trying

Circle* cp = 0; ... if(typeid(Circle*) == typeid(cp)) cout << "okay!";

You can use typeid(*s) if you want to know the type it points to.

Also, you can use your debugger to step into the typeinfo::operator==(...) and see for yourself what it is doing.

Note:

This will only work if you dereference the pointers to the objects. Only then will typeid work with the dynamic type of objects, instead of just giving you Circle* and Shape* back. – Seth Carnegie

http://stackoverflow.com/questions/12588264/static-cast-and-rtti-vs-dynamic-cast

Try this instead: http://ideone.com/dDRNFY

See how this works in the example here: http://en.cppreference.com/w/cpp/types/type_info/operator_cmp

Also used C++11's nullptr pointer literal:

http://en.cppreference.com/w/cpp/language/nullptr

#include <iostream>
#include <typeinfo>

class Shape { public: virtual ~Shape() {}; };
class Circle : public Shape {};
class Square : public Shape {};
class Other {};

int main() {
  Circle c;
  Shape* s = &c; // Upcast: normal and OK
  // More explicit but unnecessary:
  s = static_cast<Shape*>(&c);
  // (Since upcasting is such a safe and common
  // operation, the cast becomes cluttering)
  Circle* cp = nullptr;
  Square* sp = nullptr;
  // Static Navigation of class hierarchies
  // requires extra type information:
  // C++ RTTI
  if (typeid(*s) == typeid(Circle))
    cp = static_cast<Circle*>(s);
  if (typeid(*s) == typeid(Square))
    sp = static_cast<Square*>(s);
  std::cout << "cp = " << cp << std::endl;
  std::cout << "sp = " << sp << std::endl;
  if (cp) std::cout << "It's a circle!" << std::endl;
  if (sp) std::cout << "It's a square!" << std::endl;
  // Static navigation is ONLY an efficiency hack;
  // dynamic_cast is always safer. However:
  // Other* op = static_cast<Other*>(s);
  // Conveniently gives an error message, while
  // that would be undefined behavior (UB)!
  // Other* op2 = (Other*)s;
  // does not
  // AND *nothing* is guaranteed if we uncomment the UB
  // INCLUDING *anything* about the lines *before* the UB (yes, really!)
}

BTW, I think the example may be somewhat simpler without all this pointer cruft (dynamic polymorphism works perfectly fine with references) and unnecessary access specifiers (let's use structs, this will give us public-by-default for free): http://ideone.com/sxNT7o

#include <iostream>
#include <typeinfo>

struct Shape { virtual ~Shape() {}; };
struct Circle : Shape {};
struct Square : Shape {};
struct Other {};

int main() {
  Circle c;
  Shape & s = c; // Upcast: normal and OK
  // More explicit but unnecessary:
  s = static_cast<Shape&>(c);
  std::cout << "Address of `s` = " << &s << std::endl;
  
  // (Since upcasting is such a safe and common
  // operation, the cast becomes cluttering)

  // Static Navigation of class hierarchies
  // requires extra type information:
  // C++ RTTI
  if (typeid(s) == typeid(Circle))
  {
    Circle & cp = static_cast<Circle&>(s);
    std::cout << "It's a circle!" << std::endl;
    std::cout << "Address = " << &cp << std::endl;
  }
  if (typeid(s) == typeid(Square))
  {
    Square & sp = static_cast<Square&>(s);
    std::cout << "It's a square!" << std::endl;
    std::cout << "Address = " << &sp << std::endl;
  }
  // Static navigation is ONLY an efficiency hack;
  // dynamic_cast is always safer. However:
  // Other & op = static_cast<Other&>(s);
  // Conveniently gives an error message, while
  // that would be undefined behavior (UB)!
  // Other& op2 = (Other&)s;
  // does not
  // AND *nothing* is guaranteed if we uncomment the UB
  // INCLUDING *anything* about the lines *before* the UB (yes, really!)
}