#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; } 調(diào)用時直接傳遞變量，而非指針 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;   合法，引用表達式結(jié)果

1、定義方式：在引用聲明前加 const 關(guān)鍵字
int a = 10;
const int &ref = a;   ref 是常量引用，綁定到 a
2、不能通過常量引用修改原變量：
int a = 10;
const int &ref = a;
ref = 20;   錯誤！常量引用不允許修改所引用的變量
a = 20;     合法！原變量本身可以被修改（除非原變量也是 const）
3、可以引用常量或臨時值：普通引用不能直接引用常量或表達式結(jié)果，但常量引用可以
const int &ref1 = 100;        合法，常量引用可以引用字面量
const int &ref2 = 5 + 3;      合法，引用表達式結(jié)果
const int &ref3 = a * 2;      合法，引用變量運算結(jié)果

nt a = 10;
double b = static_cast<double>(a);   基本類型轉(zhuǎn)換
class Base {};
class Derived : public Base {};
Derived d;
Base* b_ptr = static_cast<Base*>(&d);   子類指針→父類指針（安全）

class Base { virtual void f() {} };   含虛函數(shù)，多態(tài)類型
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、向下轉(zhuǎn)型父類指向子類
    Father *father = new Son;
    Son *son = dynamic_cast<Son *>(father);
    son->fun();
     2、向下轉(zhuǎn)型父類指向父類  不安全，返回 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屬性之后還是共用同一塊內(nèi)存
    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);  重新解釋指針類型（危險）