技术交流QQ群:1027579432,欢迎你的加入!

1.常引用

  • 用const声明的引用就是常引用。常引用所引用的对象不能被更改。经常见到的是常引用作为函数的形参,这样不会发生对实参的误修改。常引用的声明形式为:const 类型说明符 &引用名。常引用作为函数形参的例子如下:
        #include "iostream"
    
        using namespace std;
    
    
        // 常引用作为函数形参,保证了不会对实参的值进行误修改,常引用的格式是: const 类型名 &引用名;
        void fun(const double &d);
    
    
        int main(){
            double d = 3.14;
            fun(d);
            return 0;
        }
    
        void fun(const double &d){
            // 常引用作形参,在函数中不能更新d所引用的对象
            double i = 6.66;
            // d = i;  此处将报错!!!
            cout << "d = " << d << endl;
        }
    
    

2.常对象

  • 常对象是指数据成员在它的生存期内不会被改变。定义常对象时必须对其进行初始化,并且不能改变其数据成员的值。常对象的声明形式为:类名 const 对象名 或者 const 类名 对象名。常对象的例子如下:
        // 常对象
        class A{
            public:
                A(int i, int j){
                    i = x;
                    j = y;
                }
            private:
                int x;
                int y;
        };
        int main(){
            A const a(1, 2);  // 等价于const A a(1, 2);a是常对象,不能被更新!!!
            return 0;
        }
    
  • 如果程序中出现对常对象的数据成员试图进行修改的语句,编译器会报错。一般修改对象的数据成员有两种途径,一种是通过对象名访问公有数据成员并修改其值,而常对象的数据成员是不能被修改的;另一种是类的成员函数修改数据成员的值,而常对象不能调用普通的成员函数。可是这样的话,常对象就只剩数据,没有对外的接口了,这就需要为常对象专门定义的常成员函数了。

3.类的常成员函数

  • 类中用const声明的成员函数就是常成员函数,常成员函数的声明形式为:类型说明符 函数名(参数表) const;。常成员函数需要注意的几点:
    • 常成员函数在声明和实现时都要带const关键字;
    • 常成员函数不能修改对象的数据成员,也不能访问类中没有用const声明的非常成员函数;
    • 常对象只能调用它的常成员函数,不能调用其他的普通成员函数;
    • const关键字可以被用于参与对重载函数的区分。比如,如果有两个这样声明的函数:void fun(); void fun() const;,则它们是重载函数。
  • 常成员函数实例如下:
        // 常成员函数
        class R{
            public:
                R(int i1, int i2){
                    R1 = i1;
                    R2 = i2;
                }
                void Print();
                void Print() const;   // 常成员函数
            private:
                int R1;
                int R2;
        };
    
        void R::Print(){
            cout << "R1 = " << R1 << " , R2 = " << R2 << endl;
        }
    
        void R::Print() const{
            cout << "R1 = " << R1 << " , R2 = " << R2 << endl;
        }
        
        int main(){
            R r(5, 4);
            r.Print();  // 调用的是普通成员函数void Print()
            R const rr(20, 45);  // rr是一个常对象
            rr.Print();  // 常对象只能调用常成员函数,所以此处调用的是void Print() const;
            return 0;
        }
    

4.常数据成员

  • 类的数据成员也可以是常量和常引用,用const声明的数据成员就是常数据成员。在任何函数中都不能对常数据成员赋值。构造函数对常数据成员初始化,只能通过初始化列表。常数据成员实例如下:
        // 常数据成员
        class B{
            public:
                B(int i);
                void Print();
                const int &r;   // 常引用r是对变量a的引用
            private:
                const int a;   // 常数据成员
                static const int b;  // 静态常数据成员,必须在类外进行初始化!!!
        };
        // 静态常数据成员初始化
        const int B::b = 330;
        // 类外进行构造函数定义
        B::B(int i): a(i), r(a){
            cout << "B的对象的构造函数\n";
        }
    
        void B::Print(){
            cout << "a = " << a << " , b = " << b << " , r = " << r << endl;
        }
    
    
        int main(){
            //建立对象b1和b2,并以50和550作为初值,分别调用构造函数,通过构造函数的初始化列表给对象的常数据成员赋初值
            B b1(50);
            B b2(550);
            b1.Print();
            b2.Print();
            return 0;
        }
    

5.参考博客