頂層const： 表示任意的物件是常量。

     底層const： 與指標和引用等複合型別有關。

    對指標而言， 頂層const表示指標本身是個常量， 而底層const表示指標所指的物件是一個常量。

int i = 22;
const int ci = 20; //頂層const， 不能修改ci的值
const int *p1= &ci; //底層const， 允許修改p1的值， 但是不能通過*p1修改ci
的值。
int *const p2 = &i; //頂層const， 不能修改p2的值， 但是允許通過*p2修改i
的值

    用實參初始化形參時， 會忽略掉頂層const， 也就是說，當形參有頂層const時， 傳給它常量物件或者非常量物件都是可以的。

總結

     int cube(int i); 實參可以為int型別， 也可以為const int型別。 在函式體中可以修改i的值， 函式不會修改實參的值。

    int cube(const int i); 實參可以為int型別， 也可以為const int型別。 在函式體中不可以修改i的值， 函式不會修改實參的值。

    int pCube(int * pi); 實參為int * 型別的指標， 不能為const int * 型別。 可以通過修改* pi 的值修改實參指向的物件的值， 修改pi對實參沒有影響。

    int pCube(const int pi)； 實參可以為const int 型別，也可以為int * 型別。 不可以通過修改* pi 的值修改實參指向的物件的值， 修改pi對實參沒有影響。

    int pCube(int * const pi)； 實參為 int * 型別， 不能為const int * 型別。 可以通過修改* pi 的值修改實參指向的物件的值， 不可以給pi賦值。

    void reset(int &r)； 實參為int型別， 不可以為const int 型別。 可以通過修改r的值， 從而修改實參的值。

    void print(const int &r)； 實參可以為int型別， 也可以為const int型別， 不可以修改r的值。

#include<iostream>

using namespace std
 
;

int fun1(int i);
int fun2(const int i);
int pfun1(int *pi);
int pfun2(const int *pi);
int pfun3(int *const pi);
int rfun1(int &r);
int rfun2(const int &r);
int main()
{
    //num1為int型別的變數，可以修改它的值
    //num2為int型別的常量，不可以修改它的值
    int num1 = 10;
    const int num2 = 10;
    num1 = 20;
    //num2 = 20;

    //普通指標，可以修改p1的值，也以通過修改*p1來修改num1的值。
    //所以只能用int型別的資料來初始化，不能用const int型別，不能修改常量的值
    int *p1 = &num1;
    //int *p2 = &num2; //出錯

    //底層const，可以修改指標（p3,p4），但是不可以通過*p3,*p4，去修改num1, num2的值。
    //可以使用int型別或const int型別的資料來初始化
    const int *p3 = &num1;
    const int *p4 = &num2;

    //頂層const，不可以修改指標（p5,p6），但是可以通過*p5去修改num1的值。
    //所以只能使用int型別的資料來初始化，不能const int型別
    int * const p5 = &num1;
    //int * const p6 = &num2;  //錯誤

    //int型別的引用，可以通過r1去修改num1的值，所以只能用int型別去初始化，不能使用const int型別
    int &r1 = num1;
    //int &r2 = num2; //出錯

    //const int型別的引用，不能修改r3,r4的值
    //可以使用int型別的資料來初始化，也可以使用const int型別
    const int &r3 = num1;
    const int &r4 = num2;

    //實參為int型別或const int型別
    cout << fun1(num1)  << " "<< fun1(num2) << endl;
    cout << fun2(num1) << " " << fun2(num2) << endl;

    //實參只能為int型別
    cout << pfun1(&num1) << endl;
    //cout << pfun1(&num2) << endl; //出錯

    //所以實參可以是int型別，也可以是const int型別
    cout << pfun2(&num1) << " " << pfun2(&num2) << endl;

    //所以實參型別只能是int型別
    cout << pfun3(&num1) << endl;
    //cout << pfun3(&num2) << endl; //出錯

    //實參型別只能是int型別
    cout << rfun1(num1) << endl;
    //cout << rfun1(num2) << endl; //出錯

    //實參型別可以是int型別，也可以是const int型別
    cout << rfun2(num1) << " " << rfun2(num2) << endl;
    return 0;
}

//可以修改形參i
int fun1(int i)
{
    //i = 0;
    return i * i * i;
}
//不可以修改形參i
int fun2(const int i)
{
    //i = 0;  //出錯
    return i * i * i;
}

int pfun1(int *pi)
{
    //*pi = 0;
    return *pi * (*pi) *(*pi);
}

//可以修改pi，但是不可以修改*pi。所以實參可以是int型別，也可以是const int型別
int pfun2(const int *pi)
{
    //*pi = 0;  //出錯
    return *pi * (*pi) *(*pi);
}

//不可以修改pi，但是可以修改*pi，所以實參型別只能是int型別
int pfun3(int *const pi)
{
    //*pi = 0;
    return *pi * (*pi) *(*pi);
}

//可以修改r，實參型別只能是int型別
int rfun1(int &r)
{
    //r = r * r * r;
    return r * r * r;
}
//不可以修改r,實參型別可以是int型別，也可以是const int型別
int rfun2(const int &r)
{
    //r = r * r * r; //出錯
    return r * r * r;
}