const T、const T*、T *const、const T&、const T*& 的区别

最新推荐文章于 2023-08-17 23:47:11 发布
最新推荐文章于 2023-08-17 23:47:11 发布
阅读量171 收藏 1
点赞数
分类专栏： stl源码

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

const T

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

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

const T*

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

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

const int* 与int* const的区别

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

int nValue = 10;
int* const p = &nValue;
int *const p2 = &nValue;
const int* 指针指向的对象不可以改变，但指针本身的值可以改变；int* const 指针本身的值不可改变，但其指向的对象可以改变。
int nValue1 = 10;
int nValue2 = 20;
int* const constPoint = &nValue1;
//constPoint = & nValue2;           //错误，不能改变constPoint本身的值
*constPoint = 40;                   //正确，可以改变constPoint所指向的对象，此时nValue1 = 40


const int nConstValue1 = 5;
const int nConstValue2 = 15;
const int* pPoint = &nConstValue1;
//*pPoint  = 55;                    //错误，不能改变pPoint所指向对象的值
pPoint = &nConstValue2;             //正确，可以改变pPoint指针本身的值，此时pPoint邦定的是nConstValue2对象，即pPoint为nConstValue2的地址
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

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

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

const T&

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

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

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

int i = 5;
int& rInt = i;                      //正确，int的引用
const int constInt = 10;
const int& rConstInt = constInt;    //正确，引用及邦定的值都是常量
const int& rConstInt2 = rInt;       //正确，用rInt邦定的对象进行赋值
rInt = 30;                          //这时，rConstInt2、rInt、i的值都为30
//rConstInt2 = 30;                  //错误，rConstInt2是常量引用，rConstInt2本身不能改变所指向的对象


int i2 = 15;
const int& rConstInt3 = i2;         //正确，用非常量的对象为其赋值
const int& rConstInt4 = i + i2;     //正确，用表达式为其赋值,值为45
i = 20;                             //此时i=20, rInt = 20, rConstInt4 = 45,说明rConstInt4邦定的是i + i2的临时变量
const int& rConstInt5 = 50;         //正解，用一个常量值为其赋值
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

const T*&与T *const&

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

const int nConstValue = 1;                      //常量对象
const int nConstValue2 = 2;                     //常量对象
const int* pConstValue = &nConstValue;          //指向常量对象的指针
const int* pConstValue2 = &nConstValue2;        //指向常量对象的指针
const int*& rpConstValue = pConstValue;         //指向常量对象的指针的引用
//*rpConstValue = 10;                           //错误，rpConstValue指向的是常量对象，常量对象的值不可改变
rpConstValue = pConstValue2;                    //正确，此时pConstValue的值等于pConstValue2
//指向常量对象的指针本身是对象，引用可以改变邦定对象的值

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

在函数中的应用

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

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

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

方式<1>

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

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

方式<2>

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

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

方式<3>

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

调用如下：

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

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

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

方式<1>

class MyData
{
public :
    MyData(std::string name, Data data)
    {
        m_name = name;
        m_data = data;
    }

    const Data* GetData()
    {
        return &m_data;
    }


private:
    std::string m_name;
    Data m_data;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

调用如下：

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

方式<2>

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

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

这样的话，调用方常常容易写成这样：

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

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

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

当然，如果调用方这样使用是正确的：

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

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

方式<3>

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

void DoSomething(const Data*& pData)
{
    if (pData != NULL)
    {
        // doto: 这里实现你要处理的功能
    }
    pData = &m_data;
}
柒_梦
关注
专栏目录
C++中const T*&的含义及编程实例
ByteProwl的博客
09-28 169
在C++中，const T*& 是一个指向常量指针的引用。在本文中，我将详细解释 const T*& 的含义，并提供一个编程示例来说明它的用法。综合起来，const T*& 表示一个引用，它引用一个指向常量对象的指针。在这种情况下，它修饰的是指针，表示指针所指向的内容是不可修改的。它允许我们通过指向常量的指针的引用来间接修改对象的值，但不允许直接修改指针的指向。的指向，但由于它是一个指向常量的指针，所以这个操作是非法的。函数后，虽然指针的指向没有改变，但通过指针间接修改的对象的值确实发生了变化。
C++：const int*& 和 int* const& 以及 const int* const&
m0_37433111的博客
07-30 895
2020年7月30日 周四 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录大型翻车现场问题思考情况1. 指针的引用情况2. 指针常量的引用情况3. 常量指针的引用情况4. 指向常量的常量指针的引用参考文献 大型翻车现场 void print(const int*& a) { cout << *a << endl; } int main() { int a = 10; int* p = &a; print(p); } 翻车原因是我想传入一个指针，
const使用实例
Scarlett的博客
06-12 195
#include<iostream> using namespace std; class Nick { public: int getA() { //m_a = 63; return m_a; } private: int m_a = 37; }; void func(const Nick & nick) { nick.getA(); cout << "此时不可以使用const" << endl; } void test() {
C++基础——const T、const T*、T const、const T&、const T&
weixin_33460831的博客
09-28 4816
const T、const T*、T const、const T&、const T& 的区别 T是指一种数据类型，可以是基本数据类型，也可以是自己定义的类型，单独的一个const是指一个常量。 const T 定义一个常量，声明的同时必须进行初始化。一旦声明，这个值也将不能被改变。 ##const T* 指向常量的指针，不能改变所指向对象的值。 1 const int i = 5; 2 const int i2 = 10; 3 const int* pInt = &i;
c++ const T * const name, T * const name , const T * name的区别
qq_59398646的博客
08-17 122
不可以更改指针值，也不可通过该指针修改对应的T对象。不可以更改指针值 , 但可通过该指针修改对应的T对象。可以更改指针值 , 但不可通过该指针修改对应的T对象。我们都知道这个是 T类型的一个名为name的指针。可修改指针值，可通过指针值修改对应的T对象。
深入const int *p与int * const p的区别详解(常量指针与指向常量的指针)
01-20
对于指针和常量，有以下三种形式都是正确的： 代码如下:const char * myPtr = &char_A;//指向常量的指针char * const myPtr = &char_A;//常量的指针const char * const myPtr = &char_A;//指向常量的常量指针下面...
深入理解c++中char*与wchar_t*与string以及wstring之间的相互转换
01-01
代码如下: #ifndef USE_H_ #define USE_H_ #include  #include  #include  using namespace std; class CUser { public: CUser();... char* WcharToChar(const wchar_t* wp); char* StringToChar
const T vs. T const
09-27
const T vs. T const 是在C语言及C++语言编程中非常重要的一个知识点，主要涉及const关键字如何与数据类型结合使用，以及它对变量或函数的限制。本文将详细探讨const关键字的用法，以及const在数据类型声明中的不同...
三个例子让你透彻理解const （C/C++）
Season@HangZhou 专栏
09-16 5581
三个例子让你透彻理解const （C/C++） 一、指向  const  对象的指针 指向  const  对象的指针，指的是指针指向的内容是const的，不可修改，但指针本身是可以修改的。 例1： char acConst[] = "const"; const char *pcConst = acConst; *pcConst = ‘C’;         /* Error，像这样修改pcConst指向内容的做法是不允许的 */
const应用实例
kaixinbingju的专栏
06-06 570
const int a=100; int const b=100; int* m = &a; //出错,常量只能用常指针 int c= 1;const int*pc = &c;//常指针可指向常量 const int* pa = &a; //指针指向的内容为常量(就是a的值不变) int const *a = &b; //指针指向的内容为常量(就是b的值不变)*p=3//err
int const *, const int *, int * const区别
啊啦啦的博客
03-13 732
碰到了以下代码： bool operator()(const T* const abc, T* residual ) const对const的用法，一直不解。参考：http://blog.csdn.net/skywalker_leo/article/details/48627933              http://blog.csdn.net/hsd2012/article/detai...
实例理解const用法
huangshanchun的专栏
04-11 904
笔试题，面试题经常考到const ，下面就通过实例对const进行总结。 首先要理解常量指针和指针常量的区别，* （指针）和 const（常量） 谁在前先读谁。 const int *p //常量指针 int const *p //常量指针 int * const p //指针常量另外const后面 修饰谁，说明它不能改变，const int *p  const 后面是int *p 说明初始化
c++中const的实例 及变量命名相关实例
qq_45958446的博客
02-07 537
#include<iostream> int main() { const unsigned short ADD_SUBTRACT = 32; const double RATIO = 9.0 / 5.0; double tempin, temout; char typein, typeout; std::cout << "请以【xx.x c】或【xx.x f】格...
const经典例子小结
脚踏实地，用心编写出客户满意的代码，为公司创造出应有的价值。
05-26 1257
在看这个例子之前，可以先看看：详解C和C++中的const和const和static变量的存放位置这样将会对const有非常全面的了解和认识： 下面我们将通过下面的例子看看const的一些非常不易发觉的错误： #include using namespace std; class String { public: friend ostream& operator<<(ostream& os
const*与*const以及const*与*作为函数参数的差别
shi_xin的专栏
04-27 6203
1.理解const*与*const 假设有一个ptr指针，它保存变量vbl的地址。 Type* ptr = &vbl; 当使用指针的时候就涉及到两个对象：指针本身以及本身所指的对象。这就意味着const有三个层级的保护。 1.1. 确保ptr指向唯一的内存 有两种写法 Type* const ptr = &vbl; Type* const ptr(&vbl); 1.2. 确保不能通过ptr改变vbl的值 const Type* ptr = &vbl;
数据结构--(ElemType *&T)代表的意义
墨上烟雨
04-26 5789
1、前言 ElemType表示抽象数据类型。首先看个例子： 函数1： void swap1 (int x, int y) { int temp; temp = x; x = y; y = temp; } 函数2： void swap2 (int &x, int &y) { int temp; temp = x; x = y;...
const*和*const
我与我周旋久，宁作我
03-26 1009
参考。
T const* 和const T*
最新发布
10-16
T const* 和 const T* 都表示指向常量的指针，但它们的含义略有不同。T const* 表示指向 T 类型常量的指针，也就是说，指针所指向的对象是常量，不能通过该指针修改对象的值；而 const T* 表示指向指向常量的 T 类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值