学习C++中的const

总结了一下C++中的常量。

class A
{
public:
    A(){};
    ~A(){};
    //foo1 为一个类的常函数，它允许A的const实例调用, 也允许普通A的实例调用
    //在foo1中不能修改类A中的任何成员变量！
    //常量函数在定义的时候也必须在参量括后后加上const
    //const 可以作为函数的重载标志
    //如下两个foo1函数，虽然参数都一样，但是仍可通过const来区分重载
    void foo1()const{/*i++;*/};
    void foo1(){};// OK!
    
    //foo2 为普通函数，它不允许A的const实例调用，但是允许普通A的实例调用
    void foo2(){i++;/* OK */};   





    //返回一个常量引用
    const A& foo3(){return *this;};
    const int& foo5(){return i;};

    //返回一个普通的引用
    int& foo4(){return i;};

    //j为一个常量引用参数，在foo6()不能修改其值
    //对于常量引用参数，函数调用时会先将参数拷贝到只读内存区，临时存储。
    void foo6(const int &j){i=j;};

    //非常量引用只传递一个指向参数变量的引用，而不会拷贝数据，
    //当传进来的是一个常量时会出错！
    void foo7(int &j){i=j;};
private:
    int i;
};

int
main(void)
{
    int v1, v2;
    int v[10];
   
    // 1. 定义两个常量 //   





    // k,x等价，看个人习惯使用
    const int k = 1;
    int const x = 2;

    // 2. 常量指针 //

    
    // 指针指向只读内存空间！！p1,p2等效！！
    const int* p1 = &v1;
    int const* p2 = &v2;
    
    //p1, p2指针本身的值可以改变
    p1++; //OK
    p2++; //OK

    //p1,p2指向的内存不能写
    //*p1 = 10; //error
    //*p2 = 20; //error

    //const* int p3 = &v1;//error! 这种定义是非法的！！
    //指针本身为常量，但是其指向的内存是可读可写！！
    //注意与 int const* p2的区别！！
    int* const p4 = &v1;


    //所指内存可写
    *p4 = 10;


    //指针本身内存只读
    //p4++; //error


    // 3. 常量函数 //

    A const a; // a为A的一个常量实例
    a.foo1();  // OK！foo1()为一个常量函数
    //a.foo2();// 出错，a为一个常量，而foo2是一个普通成员函数。编译器认为foo2
               // 中会修改A的成员变量，即使你没有这样做！


    // 4. 返回常量的函数//

    A a2,a3;
    a2.foo3().foo1();// OK！虽然foo3()返回一个常量，但是foo1()为一个常量函数
    //a2.foo3().foo2();//出错！因为a2.foo3()返回一个常量，而foo2()不是一个常量函数。编译器认为在foo2()中会修改其成员变量。

    //返回常量的函数也就意味着其返回值不能作为左值。
    //例如：
    a2.foo4() = 0; // OK! foo4()返回普通的引用，可以作为左值
    //a2.foo5() = 0; //error!! foo5()返回一个常量引用，不能对其赋值！

   
    //5. 常量引用参数 //

    a2.foo6(1); //OK!
    //a2.foo7(1); //error !! 非常量引用参数的函数不能传常量   
    


    // return
    return 0;
}

在C++程序中，能用const修饰的地方应尽量用const修饰！！