原文地址: http://blog.csdn.net/luoweifu/article/details/45600415

这里的T指的是一种数据类型,可以是int、long、doule等基本数据类型,也可以是自己类型的类型class。单独的一个const你肯定知道指的是一个常量,但const与其他类型联合起来的众多变化,你是不是就糊涂了?下面我们一一来解析。

const T

定义一个常量,声明的同时必须进行初始化。一旦声明,这个值将不能被改变。

  1. int i = 5;
  2. const int constInt = 10; //正确
  3. const int constInt2 = i; //正确
  4. constInt = 20; //错误,常量值不可被改变
  5. const int constInt3; //错误,未被初

const T*

指向常量的指针,不能用于改变其所指向的对象的值。

  1. const int i = 5;
  2. const int i2 = 10;
  3. const int* pInt = &i; //正确,指向一个const int对象,即i的地址
  4. //*pInt = 10; //错误,不能改变其所指缶的对象
  5. pInt = &i2; //正确,可以改变pInt指针本身的值,此时pInt指向的是i2的地址
  6. const int* p2 = new int(8); //正确,指向一个new出来的对象的地址
  7. delete p2; //正确
  8. //int* pInt = &i; //错误,i是const int类型,类型不匹配,不能将const int * 初始化为int *
  9. int nValue = 15;
  10. const int * pConstInt = &nValue; //正确,可以把int *赋给const int *,但是pConstInt不能改变其所指向对象的值,即nValue
  11. *pConstInt = 40; //错误,不能改变其所指向对象的值

const int* 与int* const的区别

指针本身就是一种对象,把指针定义为常量就是常量指针,也就是int* const的类型,也可以写成int *const,声明时必须初始化。

  1. int nValue = 10;
  2. int* const p = &nValue;
  3. int *const p2 = &nValue;
  4. const int* 指针指向的对象不可以改变,但指针本身的值可以改变;int* const 指针本身的值不可改变,但其指向的对象可以改变。
  5. int nValue1 = 10;
  6. int nValue2 = 20;
  7. int* const constPoint = &nValue1;
  8. //constPoint = & nValue2; //错误,不能改变constPoint本身的值
  9. *constPoint = 40; //正确,可以改变constPoint所指向的对象,此时nValue1 = 40
  10. const int nConstValue1 = 5;
  11. const int nConstValue2 = 15;
  12. const int* pPoint = &nConstValue1;
  13. //*pPoint = 55; //错误,不能改变pPoint所指向对象的值
  14. pPoint = &nConstValue2; //正确,可以改变pPoint指针本身的值,此时pPoint邦定的是nConstValue2对象,即pPoint为nConstValue2的地址

const int* const 是一个指向常量对象的常量指针,即不可以改变指针本身的值,也不可以改变指针指向的对象。

  1. const int nConstValue1 = 5;
  2. const int nConstValue2 = 15;
  3. const int* const pPoint = &nConstValue1;
  4. //*pPoint = 55; //错误,不能改变pPoint所指向对象的值
  5. //pPoint = &nConstValue2; //错误,不能改变pPoint本身的值

const T&

对常量(const)的引用,又称为常量引用,常量引用不能修改其邦定的对象。

  1. int i = 5;
  2. const int constInt = 10;
  3. const int& rConstInt = constInt; //正确,引用及邦定的值都是常量
  4. rConstInt = 5; //错误,不能改变引用所指向的对象

允许为一个常量引用邦定一个非常量对象、字面值,甚至是表达式;引用的类型与引用所指向的类型必须一致。

  1. int i = 5;
  2. int& rInt = i; //正确,int的引用
  3. const int constInt = 10;
  4. const int& rConstInt = constInt; //正确,引用及邦定的值都是常量
  5. const int& rConstInt2 = rInt; //正确,用rInt邦定的对象进行赋值
  6. rInt = 30; //这时,rConstInt2、rInt、i的值都为30
  7. //rConstInt2 = 30; //错误,rConstInt2是常量引用,rConstInt2本身不能改变所指向的对象
  8. int i2 = 15;
  9. const int& rConstInt3 = i2; //正确,用非常量的对象为其赋值
  10. const int& rConstInt4 = i + i2; //正确,用表达式为其赋值,值为45
  11. i = 20; //此时i=20, rInt = 20, rConstInt4 = 45,说明rConstInt4邦定的是i + i2的临时变量
  12. const int& rConstInt5 = 50; //正解,用一个常量值为其赋值

const T*&与T *const&

指向常量对象的指针的引用,这可以分两步来理解:1.const T*是指向常量的指针;2.const T*&指向常量的指针的引用。

  1. const int nConstValue = 1; //常量对象
  2. const int nConstValue2 = 2; //常量对象
  3. const int* pConstValue = &nConstValue; //指向常量对象的指针
  4. const int* pConstValue2 = &nConstValue2; //指向常量对象的指针
  5. const int*& rpConstValue = pConstValue; //指向常量对象的指针的引用
  6. //*rpConstValue = 10; //错误,rpConstValue指向的是常量对象,常量对象的值不可改变
  7. rpConstValue = pConstValue2; //正确,此时pConstValue的值等于pConstValue2
  8. //指向常量对象的指针本身是对象,引用可以改变邦定对象的值
  9. int nValue = 5;
  10. int nValue2 = 10;
  11. int *const constPoint = &nValue; //常量指针
  12. int *const constPoint2 = &nValue2; //常量指针
  13. int *const &rpConstPoint = constPoint; //对常量指针的引用,邦定constPoint
  14. //rpConstPoint = constPoint2; //错误,constPoint是常量指针,指针本身的值不可改变
  15. *rpConstPoint = 20; //正确,指针指向的对象可以改变

在函数中的应用

我们直接从需求出来,假设有这样一个数据结构:

  1. typedef struct __Data
  2. {
  3. int value;
  4. public:
  5. __Data()
  6. :value(0){}
  7. }Data;

1.希望传入一个对象,又不想让函数体修改这个对象。

方式<1>

  1. void Dealwith(const Data& data)
  2. {
  3. cout << data.value << endl;
  4. //data.value = 5; //错误,data是常量引用,不能改变其邦定的对象
  5. }

这种方式还有一个好处是只有在调用函数的时候会邦定对象,传递的是对象的引用,而不是对象,减少函数调用时对象赋值的花销。

方式<2>

  1. void Dealwith(const Data* pData)
  2. {
  3. cout << pData->value << endl;
  4. //pData->value = 5; //错误,pData是指向常量对象的指针,不能改变其指向的对象
  5. }

这种方式与void Dealwith(const Data& data)的功能相同

方式<3>

  1. Data g_data(20);
  2. void Dealwith(const Data*& pData)
  3. {
  4. cout << pData->value << endl;
  5. //pData->value = 5; //错误,pData邦定的是指向常量对象的指针,常量对象的指针不能改变其指向的对象
  6. pData = &g_data; //正确,pData是[指向常量对象的指针]的引用,引用可改变其邦定的对象
  7. }

调用如下:

  1. Data d(10);
  2. const Data* pData = &d;
  3. Dealwith(pData);
  4. cout << pData->value << endl; //此时pData->value为20,d.value还是10

这种方式函数未改变传入的对象的值,但可以返回另外一个对象的指针。注意返回的指针必须指向全局的对象,如果返回函数内定义的对象,退出函数作用域后,其指针将无效,这是非常危险的;如果Dealwith是成员函数,也可以返回指向成员的指针。

2.在类中的使用,返回一个类的成员,但不希望调用方修改这个成员。

方式<1>

  1. class MyData
  2. {
  3. public :
  4. MyData(std::string name, Data data)
  5. {
  6. m_name = name;
  7. m_data = data;
  8. }
  9. const Data* GetData()
  10. {
  11. return &m_data;
  12. }
  13. private:
  14. std::string m_name;
  15. Data m_data;
  16. };

调用如下:

  1. MyData mydata("", Data(100));
  2. const Data* pData = mydata.GetData();
  3. cout << pData->value << endl; //pData->value = 100
  4. //pData->value = 50; //错误,pData是指向常量对象的指向,不能改变其指向对象的值

方式<2>

有人可能会问GetData也可以写成这样:

  1. const Data& GetData()
  2. {
  3. return m_data;
  4. }

这样的话,调用方常常容易写成这样:

  1. MyData mydata("", Data(100));
  2. Data data = mydata.GetData(); //这会有个赋值的过程,会把mydata.m_data赋给data
  3. cout << data.value << endl; //data.value = 100
  4. data.value = 50; //正确,data.value=50,但mydata.m_data.value还是100

这样调用时会有一个结果赋值的过程,如果Data是一个复杂的类,会有较大的开销,其效果与下面这种方式是一样的:

  1. Data GetData()
  2. {
  3. return m_data;
  4. }

当然,如果调用方这样使用是正确的:

  1. const Data& GetData()
  2. {
  3. return m_data;
  4. }
  1. MyData mydata("", Data(100));
  2. const Data& data = mydata.GetData(); //这会有个赋值的过程,会把mydata.m_data赋给data
  3. cout << data.value << endl; //data.value = 100
  4. //data.value = 50; //错误,data是一个对常量的引用,不能改变其邦定的对象

这对调用方的技术能力要求比较高,如果你是设计方,一定要尽量使接口简单易用。

方式<3>

如果你要传入一个Data进行一些处理,处理完后返回类的成员m_data,可如下实现:

  1. void DoSomething(const Data*& pData)
  2. {
  3. if (pData != NULL)
  4. {
  5. // doto: 这里实现你要处理的功能
  6. }
  7. pData = &m_data;
  8. }

const T、const T*、T *const、const T&、const T*& 的区别的更多相关文章

  1. C++中的const成员函数(函数声明后加const,或称常量成员函数)用法详解

    http://blog.csdn.net/gmstart/article/details/7046140 在C++的类定义里面,可以看到类似下面的定义: 01 class List { 02 priv ...

  2. C++ —— 非类中使用const定义常量的初始化,以及#define和typedef的区别

    总结一下在非类中使用const关键字定义常量时的初始化问题,亲测VS2015.顺便记录#define宏和typedef的区别. 1 首先对const声明的常量的初始化做简单小结: , w2 = , w ...

  3. 常量指针(const X*)和指针常量(X* const)

    const X* 类型的指针(指向常量的指针),此指针的地址是一个变量,是可以修改的:但其所指向的内容是常量,是不可以修改的. 例如: 1: char name[5] = "lisi&quo ...

  4. 为什么const对象只能调用const成员函数,而不能调用非const成员函数?

    在c++中,我们可以用const来定义一个const对象,const对象是不可以调用类中的非const成员函数,这是为什么呢?下面是我总结的一些原理. 假设有一个类,名字为test代码如下: clas ...

  5. CTC安装及其错误解决办法:binding.cpp:92:49: error: cannot convert ‘THCudaTensor*’ to ‘const THFloatTensor*’ for argument ‘1’ to ‘int64_t THFloatTensor_size(const THFloatTensor*, int)’

    CTC安装: 1. 在终端执行命令:git clone https://github.com/SeanNaren/warp-c) (效果如下图,大家不用管我前面括号的内容,那是我打开的虚拟环境) 2. ...

  6. 预处理、const、static与sizeof-内联函数与宏有什么区别

    1:二者的区别如下: (1)内联函数在编译时展开,宏在预编译时展开. (2)在编译的时候,内联函数可以直接被镶嵌到目标代码中,而宏只是一个简单的文本替换. (3)内联函数可以完成诸如类型检测.语句是否 ...

  7. 预处理、const、static与sizeof-static全局变量与普通的全局变量有什么区别

    1:全局变量的说明之前再加上static就构成了静态的全局变量.全局变量本身就是静态存储方式,静态全局变量当然也是静态存储方式.这两者在存储方式上并无不同.这两者的区别在于,非静态全局变量的作用域是整 ...

  8. const,static,extern 简介

    const,static,extern 简介 一.const与宏的区别: const简介:之前常用的字符串常量,一般是抽成宏,但是苹果不推荐我们抽成宏,推荐我们使用const常量. 执行时刻:宏是预编 ...

  9. C++中的const

    一,C++中const的基本知识 1.C++中const的基本概念 1.const是定义常量的关键字,表示只读,不可以修改. 2.const在定义常量的时候必须要初始化,否则报错,因为常量无法修改,只 ...

  10. const extern static 终极指南

    const extern static 终极指南 不管是从事哪种语言的开发工作,const extern static 这三个关键字的用法和原理都是我们必须明白的.本文将对此做出非常详细的讲解. co ...

随机推荐

  1. 02 Django模型

    ORM 的作用 ORM 作用示意图 ORM 框架的功能 建立模型类和表之间的对应关系,允许通过面向对象的方式来操作数据库 根据设计的模型类生成数据库中的表格. 通过方便的配置就可以进行数据库的切换 数 ...

  2. nw335 debian sid x86-64 -- 1 需求介绍

    自己的台式机上面有有线网卡,路由器在客厅,托一条长长的线,关门也不方便.没有选择PCI无线网卡,没有选择nano类型的迷你网卡.买了nw335,带一条5DB天线,信号应该会好点.于是,开始了在debi ...

  3. 浅谈Http长连接和Keep-Alive以及Tcp的Keepalive

    原文:https://blog.csdn.net/weixin_37672169/article/details/80283935 Keep-Alive模式: 我们知道Http协议采用“请求-应答”模 ...

  4. 精通 JavaScript中的正则表达式

    精通 JS正则表达式 (精通?标题党 ) 正则表达式可以: •测试字符串的某个模式.例如,可以对一个输入字符串进行测试,看在该字符串是否存在一个电话号码模式或一个信用卡号码模式.这称为数据有效性验证  ...

  5. Java学习笔记3---unable to launch

    环境配置好后,在eclipse下编写HelloWorld程序: ①创建新工程 ②创建.java文件,命名为HelloWorld ③在源文件中添加main方法,代码如下: public void mai ...

  6. 转:GridView中RowDataBound的取值

    GridView是ASP.NET中功能强大的数据显示控件,它的RowDataBound事件为我们提供了方便的控制行.列数据的途径. 要获取当前行的某个数据列,我在实践中总结有如下几种方法: 1. Ce ...

  7. Leetcode7--->Reverse Integer(逆转整数)

    题目: 给定一个整数,求将该整数逆转之后的值: 举例: Example1: x = 123, return 321Example2: x = -123, return -321 解题思路: 在这里只用 ...

  8. NoClassDefFoundError: javax/servlet/jsp/jstl/core/Config的问题

    故障问题: 使用springMVC3.05 ,tomcat服务器进行开发, Spring配置正确,console有输出,但是url打开时不能出现页面,提示错误信息为:NoClassDefFoundEr ...

  9. [转]廖雪峰:datetime用法

    datetime是Python处理日期和时间的标准库. 获取当前日期和时间 我们先看如何获取当前日期和时间: >>> from datetime import datetime &g ...

  10. hibernate与struts框架实现增删改查

    这里配置hibernate与struts不再过多赘述,配置搭建前文已经详细讲解,配置如下: hibernate.hbm.xml配置: <?xml version="1.0" ...