学步园

//test const 使用细则

class Game
{
public:
    int a;
};

void function(const Game& obj)
{
    //obj.a = 1;     //×，内容不可变
}

void function(const string& s)
{
    string tmp = "test";
    //s = tmp;      //×，内容不可变
}

int _tmain(int argc, _TCHAR* argv[])
{

    //1. 定义常量(两种本质相同，都是定义常量)
    const int a = 100;
    int const b = 100;

    //a = 1;   //错误
    //b = 1;   //错误

    //2. 指针(*在const左侧则则表示指针不可变, 右侧表示内容不可改)
    char cDataA[100];
    char cDataB[100];
    char cDataC[100];
    char cDataD[100];
    char* const pDataA = cDataA;        //定义指针常量
    //pDataA = cDataB;                  //×，指针为常量不可以变
    pDataA[0] = 'A';                    //√，内容可变

    const char* pDataB = cDataA;        //指针指向内容不可以改变
    pDataB = cDataB;                    //√，指针可变
    //pDataB[0] = 'B';                  //×，内容不可变

    char const *pDataC = cDataC;
    pDataC = cDataB;                    //√，指针可变
    //pDataC[0] = 'A';                  //×，内容不可变

    const char* const pDataD = cDataD;
    //pDataD = cDataB;                  //×，指针为常量不可以变
    //pDataD[0] = 'A';                  //×，内容不可变


    //3. 函数中使用常量
    //void function(const int a);       //a为形参，调用时会自动拷贝，无意义(注意：仅限于基本类型[int,bool,float])
    //void function(const char* p);     //p所指内容不可改变，这个经常要用到
    //void function(char* const p);     //p为形参，调用时会自动拷贝，无意义
    //void function(const Class& a);    //此做法是为了提高效率，实际a为地址，不对原对象进行拷贝传递,a中内容不可变
    //void function(const Type& a);     //此做法是为了提高效率，实际a为地址，不对原对象进行拷贝传递,a中内容不可变

    
    //4. 类中使用常量
    class ClassA
    {
    public:    
        const int a;
        char* const p;
        int b;

    public:
        ClassA(int x, char* ptr):
          a(x),p(ptr)                   //√，初始化序列中可以更改常量值
        {
            //a = x;                    //×，a的初始化只能在初始化序列中
        }

        int GetAValue() const           //函数后边加const表示此函数不改变类成员变量
        {
            if(a>0)
                return a;               //√，返回成员变量是允许的
            return b;                   //√，返回常量也是可以的
        }
        
        void SetAValue(int v) const
        {
            //a = v;                    //×，不能改变常量参数
            //b = v;                    //×，函数声明为const不能改变类中成员变量的值
        }
    
        void SetBValue(int v)
        {
            b = v;
        }
    };

    const ClassA CA(10,NULL);
    CA.GetAValue();                     //√，常量对象可以调用常量对象方法
    //CA.SetBValue(1);                  //×，常量对象不能调用非常量(const)函数

    const ClassA* pCA = new ClassA(10, NULL); 
    pCA->GetAValue();                   //√，常量对象可以调用常量对象方法
    //pCA->SetBValue(1);                //×，常量对象不能调用非常量(const)函数

    ClassA NA(10, NULL);
    NA.GetAValue();                     //√，非常量对象可以调用常量对象方法
    NA.SetBValue(1);                    //√，非常量对象可以调用普通对象方法

    getchar();
    return 0;
}