开发者

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

目录
  • 1.迭代javascript
  • 2.显式类型转换
    • 2.1 reinterpret_cast
    • 2.2const_cast
    • 2.3 static_cast
    • 2.4 dynamic_cast 
  • 总结

    1.迭代器

    其实迭代器很简单,没有我们想象中的那么复杂。

    以前要读写数据结构中的数据,一般是通过移动指针来进行的,但是在编写指针的过程中难免会出现野指针等情况出现,而且指针用起来也相对复杂。

    这时候,神奇的迭代器出现了。

    迭代器是指针的一个泛化,在容器和算法之间充当桥梁的作用。

    区别于指针,迭代器本身重载的“++”和“–”操作符,能够直接指向前驱和后继节点。

    2.显式类型转换

    将一种类型转换成另一种类型,在程序中很常见,转换后的类型变量,它的内部存储方式一般也随之改变。

    C++提供了四种显式的类型转换操作函数reinterpret_cast、const_cast、static_cast和dynamic_cast。

    前三个类型的转换是在编译的时候进行类型转换,最后一个则是在运行的时候进行类型转换,并可返回转换成功与否的标志。

    2.1 reinterpret_cast

    **reinterpret_cast类型转换函数将一个类型的指针转换为另一个类型的指针。

    **这种转换不用修改指针变量值数据存放格式(不改变指针变量的值),也不能把const指针转换成void*指针,只需在编译时重新解释指针的类型就行。

    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;
    

    2.2const_cast

    const_cast用于去除指针变量的常量属性,将它转换为一个对应指针类型的普通变量,反过来也成立。

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

    const_cast只是针对于指针操作,无法将非指针的常变量转换为普通变量。

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

    2.3 static_cast

    static_cast一般用于基本类型之间和具有继承关系之间的类型转换,这种转换一般会更改变量的内部表示方式。

    一般不用于指针类型转换。

        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;
    

    2.4 dynamic_cast 

    与上面三个不同,dynamic_cast是在运行的时候进行转换分析的,上面三个是在编译时进行。

    dynamic_cast只能在继承类对象的指针之间或引用之间进行类型转换。

    进行转换时,会根据当前运行对象的运行时类型信息,判断类型对象之间是否转换合法。

    dynamic_cast的指针转换失败,可通过是否为null指针检测;引用转换失败则抛出一个bad_cast异常。

    #include <QCoreApplication>
    #include <IOStream>
    #include<stdio.h>
    #include<typeinfo.h>
    us编程ing 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();
    }
    

    运行结果:

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

    dynamic_cast不只是应用于类型转换,**通常利用它做运行时对象类型检查的特性,在程序中检测当前内存对象的类型信息,**以决定下一步操作,使程序更灵活机动。

    总结

    以上为个人经验,希望能给大家一个参考,也希望大家多多支持编程客栈(www.devze.com)。

    0

    上一篇:

    下一篇:

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    最新开发

    开发排行榜