const修饰函数参数一般不作为函数签名的一部分。除非修饰的参数是指针或引用。并且需要是修饰的是底层。#

• const修饰的函数参数是值的时候不可以进行重载。如下代码编译错误。

1
class myobj{
2
    public:
3
        myobj(int x):cal(x){}
4
        int cal;
5
};
6
void func1(myobj a){
7
        cout << "non const" << endl;
8
        }
9
void func1(const myobj  a){
10
    cout <<"const" << endl;
11
}

• const修饰的函数参数是指针或引用的时候，并且修饰的是底层的时候可以进行重载。

• volatile也适用于此规则。

• 以上例外const必须修饰的是指针指向的内容， 即ponter-to-const;

  • 如果是指针本身是const的，则不能重载

• 原因是函数签名不包括形参列表参数的顶层CV限定

  • 顶层const表示指针本身是个常量。顶层修饰的是对象本身。

    • myobj* const b = new myobj(20); const指针b指向myobj

  • 底层const表示指针所指向的对象是个常量。

    • const myobj* b = new myobj(20);指针b指向const myobj

1
//指针
2
void func(myobj* a){
3
        cout << "non const" << endl;
4
        }
5
void func(const myobj* a){
6
    cout <<"const" << endl;
7
}
8
//引用
9
void func1(myobj& a){
10
        cout << "non const" << endl;
11
        }
12
void func1(const myobj& a){
13
    cout <<"const" << endl;
14
}
15

16

17
int main(){
18
    myobj* a = new myobj(10);
19
    const myobj* b = new myobj(20);
20
    func(a); //输出non const
21
    func(b); //输出const
22

23

24
    myobj obj(10);
25
    myobj& refa = obj;
26
    const myobj& refb = obj;
27

28
    func1(refa); //输出 non const
29
    func1(refb); //输出 const
30

31

32
    return 0;
33

34
}

• const引用可以绑定到非const对象，但是非const引用不可绑定const对象。因为不能保证其不被修改。

1
string t = "234"; //非const对象
2
const string& y = t; //可以 const引用
3

4
const string s = "234"; //const对象
5
string& b = s; //不可以 非const引用

• 所以函数入参为引用的时候，非const对象可以传入const引用参数。也就是const引用绑定到非const对象。比如作用是防止修改。但是const对象不可传入非const引用参数。也就是非const引用不可以绑定到const对象。

1
void test(const string& a){
2
    cout << a << endl;
3
}
4

5
void test2(string& a){
6
    cout << a << endl;
7
}
8
int main(){
9
    const string str1 = "234";
10
    string str2 = "234";
11
    test(str1);
12
    test2(str1); //不可以。const对象不能传入非const参数
13
    test(str2);
14
    test2(str2);
15

16
}

• 值传递不受影响

const修饰成员函数修饰的是什么？是this指针#

我们在上面代码段看到了两段被注释掉的函数，里面写出了如果显式this指针会是什么样。

• 注意，由于this指针不能改变指向，所以this指针是一个常量指针。也就是myclass* const this。

• 如果我们不想修改一个参数的值，办法就是让这个参数被const修饰。在这里就是把this指针也用const修饰。则会变成const myclass* const this。这也说明了为什么const只能修饰成员函数，因为非成员函数没有this指针。

• 又由于this指针会被编译器根据对象来隐式传入。所以const对象的this指针必然是也是常量指针。所以自然const对象无法调用非const函数。因为this指针的不匹配。const可以被隐式（函数调用）加上但是不能被去除。也就是权限的缩紧是可以的，放松是不可以的。

• 简单理解就是因为const成员无法进行修改。如果const成员变量调用了非const函数，函数不能保证不修改const成员，如果修改了会报错，所以直接加以限制。当然了非const成员因为可以修改也可以不修改，都不会报错。所以自然可以调用const函数也可以调用非const函数。

• const成员函数不能调用非const成员函数。因为在const成员函数里面的this指针被const修饰，在const成员函数里面调用非const成员函数时，相当于将const修饰的this指针传给非const成员函数。

  • 也可以理解为权限的扩张是禁止的。不可以修改（整体）-> 可以修改（局部）是不可以的。

• 非const成员函数可以调用const成员函数的原因是：权限的缩紧是可以的。

  • 也就是：可以修改（整体）->不可以修改（局部）这样是可以的

1
class myclass{
2
public:
3
    int vala;
4
    int valb;
5
    myclass(int x, int y):vala(x), valb(y){}
6
    void func(){
7
    //一些内容
8
    }
9
    void changethis(const myclass& obj){
10
        obj.func(); //错误。const对象（引用）不能调用非const函数
11
    }
12
};

注意 this指针并不是对象本身的一部分。#

注意 this指针并不是对象本身的一部分。也不会影响sizeof的结果。它的作用域是在类的内部。this指针只不过会在调用非静态函数的时候被编译器隐式加入。

关于const函数重载。const算作函数签名的一部分#

我们在上面代码可以看到，我们有一个函数重载。因为const算作函数签名的一部分。

但是编译器如何判断我们调用的是哪个函数呢？虽然表面参数一样，但其实隐藏的this形参是不同的。

• 所以如果我们调用方是const对象，则会调用const版本的函数。如果是非const对象就调用非const版本的函数。