C++ const指针常量与常量指针，const成员函数

记忆法：const 在*左边右边记忆法

常量指针(被指向的对象是常量)

定义：又叫常指针，可以理解为常量的指针，指向的是个常量

关键点：

1. 常量指针指向的对象不能通过这个指针来修改，可是仍然可以通过原来的声明修改；
2. 常量指针可以被赋值为变量的地址，之所以叫常量指针，是限制了通过这个指针修改变量的值；
3. 指针还可以指向别处，因为指针本身只是个变量，可以指向任意地址;

const int *p或int const *p

指针常量(指针本身是常量)

定义：

本质是一个常量，而用指针修饰它。指针常量的值是指针，这个值因为是常量，所以不能被赋值。

关键点：

1. 它是个常量！
2. 指针所保存的地址可以改变，然而指针所指向的值却不可以改变；
3. 指针本身是常量，指向的地址不可以变化,但是指向的地址所对应的内容可以变化；

int main(int argc, const char * argv[]) {

    int i = 0;
    int j = 10;
    int *pi =&j;
    pi = &i;//没有const限制的情况下

    const int &r3 = i;
    int *const p1 = &i; //顶层const 修饰指针不能指向其他对象
    *p1 = 1000;         //但是指向的对象的值可以更改
    const int ci = 42;//顶层const
    const int ci2 = 44;
    const int *p2 = &ci;//底层const
    const int *const p3 = p2;//左底右顶
    p2 = p3;
    const int &r = ci;//底层const

    const int &ci_j = j;//改变底层const绑定的值
    int &r_j = j;//因为ci_j是const引用，不能通过ci_j绑定的对象而修改值
    r_j = j*2;//r_j为20

//同理其他类型
    const char *a = "aaa";
    const char *b = "bbb";
    a = b;
    a = "cccc";
    char *const p22 = "ss";
    char *const p11 = "aa";

    string ab = "aaaa";
    string ac = "bbbb";
    const string *ptr = &ab;
    const string *ptr2 = ∾
    ptr = ptr2;
    string ad ="ccc";
    string *ptr3 = &ad;
    *ptr3 = "600";
   return 0;
}

C++的const类型成员函数

非const成员函数不能访问const类对象的数据成员 

1. 在C++中只有被声明为const的成员函数才能被一个const类对象调用。

 在C++中，只有被声明为const的成员函数才能被一个const类对象调用。

如果要声明一个const类型的类成员函数，只需要在成员函数列表后加上关键字const， 例如：

class Screen {
    public:
        char get() const;
};

char Screen :: get() const {
    return _screen[_cursor];
} 

若将成员函数声明为const，则不允许通过其修改类的数据成员。 值得注意的是，如果类中存在指针类型的数据成员即便是const函数只能保证不修改该指针的值，并不能保证不修改指针指向的对象。例如：

class Name {
public:
void setName(const string &s) const;
private:
    char *m_sName;
};
void setName(const string &s) const {
    m_sName = s.c_str();      // 错误！不能修改m_sName;
for (int i = 0; i < s.size(); ++i) 
    m_sName[i] = s[i];    // 不好的风格，但不是错误的
}

2. const成员函数可以被对应的具有相同形参列表的非const成员函数重载，例如：

class Screen {
public:
char get(int x,int y);
char get(int x,int y) const;
};
int main()
{
const Screen cs;
Screen cc2; 
char ch = cs.get(0, 0);  // 调用const成员函数  
ch = cs2.get(0, 0);     // 调用非const成员函数 
}

在这种情况下，类对象的常量性决定调用哪一个函数： 

• const成员函数可以访问非const对象的非const数据成员，const数据成员，也可以访问const对象内的所有数据成员；
• 非const成员函数只可以访问非const对象的任意的数据成员（不能访问const对象的任意数据成员）；（上述原因可详见C++Primer（5th）231页。 在默认情况下，this的类型是指向类类型非常量版本的常量指针，例如 Screen类中，this类型为 Screen *cosnt。当在成员函数的后面加上const关键字时，隐式的将this指针修改为 const Screen *const 即指向类类型常量版本的常量指针。根据初始化原则，我们不能将一个常量指针赋值给一个非常量指针）
• 作为一种良好的编程风格，在声明一个成员函数时，若该成员函数并不对数据成员进行修改， 应尽可能将该成员函数声明为const成员函数。

2. const修饰的是谁？

 const成员函数的写法有两种

　　1、void fun(int a，int b) const{}

　　2、void const fun(int a,int b){}

这两种写法的本质是：void fun (const 类 *this, int a,int b);

const修饰的不是形参a和b；const修饰的是属性this->a和this->b。与const所写的位置无关。

为什么？

因为c++对类的this指针做了隐藏，本质上，const指针修饰的是被隐藏的this指针所指向的内存空间，修饰的是this指针。

总结：

1）const成员函数可以访问非const对象的非const数据成员、const数据成员，也可以访问const对象内的所有数据成员；

2）非const成员函数可以访问非const对象的非const数据成员、const数据成员，但不可以访问const对象的任意数据成员；

3）作为一种良好的编程风格，在声明一个成员函数时，若该成员函数并不对数据成员进行修改操作，应尽可能将该成员函数声明为const 成员函数。

4）如果只有const成员函数，非const对象是可以调用const成员函数的。当const版本和非const版本的成员函数同时出现时，非const对象调用非const成员函数。

 

补充：

> 类中的const成员变量都要放在初始化列表之中进行
　　> const数据成员
　　> 引用数据成员
　　> 对象数据成员（内置类）

 

　　const成员函数
　　> void print() const => const 类名 * const this
　　> 在其内部是不能修改数据成员
　　> 只能调用const成员函数，不能调用非const成员函数
　　> const对象只能调用const成员函数,必须要提供一个const版本的成员函数

 

const成员函数和成员变量这一块的逻辑容易混乱！