#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    //在基类中提供个用来判断类型的虚函数
    //并且所有的派生类中都必须实现这个函数
    virtual string type()
    {
        return "Base";  //手动返回一个用于识别的标识符
    }    
};

class Derived : public Base
{
public:
    string type()
    {
        return "Derived";
    } 

    void print()
    {
        cout << "I‘m a Derived." << endl;
    }
};

class Child : public Base
{
public:
    string type()
    {
        return "Child";
    }
};

void test(Base* b)
{
    //危险的转换方式。因为b可能实际类型可能不是Derived的类型
    //Derived* d = static_cast<Derived*>(b);
    
    if(b->type() == "Derived")
    {
        Derived* d = static_cast<Derived*>(b);
        d->print();
    }
    //如果类中没有虚函数表，则调用dynamic_cast会直接报错，编译不过。
    //当父、子类没有继承关系时，dynamic_cast返回false，否则会转换后
    //实际对象的地址
    cout <<  dynamic_cast<Derived*>(b) << endl;
}

int main()
{
    Base b;
    Derived d;
    Child c;
    
    test(&b); //Base与Base没有继承关系，dynamic_cast返回false
    test(&d);  //Derived与Base有继承关系，dynamic_cast转换后对象的地址
    test(&c);  //Child与Derived没有继承关系，返回false
    
    return 0;
}
/*输出结果：
0
I‘m a Derived.
0x23feb8
0
*/

#include <iostream>
#include <string>
#include <typeinfo> //for typeid

using namespace std;

class Base
{
public:
    virtual ~Base(){}
};

class Derived : public Base
{
public:
    void print()
    {
        cout << "I‘m a Derived." << endl;
    }
};

void test(Base* b)
{    
    //const type_info& tb = typeid(b); //判断b的类型,Base*或Derived*
    const type_info& tb = typeid(*b);  //判断对象的类型
    
    cout << tb.name() << endl;
}

int main()
{
    int i = 0;
    
    const type_info& tiv = typeid(i);    //判断变量的类型
    const type_info& tii = typeid(int);  //判断类的类型
    
    cout << (tiv == tii) << endl;  //相等
    
    Base b;
    Derived d;
    
    test(&b);
    test(&d);//无虚函数表数打印的类型名一样（因为Test参数为Base，即静态类型为Base），有虚函数表时则不一样
    
    return 0;
}
/*输出结果：
1
4Base       //g++下类名前面的数字表示类名的长度
7Derived
*/