C++威力强大的助手 --- const

9ilk 2024-08-17 08:35:01 阅读 68

 Welcome to 9ilk's Code World

       

(๑•́ ₃ •̀๑) 个人主页:        9ilk

(๑•́ ₃ •̀๑) 文章专栏:     C++之旅 


const是个奇妙且非比寻常的东西,博主从《Effective C++》一书中认识到关于const更深层次的理解,写此博客进行巩固。


🏠 const的作用

const可以指定一个“不该被改动的对象”,编译器会强制实施这个约束const可修饰类外的作用域(全局域,命名空间域等)中的常量,文件,函数或静态常量等const可修饰类内的static和non-static成员

🏠 const修饰指针和迭代器

📌 const修饰指针

const修饰指针无外乎三种:

<code>char greet[] = "hello";

char* pg = greet;

//指针指向内容不可变

const char * pg = greet;

char const * pg = greet;

//指针本身不可变

char * const pg = greet;

//指针本身和指针执行内容都不可变

const char * const pg = greet;

总结:

1.const出现在*号左边时,表示指针指向的内容是常量。

2.const出现在*号右边时,表示指针本身是常量。

3.const出现在*号左右边时,表示指针本身和指针指向的内容都是常量

📌 const与迭代器

声明迭代器为const

我们把迭代器看作一个类型,它的作用就像个T*的指针,当声明迭代器为const时,类比const int是int这个int类型变量不可能,此时说明迭代器类型变量是不能变的,也就是类比修饰一个T* const的指针。

vector<int> v = {4,1,2,9,10};

const vector<int>::iterator it = v.begin();

it++; //错误,迭代器类型对象不可变

(*it)++; //正确,指向内容可以变

我们也可以利用下面代码进行验证,当生成解决方案时会对其进行报错:

template<class T>

void fun()

{

const T x;

cout << typeid(x).name() << endl;

x++;

}

int main()

{

//op o;

//cout << o[1];

vector<int> v = {3,5};

vector<int>::iterator it = v.begin();;

fun<vector<int>::iterator>();

return 0;

}

const迭代器

  如果你希望迭代器所指的东西不可被改动(也就是类似希望模拟个const T*指针),你需要的是const_iterator.

std::vector<int> v = {1,5,2,3,4};

std::vector<int>::const_iterator it = v.begin();

*it = 10; //错误,此时是const迭代器,指向内容不可改变。

it++; //此时不是声明迭代器为const,本身迭代器可以改变。

注:我们平时所说的const迭代器就是const_iterator,请注意区分与前者声明迭代器为const进行区分。

🏠 const与函数

📌 const与函数参数

建议:如果对于局部对象或对于函数参数没有改动的需求时,建议将他们声明为const,此时可以避免不必要的麻烦。比如:将“==”键值的“=”。

📌const与函数返回值

函数返回一个常量,往往可以降低因客户错误而造成的意外,而且具有安全性和高效性

    假设有这样的一个有理数类:

class Rational;

const Rational operator*(const Rational& r1,const Rational& r2)

{//...};

Rational a,b,c;

...

(a*b) = c;

由于是有理数类,客户可能会将乘积再做一次赋值,此时将operator*的返回值类型设置为const就可以避免这样无意义的赋值动作。

🏠 const与成员函数

📌 const成员函数的好处

1. const成员函数易使class接口比较容易被理解,清楚知道哪个函数可以改动对象内容而哪个函数不行。

2. 有了const成员函数,const对象就能被“操作”,因为const对象只能调用const成员函数;能操作const对象,就能利用传引用(const 类类型 &)提高效率。

const成员函数与普通成员函数的区别

我们知道普通成员函数参数都有一个隐含的this指针,是不能修改的,也就是类 * const this;而const成员函数的this指针,类型是const 类 * const this,也就是说此时对象的内容也不能被修改

class Date

{

public:

//...

const char& operator[](size_t position)const //operator[]for const对象

{

return _date[position];

}

char& operator[](size_t position) //operator[]for non-const 对象

{

return _date[position];

}

private:

string _date;

};

int main()

{

Date d1("2024/08/04");

cout << d1[0] << endl; //调用的是non-const版本

const Date d2("2024/08/04")

cout << d2[0]; //调用的是const版本

return 0;

}

说明

1. 两成员函数如果只是常量性不同,也是可以被重载的。因为两个版本隐含的this类型不同,同时

返回值类型也跟着不同。

2.const对象d2的对象指针为const Date* ,更匹配const版本的operator[],因此调用const版本;

而非const对象d1的对象指针为Date*,更匹配非const版本。

📌 bitwise const VS logical const

        到这里,我们思考一下什么成员函数如果是const意味着什么?目前有以下两个流行概念需要向大家介绍一下:

bitwise constness

这种观点的人认为,成员函数只有在不改变对象之任何成员变量时才可以说是const,也就是说不改变对象内的任何一个bit。这种论点的好处是很容易找到违反点:只需找到对成员变量的赋值动作即可。

这种观点正是C++对常量性的定义,因此const成员函数不可以更改对象内任何非静态成员变量。

如果只有指针(而非所指向内容)隶属于对象,(比如有这样的一个类,将数据存储于char*而不是string),不修改char*而修改char*指向内容,此时编译器是认为是bitwise constness的,可以正常通过编译。

class Block

{

public:

Block( char* ch )

:pText(ch)

{}

char& operator[](size_t position)const

{

return pText[position];

}

private:

char* pText;

};

int main()

{

char arr[] = "hello";

char* ch = arr;

const Block cctb(ch);

char* pc = &cctb[0];

*pc = 's';

return 0;

}

此时可以通过这个漏洞修改成员变量指针指向的内容而不违法const

(注:如果成员变量是string,由于operator[]需要访问pText成员变量,并且你需要保证Block对象的状态不被修改,所以pTextoperator[]调用也必须是const的,因此不会出现上述漏洞。)

这种情况导出所谓的logical constness.

logical constness

class BigArray

{

vector<int> v;

int accessCounter;

public:

int getItem(int index) const

{

accessCounter++;

return v[index];

}

};

此类提供了一个 getItem 接口,除此之外,为了计算外部访问数组的次数,该类还设置了一个计数器 accessCounter ,可以看到用户每次调用 getItem 接口,accessCounter 就会自增,很明显,这里的成员 v 是核心成员,而 accessCounter 是非核心成员

我们希望接口 getItem 不会修改核心成员,而不考虑非核心成员是否被修改,此时 getItem 所具备的 const 特性就被称为 logic constness

问题:在这个函数中虽然accesCounter修改对对象而言可以被接受,但是编译器只认bitwise constness不允许修改怎么办?

mutable

mutable是C++中一个与const相关的摆动场,他可以释放掉non-static成员变量的bitwise constness约束。

class BigArray {

vector<int> v;

mutable int accessCounter; //像这样的成员变量可能总是会被更改。

public:

int getItem(int index) const {

accessCounter++;

return v[index];

}

};

总结:当const成员函数接受某些修改之后不改变成员函数逻辑状态的成员变量时,这时可以使用mutable来释放const约束。但注意mutable可能会违反对象的不变性,需要慎用。

📌 在const和non-const成员函数中避免重复

   对于“bitwise constness”非我所欲的问题,mutable是个解决办法,但并不能解决所有的难题。假设有个类,类内的operator[ ]不单只是返回一个引用指向某字符,也执行边界检验,志记访问信息,甚至可能进行数据完善性检验等...把所有这些放进const版本和非const版本的operator[ 里的问题是会导致代码膨胀以及大量代码重复:

class Text

{

public:

char& operator[](size_t pos)

{

//... 边界检验

//... 志记数据访问

//... 检验数据完整性

return text[pos];

}

const char& operator[](size_t pos)const

{

//... 边界检验

//... 志记数据访问

//... 检验数据完整性

return text[pos];

}

private:

string text;

};

避免代码重复的安全做法:

class Text

{

public:

const char& operator[](size_t pos)

{

//... 边界检验

//... 志记数据访问

//... 检验数据完整性

return text[pos];

}

char& operator[](size_t pos)const

{

return (char&)(((const Text &)(*this))[pos]);

}

private:

string text;

};

说明

1. 这份代码进行了两次转型实现了了“运用const成员函数实现其non-const兄弟”,避免了代码重

复。

2.第一次转型将(*this)也就是这个对象类型强转为const Text&是为了匹配const版本调用const版

本的operator[ ],否则会陷入无限调用非const版本;第二次转型则是用来从const operator[ ]的

返回值中移除const,这其中并未有权限放大的问题,强转是可行的。

3. 反向调用也就是“令const版本调用non-const版本以避免代码重复”是一件错误的事,因为non-

const并未承诺绝不改变其对象的逻辑状态,因此这种做法可能使得对象被改动,当然编译器也不

允许const调用非const,也是一种权限的放大。


总结:

1. 将某些东西声明为const可帮助编译器侦测出错误用法,比如错误的赋值行为使得不必要的对象改动。

2.const可施加于任何作用域的对象,函数参数,函数返回值,成员函数。

3.如果在const成员函数内想改变非核心成员变量以达目的,可利用mutable解除const约束。

4.当const与非const成员函数实质有着等价的实现且代码有大量重复时,可考虑复用const版本以实现非const版本。



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。