C++引用和强制类型转换问题小结

#include <iostream>
#include<string>
using namespace std;
int main()
{
    int a = 20;
    int& b = a; b是a的引用（别名）
    cout << "a=" << a << ",b=" << b << endl;
    cout << "a的地址" << &a << ",b的地址" << &b << endl;
    b = 20;
    cout << "a=" << a << ",b=" << b << endl;
    return 0;
}

void swap(int &x, int &y) 
{ int temp = x; x = y; y = temp; } 调用时直接传递变量，而非指针 int a = 10, b = 20; swap(a, b); a 和 b 的值会被交换

int &max(int &x, int &y) {
    return (x > y) ? x : y;
}
int a = 10, b = 20;
max(a, b) = 30;   将较大的变量（b）赋值为 30

class MyClass {
private:
    int value;
public:
    MyClass(int v) : value(v) {}
    int &getValue() { return value; }   返回成员变量的引用
};
MyClass obj(10);
obj.getValue() = 20;   通过引用修改私有成员变量   

int &badFunction() {
    int x = 10;
    return x;    错误！返回局部变量的引用
}  

const int &ref1 = 100;   合法
const int &ref2 = a + b;   合法，引用表达式结果

1、定义方式：在引用声明前加 const 关键字
int a = 10;
const int &ref = a;   ref 是常量引用，绑定到 a
2、不能通过常量引用修改原变量：
int a = 10;
const int &ref = a;
ref = 20;   错误！常量引用不允许修改所引用的变量
a = 20;     合法！原变量本身可以被修改（除非原变量也是 const）
3、可以引用常量或临时值：普通引用不能直接引用常量或表达式结果，但常量引用可以
const int &ref1 = 100;        合法，常量引用可以引用字面量
const int &ref2 = 5 + 3;      合法，引用表达式结果
const int &ref3 = a * 2;      合法，引用变量运算结果

nt a = 10;
double b = static_cast<double>(a);   基本类型转换
class Base {};
class Derived : public Base {};
Derived d;
Base* b_ptr = static_cast<Base*>(&d);   子类指针→父类指针（安全）

class Base { virtual void f() {} };   含虚函数，多态类型
class Derived : public Base {};
Base* b = new Derived;
Derived* d = dynamic_cast<Derived*>(b);   父类→子类，安全，返回非空指针
下面写法不推荐
Base* b2 = new Base;
Derived* d2 = dynamic_cast<Derived*>(b2);   不安全，返回 nullptr
#include <string>
#include <iostream>
using namespace std;
class Father
{
public:
    virtual void fun()
    {
        cout << "我是父类" << endl;
    }
};
class Son : public Father
{
public:
    void fun()
    {
        cout << "我是子类" << endl;
    }
};
int main()
{
     1、向下转型父类指向子类
    Father *father = new Son;
    Son *son = dynamic_cast<Son *>(father);
    son->fun();
     2、向下转型父类指向父类  不安全，返回 nullptr
    Father *father1 = new Father;
    Son *son1 = dynamic_cast<Son*>(father1);
    if (son1==nullptr)
    {
        cout<<"我是空指针"<<endl;
    }
    return 0;
}

const int* p = new int(10);
int* q = const_cast<int*>(p);   移除 const 限定
*q = 20;   若原对象（*p）非 const，则合法；若原对象是 const，则 UB
 去除const属性之后还是共用同一块内存
    int b=20;
    const int *p=&b;
    cout<<*p<<endl;
    int *p1=const_cast<int*>(p);
    *p1=40;
    cout<<*p<<endl;

int a = 0x12345678;
int* p = &a;
double* q = reinterpret_cast<double*>(p);  重新解释指针类型（危险）