C++ 关于“常量”的知识整理：

目录

1 常量对象：

2 常量成员：

2.1常量数据成员：

常数据成员总结：

2.2常量成员函数（使用最多）：

常成员函数总结：

3 常量引用：

---

C++中常量的值在程序运行中不允许被改变，定义或声明常量时必须初始化！

常量对象：

常量对象的数据成员的值始终为初始化所赋值，在整个对象生命周期内不允许被修改

const class 对象名 {初始化列表};
class const 对象名 {初始化列表};

引例：

class A 
{
public:
    A(int i):id(i) //构造函数 {	}
    void set(int i)//修改id的值
    {
        id = i;
    }
    ~A(){	}//析构函数
private:
	int id; //编号
};

int main()
{
    //定义常量对象
    A const a{ 1 };//写法1
    const A b{ 1 };//写法2

    //错误：常量对象的数据成员不允许被修改！！！
    //a.set(10);//错误a的值不能修改
    //b.set(20);//错误b的值不能修改
    return 0;
}

常量成员：

类的常量成员包括常量成员函数和常量数据成员。

常量数据成员：

常量数据成员要求，自第一次赋值之后，数据不允许更改；

引例：居民身份证号

const 数据类型 变量名；

赋值方式：定义时在后面直接赋值；构造函数的初始化列表内赋值；

                若两种赋值方式同时出现时，以构造函数的具体赋值为准；

class A
{
private:
	const int a = 10;
	const int b = 20;

public:
	A(int c, int d) :a(c), b(d) 
    {
        //a = c;//错误的
		//b = d;//仅有允许在初始化列表赋值！函数内部错误
    };
	A() {};//重载函数：无参数时构造函数不再赋值常数据成员。
	void show()const//自觉设为常函数，避免复杂设计时错误产生
	{
		cout << "const a:" << a << "       const b:" << b << endl;
	}
};

int main()
{
	A a(100, 200);//a对象采用初始化定义和构造函数初始化列表赋值两种方式
    //以初始化列表中数值为准
	a.show();
    
	A b;//无参数时构造函数不再赋值常数据成员
    //b 对象采用定义的同时初始化，推荐此类方式！
	b.show();
	return 0;
}

常数据成员总结：

1. 两种赋值方式都存在时，以构造函数初始化列表内数据为准
2. 构造函数为常数据成员赋值时，仅能采用函数初始化列表的方式
3. 构造函数的函数主题内赋值常数据成员是错误的，而类内普通数据成员可以在参数列表或函数主题中完成初始化，二选一即可
4. 推荐使用定义常数据成员的同时赋值

常量成员函数（使用最多）：

返回值 函数名（参数列表） const;

常量成员函数限定两个因素:成员函数（访问对象的所有数据）、常量（限定对象的数据不能被修改）

结构说明：

1. C++中所有的成员函数中都隐含一个指向对象的this指针，也正是因为this 隐含，const无法直接限定对象，只能放在函数最后！！！注意区分常量引用，const 位于参数列表；
2. const 作为常量限定的关键字，在声明和定义实现的两处都有（区别于：友元、静态，仅声明处有，定义处没有）；
3. const 可以作为重载函数的区分，加const 与未加const 为重载函数

class A
{
public:
    A(int i) :id(i)  {	}//构造函数

    void set(int i)//修改id的值
    {
        id = i;
        cout << "修改后的值:";
        show();
    }
    void show()const//常函数：输出
    {
        cout << "id=" << id << endl;
       //error: id++;
       // 错误原因：常函数内对象的数据不允许被修改
       // 
        //error:set(2);
        //错误原因：常函数内可以调用常函数，不能调用普通函数
    }

    ~A() {	}//析构函数
private:
    int id; //编号
};

int main()
{
   
    A  a{ 1 };//普通对象
    const A b{ 1 };//常对象

    a.show();
    b.show();

    a.set(2);
   // error:b.set(2);
    //出错原因：常对象只能调用常函数
    return 0;
}

常成员函数总结：

1. 常成员函数内不允许修改对象的值
2. 常成员函数内可以调用常成员函数，而不允许调用普通函数
3. 常对象仅能调用常成员函数，不能调用普通成员函数
4. 普通对象既能调用普通成员函数，又能调用常成员函数
5. 普通成员函数内既能调用常成员函数，又能调用普通成员函数

权限仅能缩小传递，不能放大传递

注意：在函数设计时，如若对象的数据成员无需修改则定义为常函数，在函数声明和定义最后加const 关键字限定！

避免常对象无法正确调用函数、函数内错误修改不必要修改的值

常量引用：

常量引用：用const 修饰引用，则不能通过引用修改原对象的数据成员（修饰形参）

const 类型 & 变量名；//格式

void Show(const int& x)
{
    //x++; 
    //错误，常量引用作为形参，其值不能被改变
    cout << x << endl;
}
int main()
{
    int i = 12;
    Show(i);

    return 0;
}

主要使用场景：修饰形参

class A
{
public:
    A(int a = 0, int b = 0) :m_a(a), m_b(b)
    {}
    A(const A& ca)//拷贝构造函数,不允许修改ca的内容
    {
        m_a = ca.m_a;
        m_b = ca.m_b;
    }
private:
    int m_a;
    int m_b;
};

int main()
{
    A a{10,20};
    A b{ a };

    return 0;
}

区分：const放在函数最后（常成员函数）const 放在函数参数列表（常引用）

• 常函数修饰函数，限制函数内隐含指向对象的this指针，使得函数主体内对象的数据成员不允许被修改。
• 常引用修饰形参，限制引用的"一改同改"的特性，因而不允许修改参数对象的数据成员,即同时满足引用和常量的性质

 引例：运算符重载

两种加法运算重载，都是以类的对象作为运算的第一个操作数，区别于第二个参数类型的函数重载

//s3=s1+s2
Time Time:: operator +(const Time& t)const
{
	int tmp = (s + m * 60 + h * 3600) + (t.s + t.m * 60 + t.h * 3600);
	return Time(tmp / 3600 % 24, tmp % 3600 / 60, tmp % 3600 % 60);
}
//s3=s1+1
Time Time::operator +(int t)const
{
	int tmp = (s + m * 60 + h * 3600) + t;
	return Time(tmp / 3600 % 24, tmp % 3600 / 60, tmp % 60);
}

***具体细节：eg: a=b+c

1.(a:)返回值为类的类型及自身属性

2.(c:)Time Time:: operator +(const Time& t)const

此 const 为常引用的标识，即限制参数在函数内不能修改值（限制参数在传递过程中即满足引用的一改全改的特性，又满足常量的不能修改的特性）

3.(b:)Time Time:: operator +(const Time& t)const

此 const 为常函数的标识，限制对象在函数过程中成员的值不能修改，（即限制隐含的指向对象的this指针）

4.常引用及常函数的限制要求，仅常量对象才能调用常函数 如下：

常引用对象 “t" ，t作为常量对象仅能调用常函数，双方相互钳制

//s3=1+s1
Time operator +(int n, const Time& t)
{
	return t + n;
}

5.cosnt 常量仅限类的成员函数作为常函数，普通函数无法限制（无this 指针）