C++语言中常对象、常对象成员【详细讲解】

1、常对象

1）常对象：指的是对象常量。

2）格式

类名 const 对象名;
or
const 类名 对象名;

3）常对象使用时注意要点

（1）在定义常对象时必须进行初始化；
（2）常对象的成员属性不能进行更新；
（3）常对象不能调用该对象中非常成员函数【非const函数】，否则系统会报错误。目的：防止非const成员函数修改常对象中的成员属性的值，因为const成员函数是不可以修改对象中成员属性的值。
（4）常对象的主要作用是【防止对常对象的成员属性的值进行修改】

对注意点（1）（2）的解释

程序1：

#include <iostream>
#include <string>

using namespace std;

class Person{
public:
	Person()
	{
		cout << "调用了Person()构造函数!!!" << endl;
	}
	Person(int age)
	{
		cout << "调用了Person(int age)构造函数!!!" << endl;
		Age = age;
	}
	~Person()
	{
		cout << "调用了析构函数!!!" << endl;
	}
	int Age;
};

int main()
{
	const Person a(10);  //定义个常对象，并且对其中的成员属性进行初始化
	cout << "a.Age的值为：" << a.Age << endl;
	return 0;
}

运行结果：

调用了Person(int age)构造函数!!!
a.Age的值为：10
调用了析构函数!!!

---

程序2：

#i1nclude <iostream>
#include <string>

using namespace std;

class Person{
public:
	Person()
	{
		cout << "调用了Person()构造函数!!!" << endl;
	}
	Person(int age)
	{
		cout << "调用了Person(int age)构造函数!!!" << endl;
		Age = age;
	}
	~Person()
	{
		cout << "调用了析构函数!!!" << endl;
	}
	int Age;
};

int main()
{
	const Person a;  //定义个常对象
	a.Age = 10;      //不能对常对象中的成员属性的值进行修改
	return 0;
}

运行结果：

结果解释：

将常对象类比于常整型进行记忆学习。比如，在下面的语句中，将a定义为一个整型常量，只能并且必须在初始化的时候对a赋初值，之后不可以对a的值进行改动。

const int a = 10;    //将a定义一个整型常量，并且对a进行初始化
a = 20;              //错误，a是整型常量，不能对a的值进行再次修改

对注意点（3）的解释

程序：

#include <iostream>
#include <string>

using namespace std;

class Person{
public:
	Person()
	{
		cout << "调用了Person()构造函数!!!" << endl;
	}
	Person(int age)
	{
		cout << "调用了Person(int age)构造函数!!!" << endl;
		Age = age;
	}
	//非const成员函数
	void fun(void)
	{
		cout << "调用非const函数fun(void)" << endl;
	}
	~Person()
	{
		cout << "调用了析构函数!!!" << endl;
	}
	int Age;
};

int main()
{
	const Person a;  //定义个常对象
	a.fun();         //常对象不能调用类中非const成员函数
	return 0;
}

运行结果：

2、常对象成员

常对象成员包括常成员属性和常成员函数。

1）常成员属性

（1）类中的成员属性可以是常量或者常引用，使用const关键字将成员属性变换为常成员属性。

（2）如何对于常成员属性进行初始化？

答：通过构造函数和初始化列表对于常成员属性进行初始化。

类名(参数列表):常成员属性1(值),常成员属性2(值),......

（3）程序

#include <iostream>

using namespace std;
class Person {
public:
	Person(int a, int b,int c) :Age(a), Data(b), Num(c)  //通过初始化列表来初始化常成员属性
	{
		cout << "调用了构造函数和初始化列表来初始化常成员属性!!!" << endl;
	}
	const int Age;   //常量
	const int Data;
	const int& Num;  //常引用
};

int main()
{
	int c = 30;
	Person person(10, 20,c);
	cout << "person.Age的值为：" << person.Age << endl;
	cout << "person.Data的值为：" << person.Data << endl;
	cout << "person.Num的值为：" << person.Num << endl;
	return 0;
}

运行结果：

调用了构造函数和初始化列表来初始化常成员属性!!!
person.Age的值为：10
person.Data的值为：20
person.Num的值为：30

知识回顾：

带有初始化列表的构造函数执行顺序：先执行初始化列表，在执行构造函数体。对于含有多个初始化项的列表，初始化顺序是按照成员属性定义的顺序进行初始化的。

 2）常成员函数【之前学的都是非常成员函数】

（1）格式

函数类型 函数名称(参数列表) const

（2）对于常成员函数的注意要点

a. 常成员函数不能更新对象的成员属性；
b. 常成员函数不能调用该类中其他的非常成员函数；
c. 常对象只能调用常成员函数，不能调用非常成员函数；
d. const关键字可以实现函数重载。

（3）程序

#include <iostream>

using namespace std;
class Person {
public:
	//构造函数
	Person(int age) :Age(age)
	{
		cout << "调用了构造函数!!!" << endl;
	}
	//非常成员函数
	void fun(void)
	{
		cout << "调用了非常成员函数!!!" << endl;
	}
	//常成员函数
	void function(void) const
	{
		cout << "调用了常成员函数!!!" << endl;
		cout << "Age的值为：" << Age << endl;
	}
	int Age;
};

int main()
{
	const Person a(10);  //定义一个常对象
	a.function();        //常对象只能调用常成员函数
	cout << "-------------------" << endl;
	Person b(20);        //定义一个非常对象
	b.function();        //既可以调用常成员函数
	b.fun();             //也可以调用非常成员函数
	return 0;
}

运行结果：

调用了构造函数!!!
调用了常成员函数!!!
Age的值为：10
-------------------
调用了构造函数!!!
调用了常成员函数!!!
Age的值为：20
调用了非常成员函数!!!

3、常对象、常成员属性、常成员函数总结

1）常对象只能调用常成员函数，不能调用非常成员函数；并且成员属性只能通过构造函数和初始化列表进行初始化，之后不能被修改
2）常成员函数只能调用该类中常成员函数，不能调用该类中非常成员函数；可以访问成员属性，但是不能修改成员属性
3）常成员函数与非常成员函数可以实现重载
4）非常对象既可以调用非常成员函数也可以调用常成员函数（优先调用非常成员函数）