关于c++:编程语言C-四种强制类型转换

9次阅读

共计 4501 个字符，预计需要花费 12 分钟才能阅读完成。

1、常量指针被转化成十分量的指针，并且依然指向原来的对象；
2、常量援用被转换成十分量的援用，并且依然指向原来的对象；
3、const_cast 个别用于批改指针。如 const char * p 模式。

#include<iostream>

int main() {
    // 原始数组
    int ary[4] = {1,2,3,4};

    // 打印数据
    for (int i = 0; i < 4; i++)
        std::cout << ary[i] << "\t";
    std::cout << std::endl;

    // 常量化数组指针
    const int*c_ptr = ary;
    //c_ptr[1] = 233;   //error

    // 通过 const_cast<Ty> 去常量
    int *ptr = const_cast<int*>(c_ptr);

    // 批改数据
    for (int i = 0; i < 4; i++)
        ptr[i] += 1;    //pass

    // 打印批改后的数据
    for (int i = 0; i < 4; i++)
        std::cout << ary[i] << "\t";
    std::cout << std::endl;

    return 0;
}

out print：

1   2   3   4
2   3   4   5

留神: 对于在定义为常量的参数, 应用 const_cast 可能会有不同的成果. 相似代码如下

#include<iostream>
int main() {
    const int c_val = 233;  // 申明为常量类型
    int &use_val = const_cast<int&>(c_val); // 应用去 const 援用
    int *ptr_val = const_cast<int*>(&c_val);// 应用去 const 指针

    use_val = 666;  // 未定义行为
    std::cout << c_val << "\t" << use_val << "\t" << *ptr_val << std::endl;
    *ptr_val = 110; // 未定义行为
    std::cout << c_val << "\t" << use_val << "\t" << *ptr_val << std::endl;
    return 0;
}

在 vs2017 下输入为：

233 666 666
233 110 110

未定义行为:C++ 规范对此类行为没有做出明确规定. 同一份代码在应用不同的编译器会有不同的成果. 在 vs2017 下, 尽管代码中 c_val , use_val , ptr_val 看到的地址是一样的. 然而 c_val 的值并没有扭转. 有可能在某种编译器实现后, 这一份代码的 c_val 会被扭转. 也有可能编译器对这类行为间接 error 或 warning.

static_cast 作用和 C 语言格调强制转换的成果根本一样，因为没有运行时类型查看来保障转换的安全性，所以这类型的强制转换和 C 语言格调的强制转换都有安全隐患。
用于类层次结构中基类（父类）和派生类（子类）之间指针或援用的转换。留神：进行上行转换（把派生类的指针或援用转换成基类示意）是平安的；进行上行转换（把基类指针或援用转换成派生类示意）时，因为没有动静类型查看，所以是不平安的。
用于根本数据类型之间的转换，如把 int 转换成 char，把 int 转换成 enum。这种转换的安全性须要开发者来保护。
static_cast 不能转换掉原有类型的 const、volatile、或者 __unaligned 属性。(前两种能够应用 const_cast 来去除)
在 c ++ primer 中说道：c++ 的任何的隐式转换都是应用 static_cast 来实现。

/* 惯例的应用办法 */
float f_pi=3.141592f
int   i_pi=static_cast<int>(f_pi); /// i_pi 的值为 3

/* class 的上下行转换 */
class Base{// something};
class Sub:public Base{// something}

//  上行 Sub -> Base
// 编译通过，平安
Sub sub;
Base *base_ptr = static_cast<Base*>(&sub);  

//  上行 Base -> Sub
// 编译通过，不平安
Base base;
Sub *sub_ptr = static_cast<Sub*>(&base);

dynamic_cast 强制转换, 应该是这四种中最非凡的一个, 因为他波及到面向对象的多态性和程序运行时的状态, 也与编译器的属性设置无关. 所以不能齐全应用 C 语言的强制转换代替, 它也是最常有用的, 最不可短少的一种强制转换.

#include<iostream>
using namespace std;

class Base{
public:
    Base() {}
    ~Base() {}
    void print() {std::cout << "I'm Base" << endl;}
    virtual void i_am_virtual_foo() {}
};

class Sub: public Base{
public:
    Sub() {}
    ~Sub() {}
    void print() {std::cout << "I'm Sub" << endl;}
    virtual void i_am_virtual_foo() {}
};
int main() {
    cout << "Sub->Base" << endl;
    Sub * sub = new Sub();
    sub->print();
    Base* sub2base = dynamic_cast<Base*>(sub);
    if (sub2base != nullptr) {sub2base->print();
    }
    cout << "<sub->base> sub2base val is:" << sub2base << endl;


    cout << endl << "Base->Sub" << endl;
    Base *base = new Base();
    base->print();
    Sub  *base2sub = dynamic_cast<Sub*>(base);
    if (base2sub != nullptr) {base2sub->print();
    }
    cout <<"<base->sub> base2sub val is:"<< base2sub << endl;

    delete sub;
    delete base;
    return 0;
}

vs2017 输入为：

Sub->Base
I'm Sub
I'm Base
<sub->base> sub2base val is: 00B9E080   // 注: 这个地址是零碎调配的, 每次不肯定一样

Base->Sub
I'm Base
<base->sub> base2sub val is: 00000000   // VS2017 的 C ++ 编译器, 对此类谬误的转换赋值为 nullptr

从上边的代码和输入后果能够看出:
对于从子类到基类的指针转换 ,dynamic_cast 胜利转换, 没有什么运行异样, 且达到预期后果
而从基类到子类的转换 , dynamic_cast 在转换时也没有报错, 然而输入给 base2sub 是一个 nullptr , 阐明 dynami_cast 在程序运行时对类型转换对“运行期类型信息”（Runtime type information，RTTI）进行了查看.
这个查看次要来自虚函数 (virtual function) 在 C ++ 的面对对象思维中，虚函数起到了很要害的作用，当一个类中领有至多一个虚函数，那么编译器就会构建出一个虚函数表(virtual method table) 来批示这些函数的地址，如果继承该类的子类定义并实现了一个同名并具备同样函数签名（function siguature）的办法重写了基类中的办法，那么虚函数表会将该函数指向新的地址。此时多态性就体现进去了：当咱们将基类的指针或援用指向子类的对象的时候，调用办法时，就会顺着虚函数表找到对应子类的办法而非基类的办法。因而留神下代码中 Base 和 Sub 都有申明定义的一个虚函数”i_am_virtual_foo”, 我这份代码的 Base 和 Sub 应用 dynami_cast 转换时查看的运行期类型信息, 能够说就是这个虚函数

reinterpret_cast 是强制类型转换符用来解决无关类型转换的，通常为操作数的位模式提供较低层次的从新解释！然而他仅仅是从新解释了给出的对象的比特模型，并没有进行二进制的转换！
他是用在任意的指针之间的转换，援用之间的转换，指针和足够大的 int 型之间的转换，整数到指针的转换，在在面的文章中将给出.
请看一个简略代码

#include<iostream>
#include<cstdint>
using namespace std;
int main() {int *ptr = new int(233);
    uint32_t ptr_addr = reinterpret_cast<uint32_t>(ptr);
    cout << "ptr 的地址:" << hex << ptr << endl
        << "ptr_addr 的值(hex):" << hex << ptr_addr << endl;
    delete ptr;
    return 0;
}
/*
ptr 的地址: 0061E6D8
ptr_addr 的值(hex): 0061e6d8
*/

上述代码将指针 ptr 的地址的值转换成了 unsigned int 类型的 ptr_addr 的整数值.
提供下 IBM C++ 对 reinterpret_cast 举荐应用的中央
A pointer to any integral type large enough to hold it（指针转向足够大的整数类型）
A value of integral or enumeration type to a pointer（从整形或者 enum 枚举类型转换为指针）
A pointer to a function to a pointer to a function of a different type（从指向函数的指针转向另一个不同类型的指向函数的指针）
A pointer to an object to a pointer to an object of a different type（从一个指向对象的指针转向另一个不同类型的指向对象的指针）
A pointer to a member to a pointer to a member of a different class or type, if the types of the members are both function types or object types（从一个指向成员的指针转向另一个指向类成员的指针！或者是类型，如果类型的成员和函数都是函数类型或者对象类型）

上面这个例子来自 MSDN 的一个哈希函数辅助

// expre_reinterpret_cast_Operator.cpp  
// compile with: /EHsc  
#include <iostream>  

// Returns a hash code based on an address  
unsigned short Hash(void *p) {unsigned int val = reinterpret_cast<unsigned int>(p);
    return (unsigned short)(val ^ (val >> 16));
}
using namespace std;
int main() {int a[20];
    for (int i = 0; i < 20; i++)
        cout << Hash(a + i) << endl;
}

正文完