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

心已赠人 2023-06-29 05:35 107阅读 0赞

记忆法：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 = &ac;
        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成员函数和成员变量这一块的逻辑容易混乱！