const常量的判別標準

• 只有用字面量初始化的const常量才會進入符號表
• 使用其他變數初始化的const常量仍然是隻讀變數
• 被volatie 修飾const常量不會進入符號表
  

  在編譯期間不能確定初始值的const識別符號，都被作為只讀變數處理

• const引用的型別和初始化變數的型別

  • 相同：初始化成為只讀變數

  • 不同：生成一個==新的==只讀變數

    char c = 'c';
    const char& trc = c; 
    c = 'a';
    printf("&c = %p\n", &c);
    printf
     
    ("&trc = %p\n", &trc); 
    printf("c = %c\n", c);   
    printf("trc = %c\n", trc);
    輸出：&c = 008FFD13
          &trc = 008FFD13
          c = a
          trc = a          //地址相同，改變了c   trc也改變
    當const引用的型別和初始化變數的型別相同，則地址相同，說明初始化成為了一個只讀變數trc
    
    char c = 'c';
    const int& trc = c; 
    printf("&c = %p\n", &c);
    printf
     
    ("&trc = %p\n", &trc);  
    printf("c = %c\n", c);   
    printf("trc = %c\n", trc);
    輸出：&c = 00AFFCDB
          &trc = 00AFFCC0
           c = a
          trc = c           //地址不相同，改變c  trc不變
    當const引用的型別和初始化變數的型別不同，則地址不相同，說明生成一個新的只讀變數trc

#include <stdio.h>

int main()
{
    const int x = 1;      //常量
 

    const int& rx = x;     //只讀變數

    int& nrx = const_cast<int&>(rx);   //去除只讀屬性

    nrx = 5;

    printf("x = %d\n", x);
    printf("rx = %d\n", rx);
    printf("nrx = %d\n", nrx);
    printf("&x = %p\n", &x);
    printf("&rx = %p\n", &rx);
    printf("&nrx = %p\n", &nrx);
    //輸出結果：
            x = 1
            rx = 5
            nrx = 5
            &x = 010FFCDC
            &rx = 010FFCDC
            &nrx = 010FFCDC
 -----------------------------------------------------------------------   
    volatile const int y = 2;      //具有隻讀屬性
    int* p = const_cast<int*>(&y);  //去除其只讀屬性

    *p = 6;

    printf("y = %d\n", y);   // y 值改變  輸出y = 6
    printf("p = %p\n", p);

    const int z = y;            //用變數初始化，只具有隻讀屬性

    p = const_cast<int*>(&z);   //去除只讀屬性

    *p = 7;

    printf("z = %d\n", z);     //z = 7
    printf("p = %p\n", p);
---------------------------------------------------------------------

    const int z = 99;          //常量

    p = const_cast<int*>(&z);

    *p = 7;
    printf("z = %d\n", z);    //***** z值不變   z = 99   從符號表中取，在編譯期間這裡已經是99了
    printf("*p = %d\n", *p);  // *p =7
    printf("p = %p\n", p);    //地址和  &z 相同
    printf("&z = %p\n", &z);
-------------------------------------------------------
    char c = 'c';
    char& rc = c;
    const int& trc = c;

    rc = 'a';

    printf("c = %c \n",c);      //a
    printf("rc = %c \n",rc);    //a
    printf("trc = %c \n",trc);  //c   const引用的型別和初始化變數的型別不同,生成一個新的只讀變數
    return 0;
}

• 預設情況，const物件只在檔案內有效，要想在別檔案也引用， 不管是申明還是定義==都==在前面加上 extern

//file_1.cpp
extern const int test = 0;

//file_2.cpp
extern const int test;

-

typedef char* pstring;

const pstring cstr = 0; //等價於 char* const cstr = 0;

指標和引用

• 指標是一個變數
  
  • 值為一個記憶體地址，不需要初始化，可以儲存不同的地址
  • 通過指標可以訪問對應記憶體地址中的值
  • 指標可以被const修飾成常量或者只讀變數
• 引用是一個變數的新名字
  
  • 對引用的操作（賦值，取地址等）都會傳遞到代表的變數上
  • const引用使其代表的變數具有隻讀屬性
  • ==引用必須在定義初始化，之後無法代表其他變數==

不能使用引用陣列，==C++裡不支援引用陣列==

#include <stdio.h>

int a = 1;

struct SV
{
    int& x;
    int& y;
    int& z;
};

int main()
{
    int b = 2;
    int* pc = new int(3);
    SV sv = {a, b, *pc};
    int& array[] = {a, b, *pc}; // &array[1] - &array[0] = ?  Expected ==> 4
                                //error，c++不支援引用陣列

    printf("&sv.x = %p\n", &sv.x);   //列印的為被引用變數的地址
    printf("&sv.y = %p\n", &sv.y);
    printf("&sv.z = %p\n", &sv.z);

    delete pc;

    return 0;
}