开发者社区> 贺利坚> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

常(const)+ 对象 + 指针:玻璃罩到底保护哪一个

简介: 原创案例讲解——”玻璃罩const”系列的三篇文章: 1. 使用常对象——为共用数据加装一个名为const的玻璃罩 2. 常(const)+ 对象 + 指针:玻璃罩到底保护哪一个 3. 对象更有用的玻璃罩——常引用   在上一篇文章《使用常对象——为共用数据加装一个名为const的玻璃罩》中,利用案例讨论了运用常对象,常成员函数、常数据成员及其用法。const这个玻璃罩让数据只能看,不能改,
+关注继续查看

原创案例讲解——”玻璃罩const”系列的三篇文章:

1. 使用常对象——为共用数据加装一个名为const的玻璃罩

2. 常(const)+ 对象 + 指针:玻璃罩到底保护哪一个

3. 对象更有用的玻璃罩——常引用


  在上一篇文章《使用常对象——为共用数据加装一个名为const的玻璃罩》中,利用案例讨论了运用常对象,常成员函数、常数据成员及其用法。const这个玻璃罩让数据只能看,不能改,有效地避免程序免受不该出现的修改(引起bug的元凶)操作的影响。

  本文继续讨论const这个玻璃罩,主要是要引入指针来。这时,玻璃罩要保护何方?事情似乎变得更复杂。但实际情况是,C++的内在机理仍然很清晰,我们还是要借助实例看下去。读者如果一边能够将程序放到自己的IDE中调一调,改一改,撞撞错,那是更好的了。


  一、指向对象的常指针

  定义指向对象的常指针的一般形式为:

    类名 * const 指针变量名;

  首先应该正确地将这一定义形式识别准确了。按照结合的顺序(类名 (* (const 指针变量名))):就是首先是常量;其次是指针;最后确定指向的是类。作为常量的定义,还要注意的是定义时必须初始化。

  例如,下面程序中第23行:Test * const p1 = &t1;:p1是常量,是指针,指向Test类的对象,初始化为t1对象的地址。看惯了,挺可爱的。

//程序1
#include <iostream>  
using namespace std;  
class  Test  
{  
private:   
    int x;   
    int y;  
public:  
    Test(int a, int b){x=a;y=b;}  
    void printxy() const;  
    void setX(int n) {x=n;}  
    void setY(int n) {y=n;}  
} ;  
void Test::printxy() const   
{  
    cout<<"x*y="<<x*y<<endl;  
}  
void main(void)  
{      
	Test t1(3,5),t2(4,7);
	const Test t3(5,9); 
	Test * const p1 = &t1;
	//p1 = &t2; //招致错误——error C3892: “p1”: 不能给常量赋值
	p1->setX(5);
	t1.printxy( );   //输出x*y=25

	Test *p2=&t1;
	p2=&t2;
	p2->setX(5);
	p2->printxy();  //输出x*y=35

	//p2=&t3;  //招致错误——error C2440: “=”: 无法从“const Test *”转换为“Test *”
	//p2->setX(7);
	//p2->printxy();  

	system("pause");  
}  

  常指针一经初始化后将不能再被改变值(这是常之所在)。但指针指向的值是否可变,取决于指向的对象。例如第25行 p1->setX(5); 成功地修改了t1对象中的 x 成员的值。

  程序中p2不是常指针,所以在第29行,可以为其赋值为&t2,从而指向了t2对象。但是在第33行的赋值却会发生错误。错误的原因不是p2的值(指针)不可变,而是t3是一个常对象,需要指向常对象的指针变量进行处理。


  二、指向常对象的指针变量

  定义指向常变量的指针变量的一般形式为

    const 类名 *指针变量名;

  识别指向常对象的指针要这样看。按照结合的顺序(const ( 类名( *指针变量名))):就是首先是指针变量;其次指向的是类的对象;最后,这个对象应该是常对象。

  例如,下面程序中第22行:const Test *p1;:p1是指针,指向test类的对象,指向的是Test类的常对象,初始化为t1对象的地址。

//程序2
#include <iostream>  
using namespace std;  
class  Test  
{  
private:   
	int x;   
	int y;  
public:  
	Test(int a, int b){x=a;y=b;}  
	void printxy() const;  
	void setX(int n) {x=n;}  
	void setY(int n) {y=n;}  
} ;  
void Test::printxy() const   
{  
	cout<<"x*y="<<x*y<<endl;  
}  
void main(void)  
{      
	const Test t1(3,5),t2(4,7);
	const Test *p1;
	p1 = &t1;
	//p1->setX(5); //招致错误——error C2662: “Test::setX”: 不能将“this”指针从“const Test”转换为“Test &”
	t1.printxy( );   //输出x*y=25

	p1=&t2;
	p1->printxy();  //输出x*y=35

	Test t3(1,3);
	p1=&t3;
	t3.setX(2);
	//p1->setX(3);//招致错误——error C2662: “Test::setX”: 不能将“this”指针从“const Test”转换为“Test &”
	p1->printxy(); //输出x*y=6

	Test const *p3=&t1;
	//p3->setX(9);//招致错误——error C2662: “Test::setX”: 不能将“this”指针从“const Test”转换为“Test &”
	p3->printxy();  

	system("pause");  
} 

  在程序中可以看出,第24行,由于p1指向的是常对象,是不能被修改的对象,p1->setX(5);试图修改对象的数据成员,带来错误并不意外。

  指向常对象的指针变量,是对象不能变,不能通过指针改变其值,而不是指针不能变,所以在第27行,p1=&t2;使p1指向了另外一个常对象。

  如果一个变量已被声明为常变量,只能用指向常变量的指针变量指向它,而不能用指向非const型变量的指针变量去指向它。

  第31行将指向常对象的指针指向了一个非const对象,这是允许的。第32行可以成功地修改这一非const对象的值,但是不要指望p1(指向常对象的指针)去修改。在对待修改的这件事情上,C++采取的是一种较严格的要求,对象本身是否为“常”和指针指向的对象是否为常,两者中有一个为“常”,就不要修改。

  在第36行,定义的指向对象的常指针p3赋初值为&t1,是一个常对象的地址。(注:去掉下面的部分,表述错误。谢谢2楼的评论。原内容:按照这一定义要表达的内容,似乎p3称为指向常对象的常指针更全面,即*p3=&t1;。第36行成功地通过了编译告诉我们,指向对象的常指针可以指向一个常对象。第37行对修改的禁止由于t1为常对象所致,看来,指向对象的常指针不能改变其指向的常对象。)


  三、用(常)指针作形参:实参如何搭配?

  在上面的例子中,指针是通过赋值直接取得值的。在程序设计中还有另一种很重要的情形,来传递变量的值,那就是函数中的参数传递:将实际参数的值传递给形式参数。在这个传递的过程中,道理一样,下表将形、实参是否为const(常)的4种组合产生的效果进行一个罗列:

序号 形参 实参 是否合法 是否可以改变指向的对象的值
(1) 指向非const型变量的指针 非const变量的地址 合法 可以
(2) 指向非const型变量的指针 const变量的地址 非法 不必讨论
(3) 指向const型变量的指针  非const变量的地址 合法 不可
(4) 指向const型变量的指针 const变量的地址  合法 不可
  在这儿的表述中,用了变量,而不是对象。实际上这两者的本质是统一的,道理一样。这样写作,也是提醒读者不要将二者看成不同的事物。

  先给出程序来:

//程序3
#include <iostream>  
using namespace std;  
class  Test  
{  
private:   
	int x;   
	int y;  
public:  
	Test(int a, int b){x=a;y=b;}  
	void printxy() const;  
	void setX(int n) {x=n;}  
	void setY(int n) {y=n;}  
} ;  
void Test::printxy() const   
{  
	cout<<"x*y="<<x*y<<endl;  
}  

void doSomething(Test *p1)  //(1)形参是指向非const型变量的指针 
{
	p1->setX(5); 
	p1->printxy( ); 
}

void main(void)  
{      
	Test t1(3,5);
	doSomething(&t1); //(1)实参是非const变量的地址 
	system("pause");  
} 
  (1)形参是指向非const型变量的指针,实参是非const变量的地址 

  上面的程序中没有给变量/对象做出任何的限制,调用合法,也能够实施修改操作。


  (2)形参是指向非const型变量的指针,实参是const变量的地址 

  下面的程序将不再给出Test类的定义。这组示例中,区别仅在于函数doSomething()的定义形式和调用中使用的实参。

void doSomething(Test *p1)  //(2)形参是指向非const型变量的指针 
{
	p1->setX(5);   //由于第XXx行的错误,这一行可能引起的问题尚无机会讨论
	p1->printxy( ); 
}

void main(void)  
{      
	const Test t1(3,5);
	doSomething(&t1); //(2)实参是const变量的地址 
			  //这一行招致错误——error C2664: “doSomething”: 不能将参数 1 从“const Test *”转换为“Test *”
	system("pause");  
} 
  这段程序将出现编译错误。

  错误产生在第10行—— error C2664: “doSomething”: 不能将参数 1 从“const Test *”转换为“Test *”,还提示—— 转换丢失限定符。

  与前面所讲一致,不能将const对象地址赋值给一个非const指针,如果这个操作成功,就会产生严重的后果:doSomething()函数中将能够修改由传递地址值而对应的对象的值。调用函数时,实际参数的值传递给形式参数时,系统会进行自动类型转换,但这个转换无法进行下去,因为“转换丢失限定符”。


  (3)形参是指向const型变量的指针,实参是const变量的地址 

void doSomething(const Test *p1)  //(3)形参是指向const型变量的指针 
{
	p1->setX(5); //招致错误——error C2662: “Test::setX”: 不能将“this”指针从“const Test”转换为“Test &”
	p1->printxy( ); 
}

void main(void)  
{      
	const Test t1(3,5);
	doSomething(&t1); //(3)实参是const变量的地址 
	system("pause");  
} 
  第3行p1->setX(5);出错,是因为仅形参p1就限定p1所指向的对象为常对象,是不能被修改的。

  从另一方面讲,第10行的调用doSomething(&t1);“门当户对”,是合法语法规定的。实际参数本身也决定了,对象是不能被改变的。


  (4)形参是指向const型变量的指针,实参是非const变量的地址 

void doSomething(const Test *p1)  //(4)形参是指向const型变量的指针 
{
	p1->setX(5); //招致错误——error C2662: “Test::setX”: 不能将“this”指针从“const Test”转换为“Test &”
	p1->printxy( ); 
}

void main(void)  
{      
	Test t1(3,5);
	doSomething(&t1); //(4)实参是const变量的地址 
	system("pause");  
} 
  程序出的错误是一模一样的,形式参数p1所指向的对象不能被修改。和(3)稍有不同的是,单从实参的性质来看,p1所指向的对象t1是允许修改的,只是单纯因为形参上做的限定,不能改了。这要遗憾,这是const最大的功绩!若在某一个函数中,需求提及该函数只读取而不修改形参所指的对象,最好的方法就是,将形参设为const型变量的指针,无论实参是const对象,还是非const对象,统统一不能修改,这不正是我们要谈的关于数据的保护吗?


  四、小结

  引入指针之后,让这一部内容马上显得弯弯绕了。这可不是为了绕概念而设置的,最根本的目的,还是实施数据保护。通过将某些指针设置为指向常对象的指针,从而避免利用指针给对象改变值。

  所以,本讲最有价值的地方在于第三部分之(3)和(4)——使用指向常对象的指针做形式参数。根据用指针做形参的机制,在函数中,可以通过指针改变实际参数所给定内存单元的值。如果这部分值是不能被改变的,为了实现这个需求,将指针设为指向常对象的指针,可以让编译器替我们把关。如果开发的是类库,那也可以避免使用者陷入不种令人抓狂的bug阵中。

  另外,在程序执行中,如果一个指针所指向的位置一经初始化就不能再变,指向对象的常指针是最好的选择。

  在C++提供的如此多的机制中,择其最合适的使用,考验的是程序员的智慧。深入理解,灵活搭配,方显专业功底。


(全文完)

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Rust 大展拳脚的新兴领域:机密计算
随着云原生浪潮逐渐进入下半场,企业和用户对数据的安全性有了更高的要求,“可信原生”与“机密计算”等数据安全新概念被业界提出,并吸引了大批软硬件巨头入场布局, 也让 Rust 这门注重内存安全的高性能编程语言迎来了绝佳的发展机遇。
355 0
独家下载 | Cassandra实战指南 探索云计算与AI浪潮下的下一个职业风口
Apache Cassandra是一套开源分布式NoSQL数据库系统。它最初由Facebook开发,用于储存收件箱等简单格式数据,2008年开源后,由于Cassandra良好的可扩展性,被Digg、Twitter等知名Web 2.0网站所采纳,成为了一种流行的分布式结构化数据存储方案。
21294 0
如何在Kubernetes中部署一个高可用的PostgreSQL集群环境
本文主要介绍了如何在Kubernetes环境中用Stolon去部署高可用的PostgreSQL,本文从Stolon的结构组成开始,由浅入深介绍原理,从开始安装到最后对其进行failover测试,深入浅出,为以后部署高可用的PostgreSQL提供了一种的解决方案。
3313 0
如何在Kubernetes中部署一个高可用的PostgreSQL集群环境
本文讲的是如何在Kubernetes中部署一个高可用的PostgreSQL集群环境【编者的话】本文主要介绍了如何在Kubernetes环境中用Stolon去部署高可用的PostgreSQL,本文从Stolon的结构组成开始,由浅入深介绍原理,从开始安装到最后对其进行failover测试,深入浅出,为以后部署高可用的PostgreSQL提供了一种的解决方案。
2714 0
使用Git上传代码到Github仓库
准备工作:   首先你需要一个github账号,所有还没有的话先去注册吧! https://github.com/ 我们使用git需要先安装git工具,这里给出下载地址,下载后一路直接安装即可: https://git-for-windows.
734 0
mysql 大事物commit慢造成全库堵塞问题
原创转载请注明出处 本文使用引擎INNODB版本MYSQL5.7.13 sync_binlog = 1 innodb_flush_log_at_trx_commit = 1 也就是双1设置, 本文使用通过对mysql 进行trace,gdb 自制工具infobin,以及 select * from sys.session where command'SLEEP' \G完成。
2619 0
Computer Based Social Engineering Tools: Social Engineer Toolkit (SET)
http://www.social-engineer.org/wiki/index.php/Computer_Based_Social_Engineering_Tools:_Social_Engineer_Toolkit_%28SET%29   video http://www.
843 0
+关注
贺利坚
烟台大学计算机学院教师,建设系列学习资源,改革教学方法,为IT菜鸟建跑道,让大一的孩子会编程,为迷茫的大学生出主意,一起追求快乐的大学。 著书《逆袭大学:传给IT学子的正能量》,帮助处于迷茫中的大学
1965
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载