C++之点点滴滴

发表于 2019-09-22 更新于 2023-08-22 分类于编程开发， Qt

记录C++语法的点点滴滴

1.新式类型转换

函数	功能
`static_cast`	用于兼容类型转换，如整型和浮点型、字符型之间的互相转换。
`const_cast`	仅用于进行去除 const 属性的转换
`reinterpret_cast`	用于进行各种不同类型的指针之间、不同类型的引用之间以及指针和能容纳指针的整数类型之间的转换
`dynamic_cast`	专门用于将多态基类的指针或引用强制转换为派生类的指针或引用，而且能够检查转换的安全性。对于不安全的指针转换，转换结果返回 NULL 指针

xxxxxx_cast<T2>T1:

语法：xxxxxx_cast<类型2>(类型1变量)
功能：将指针变量由类型1转换为类型2

// 以下都是合法的转换
static_cast<const uchar *>(p)         // p 类型为 uchar*
static_cast<size_t>(p)                // p 类型为 int
const_cast<uchar *>(p)                // p 类型为 const uchar*
reinterpret_cast<const uchar *>(p);   // p 类型为 uchar*

1.1 `static_cast`示例：

#include <iostream>
using namespace std;
class A
{
public:
    operator int() { return 1; }
    operator char*() { return NULL; }
};
int main()
{
    A a;
    int n;
    char* p = "New Dragon Inn";
    n = static_cast <int> (3.14);  // n 的值变为 3
    n = static_cast <int> (a);     //调用 a.operator int，n 的值变为 1
    p = static_cast <char*> (a);   //调用 a.operator char*，p 的值变为 NULL
    n = static_cast <int> (p);     //编译错误，static_cast不能将指针转换成整型
    p = static_cast <char*> (n);   //编译错误，static_cast 不能将整型转换成指针
    return 0;
}

1.2 `reinterpret_cast`示例：

#include <iostream>
using namespace std;
class A
{
public:
    int i;
    int j;
    A(int n):i(n),j(n) { }
};
int main()
{
    A a(100);
    int &r = reinterpret_cast<int&>(a);	    //强行让 r 引用 a
    r = 200;                                //把 a.i 变成了 200
    cout << a.i << "," << a.j << endl;      // 输出 200,100
    int n = 300;
    A *pa = reinterpret_cast<A*> ( & n);    //强行让 pa 指向 n
    pa->i = 400;                            // n 变成 400
    pa->j = 500;                            //此条语句不安全，很可能导致程序崩溃
    cout << n << endl;                      // 输出 400
    long long la = 0x12345678abcdLL;
    pa = reinterpret_cast<A*>(la);          //la太长，只取低32位0x5678abcd拷贝给pa
    unsigned int u = reinterpret_cast<unsigned int>(pa);        //pa逐个比特拷贝到u
    cout << hex << u << endl;               //输出 5678abcd
    typedef void (* PF1) (int);
    typedef int (* PF2) (int,char *);
    PF1 pf1;  PF2 pf2;
    pf2 = reinterpret_cast<PF2>(pf1);       //两个不同类型的函数指针之间可以互相转换
}

// output 

// 200, 100
// 400
// 5678abed

1.3 `const_cast`示例

1.4 `dynamic_cast`示例

reinterpret_cast 可以将多态基类（包含虚函数的基类）的指针强制转换为派生类的指针，但是这种转换不检查安全性，即不检查转换后的指针是否确实指向一个派生类对象。dynamic_cast专门用于将多态基类的指针或引用强制转换为派生类的指针或引用，而且能够检查转换的安全性。

如果类型转换成功，则 dynamic_cast 返回 新类型 的值。若转换失败且新类型是指针类型，则它返回该类型的空指针。若转型失败且新类型是引用类型，则它抛出与类型 std::bad_cast 的处理块匹配的异常。。

#include <iostream>
 
struct V {
    virtual void f() {};  // 必须为多态以使用运行时检查的 dynamic_cast
};
struct A : virtual V {};
struct B : virtual V {
  B(V* v, A* a) {
    // 构造中转型（见后述 D 的构造函数中的调用）
    dynamic_cast<B*>(v); // 良好定义：v 有类型 V*，B 的 V 基类，产生 B*
    dynamic_cast<B*>(a); // 未定义行为：a 有类型 A*，A 非 B 的基类
  }
};
struct D : A, B {
    D() : B((A*)this, this) { }
};
 
struct Base {
    virtual ~Base() {}
};
 
struct Derived: Base {
    virtual void name() {}
};
 
int main()
{
    D d; // 最终派生对象
    A& a = d; // 向上转型，可以用 dynamic_cast，但不必须
    D& new_d = dynamic_cast<D&>(a); // 向下转型
    B& new_b = dynamic_cast<B&>(a); // 侧向转型
 
 
    Base* b1 = new Base;
    if(Derived* d = dynamic_cast<Derived*>(b1))
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // 可以安全调用
    }
 
    Base* b2 = new Derived;
    if(Derived* d = dynamic_cast<Derived*>(b2))
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // 可以安全调用
    }
 
    delete b1;
    delete b2;
}

#include <iostream>
#include <string>
using namespace std;
class Base
{  //有虚函数，因此是多态基类
public:
    virtual ~Base() {}
};
class Derived : public Base { };
int main()
{
    Base b;
    Derived d;
    Derived* pd;
    pd = reinterpret_cast <Derived*> (&b);
    if (pd == NULL)
        //此处pd不会为 NULL。reinterpret_cast不检查安全性，总是进行转换
        cout << "unsafe reinterpret_cast" << endl;	//不会执行
    pd = dynamic_cast <Derived*> (&b);
    if (pd == NULL)					//结果会是NULL，因为 &b 不指向派生类对象，此转换不安全
        cout << "unsafe dynamic_cast1" << endl;		//会执行
    pd = dynamic_cast <Derived*> (&d);			//安全的转换
    if (pd == NULL)					//此处 pd 不会为 NULL
        cout << "unsafe dynamic_cast2" << endl;		//不会执行
    return 0;
}

0%