C++迭代器和显示类型转换方式

double d = 9.3;
    double *pd = &d;
    int *pi = reinterpret_cast<int* >(pd);  //相当于隐式转换int *pi = (int*)pd;
    class A{};
    class B{};
    A *pa = new A;
    B *pb = reinterpret_cast<B* >(pa);        //相当于隐式转换B* pb = (B* )pa;
    long j = reinterpret_cast<long>(pi);      //相当于long j = (long)pi;

    const int* pci =0;
    int *pj = const_cast<int *>(pci);    //相当于int* pj = (int*)pci;
    const A* pca = new A;
    A* pa = const_cast<A*>(pca);    //相当于A* pa = (A*)pca;

    int* pi = 0;
    const int* pcj = const_cast<const int* >(pi);//将普通指针转换为常量指针
    int i=0;
    const int cj = const_cast<const int>(i);//非指针转换为const指针，不能通过编译！
    const int ck = (const int)i;//隐式转换，可通过编译

    int i = 0;
    double d = static_cast<double>(i);//将i的int型转换为double型然后赋值给d;
    int j = static_cast<int>(j); //将double型转换为int 型然后赋值给j;
    class Base{};
    class Derived:Base{};
    Derived d;
    Base b = static_cast<Base>(d);//将子类对象d转换为父类然后赋值给b;

#include <QCoreApplication>
#include <iostream>
#include<stdio.h>
#include<typeinfo.h>
using namespace std;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    class Base{};
    class Derived:public Base{};
    //子类指针pd转化为父类指针pb
    Derived* pd = new Derived;
    Base* pb = dynamic_cast<Base* >(pd);
    if(!pb)
    {
        cout << "类型转换失败" << endl;
    }
    else
    {
        cout << "类型转换成功" << endl;
    }
    //子类引用转化为父类引用
    Derived d;
    Base& b = dynamic_cast<Base& >(d);
    //没有继承关系，但被转化的类有虚函数
    class A{
        virtual ~A(){}
    };
    class B{};
    A* pa = new A;
    B* pc = dynamic_cast<B* >(pa);//有虚函数的对象指针，可以转化
    if(!pc)
    {
        cout << "类型转换成功" << endl;
    }
    else
    {
        cout << "类型转换失败" << endl;
    }
    return a.exec();
}