devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

const，static深度总结——c++穿透式分析

作者：2023面试高手 | 2024-04-17 05:54:07

赞

踩

const，static深度总结——c++穿透式分析

         前言；c++类和对象的知识点中除了几种默认函数， 比较重要的还有使用const和static修饰成员相关知识点。const在c++中特性很简单。 但是在使用中， 比较容易疏忽大意出现问题。 static特性也很简单， 但是比起const来要直接的多。 在使用中只要熟练语法以及底层原理。就不容易出错。

         本节内容主要是对其进行详细的解析。相信本节内容可以让你对这两种语法有一个更深层次的认识。（注：如果想要进阶const的使用 以及 对类和对象的认识， 建议自己实现vector的stl。 list也可以， 但是list的stl的迭代器比较复杂， 需要对类和对象有一定的理解。）

const

在讨论const修饰类的成员之前。 我们先需要知道const的用法。

c++的const 与c语言const的区别

        c++中的const比c语言中的const更加严格。在c语言中， 我们使用const定义一个常量后, 这个常量并不是真正意义上的常量，它还保存在栈区。  我们如果定义一个指向这个空间的指针。 那么我们还是可以对这块空间进行修改的。

        但是在c++中。 如果我们使用const定义了一个常量。 那么我们如果再使用一个指针变量保存这块内存的地址。 会报错。编译不通过。 这是因为使用const修饰的变量相当于放在了常量区。（这里是相当于放在了常量区。事实上，当我们进行源代码编译的时候， 变量被编译成对应的常量， 这个常量保存在哪个区， 取决于你在哪里定义的变量。 如果是在栈区， 那就是被存储在了栈区。 所以使用const修饰变量不会改变该数据存储的位置。这个位置是在编译时期就决定的， 不是在运行时期决定的。）我们想要访问这块空间只能通过常量指针来进行访问（只读）。

const的权限平移，放大， 缩小问题

        在c++中， 权限只能平移或者缩小， 不能放大。  如图：

  1. int main()
  2. {
  3.     const int a = 10;
  4.     int& b = a;//不可以， const修饰a，让a成为一个常量，数据放在了常量区，只读。 int& b是一个可读可写的类型。 相当于权限放大。  
  5.     int* Pa = &a;//不可以， a是一个常量，数据放在了常量区。a的内容不可被修改， 只读。 使用指针找到这块空间后，也不能修改。 但是pa是一个可读可写的类型。 相当于权限的放大。
  6.     const int* pa = &a;//可以， 这里pa使用const修饰， 变成只读。 相当于权限的平移。 
  7.   
  8.     int c = 10;
  9. //下面这两个都可以， c是变量， 可读可写。而d别名是只读的。 pc也是只读的。都相当于权限的缩小。 
  10.     const int& d = c;
  11.     const int* pc = &c;
  12.  
  13.     return 0
  14. }

        看这张图中的红框框， 红框框是使用const修饰的一个int类型的变量。 然后使用了一个int类型的引用b作为a的别名。

         这么写是错误的。 a被const修饰， 具有常性，只读。 而b是一个不加const修饰的引用别名， 只是一个单纯的变量， 可读可写。 想一想，如果这里是对的， a本身都不可以改变自己， 那么如果通过b这个别名可以来对a进行修改， 这不就乱了吗？所以， c++设定了权限只能平移和缩小， 不能放大。

同样的， 我们看一下下面的几个示例。

      1.首先， 我们来看一下红框框和绿框框， 这个对不对呢？

答案是对的， 因为a被const修饰， 具有常性。 但是pa也被const在int*前面修饰， 这里相当于指针指向的空间不可被修改， 称为常量指针（常量指针是指向常量的指针， 另一个叫做指针常量， 是不能改变指向的一个指针常量）。所以是权限的平移， 可以被编译器通过。

        2.然后， 我们来看一看蓝框框和黄框框是不是对的呢？

答案是对的， c是一个int类型的变量。 而d作为c的别名， pc作为c的指针。 都是被const修饰， 都具有常性。 权限缩小。 编译器可以通过。

const 修饰类中的成员

        在C++中，const关键字可以用来修饰类的成员函数。一个被const修饰的成员函数被称为常量成员函数，它不会修改类的内部状态。

   常量成员函数的声明和定义格式如下：

        常量成员函数可以在常对象上调用，它们也可以在非常对象上调用。但是，常量对象上只能调用常量成员函数，而非常对象上可以调用常量成员函数和非常量成员函数。因为常对象是一个只读的类型。而且类的实例化对象在调用成员函数的时候会把自己的this指针传送过去。 而常量成员函数中的const本质上是修饰的成员this指针。所以常对象在调用常量成员函数的时候， 地址给const修饰的this，是权限的平移。 可以编译通过。 但是如果常对象调用非常量成员函数， this指针是可读可写的， 属于权限的放大。编译不能通过。

        const修饰成员函数， 本质上就是修饰的成员函数中的this指针。 让this指针从可读可写变为只读的，也就是常量指针（注意区别常量指针和指针常量的区别）。 

const修饰返回值和修饰成员函数

        const修饰返回值和const修饰成员函数是不同的。 但是我们通过是否使用const修饰成员函数来区分一个成员函数的返回值是否是const修饰的常量。 就比如迭代器的实现， stl中的迭代器一般都有如下两种类型:

  1. ​
  2. iterator；//迭代器
  3. const_iterator；//只读迭代器
  4.  
  5. ​

iterator和const_iterator的实现其实就用到了const修饰， 来区分两种迭代器重载。

如下是list中迭代器的实现部分代码：

        （只需关注const修饰成员函数来形成重载这种思想。 list迭代器的具体实现不需要关注，后续会有专门一节来实现list的stl）

  1. ///迭代器
  2. 		iterator begin() 
  3. 		{
  4. 			return iterator(_head->_next);
  5. 		}
  6.  
  7. 		iterator end() 
  8.     	{
  9. 			return iterator(_head);
  10. 		}
  11.  
  12. ///只读迭代器。 如果没有这个const修饰， 他和上面的迭代器构不成重载
  13. 		const_iterator begin() const
  14. 		{
  15. 			return const_iterator(_head->_next);
  16. 		}
  17.  
  18. 		const_iterator end() const
  19. 		{
  20. 			return const_iterator(_head);
  21. 		}

注意红框框。

const比较容易出现问题的地方

如图是vector的标准库中的size（）和capacity（）的模拟实现

  1. ​
  2.  
  3. public:
  4.  
  5.    //………………………………public中的其他成员
  6. ​
  7. 		size_t size() const
  8. 		{
  9. 			return _finish - _start;
  10. 		}
  11.  
  12. 		size_t capacity() const
  13. 		{
  14. 		    return _end_of_storage - _start;
  15. 	    }
  16.  
  17. ​   //……………………………………public中的其他成员
  18.  
  19. private:
  20.         T* _start;
  21.         T* _finish;
  22.         T* _end_of_storage;
  23.  
  24. ​

这两个成员函数的实现必须使用const修饰。 为什么呢？因为size()和capacity是只读的。 他们不涉及成员变量的修改。  注意， 这里很重要。 也有点难以理解。 

我们说如果一个对象是常量。 那么这个常量对象只能调用const修饰的成员函数， 这里没问题吧。

然后， 假如， size（）和capacity（）没有被const修饰， 那么假如我们想计算常量对象的大小时， 是不是就无法调用这两个函数。 所以这显然是不对的。而且， 这个常量对象， 我们是不是一定不会去修改它？所以也就不需要调用那些涉及修改数值的函数。 那么， 那些涉及修改数值的函数， 就不需要使用const修饰。 因为我们不会让const对象去调用他们。

但是， 如果一些不涉及修改数值的函数， 我们在使用const对象时， 是不是可能去调用这种不修改数值的函数。 这些函数如果没有使用const修饰的话。 const对象就调不动他们。 这不符合我们的需求。所以我们必须给不修改数值的成员函数加const修饰。

由以上分析， 我在这里总结一个结论：设计修改数值的成员函数， 按照需要看是否加const修饰成员函数。 不涉及修改数值的成员函数， 一定要加const修饰成员函数。

这个结论正在随着我代码量的提高逐渐深刻。 当涉及容器的套娃时，可能会出现例外。 但是本人认为可以加深对于成员函数， 成员变量之间关系的理解。

---------------------------------------------------------------------------------------------------------------------------

2024年4月5日，今天新总结了一些信息：

  1. int re(int b)
  2. {
  3.     return b;
  4. }
  5.  
  6. int main()
  7. {
  8.     int b = 10;
  9.     int& a = re(b);//这里返回的是一个常量, 返回的值， 只要不带引用， 那么它的返回值， 就一定是一个常量值， 而这个常量值， 如果被引用接收， 就必须是一个const引用.
  10. }

如果是值返回， 并且使用引用接收， 注意， 我们一般不会直接进行这种操作。 但是当我们实现工程项目时， 可能会直接返回一个函数的返回值，就像这种情况：

 

所以， 如果要对值返回进行引用的接收， 要加const。

---------------------------------------------------------------------------------------------------------------------------

 static

static在c++中的作用

        static在c++用和在c语言中的应用场景类似。 都是用来修饰变量或者函数。 这里的变量或者函数包括类的成员变量和类的成员函数。

在全局作用域修饰变量或者函数

        static在全局作用域修饰变量或者函数时， 这个变量或者函数属于整个源文件。 但是不属于项目中的其他源文件。 其他源文件无法调用static在全局修饰的成员或者函数。 

在局部修饰变量或者函数

        在局部修饰变量的时候， static修饰的变量生命周期变长，局部作用域销毁后，这个变量不会销毁。 但是使用的范围不变。 这个变量仍然只能在局部使用。也就是说， static修饰的成员的作用域是当前作用域， 但是生命周期变成了整个程序的生命周期。 它在程序运行时创建， 在程序结束时销毁。 

static修饰类中成员

以上都是static修饰非类中的成员。

现在来看static修饰类中的成员。 

static修饰成员变量
static修饰成员变量的性质

static修饰的成员变量不是属于对象的。 是属于整个类的。 它同样符合上面的性质：作用域属于当前作用域，也就是类域。 生命周期是整个程序的周期。

static成员变量与普通成员变量的区别

static成员变量会在程序开始运行时就被创建出来。 而一般的成员变量是在对象实例化的时候被定义的。 所以成员变量可以属于一个对象， 但是static修饰的成员变量只能属于整个类域。

同时， 一般的成员函数是无法访问static修饰的成员变量的。 为什么？很简单。 这里涉及到了成员函数为什么可以访问成员变量的知识点。

看这一串代码。

  1. ​
  2. public:
  3.  
  4.         //………………………………public中的其他成员
  5.     	void operator=(const vector<T>& v) 
  6. 		{
  7. 			T* tmp = new T[v.size()];
  8. 			for (size_t i = 0; i < v.size(); i++) 
  9. 			{
  10. 				tmp[i] = v[i];
  11. 			}
  12. 			_start = tmp;
  13. 			_finish = _start + (v._finish - v._start);
  14. 			_end_of_storage = _start + v.capacity();
  15.  
  16.  
  17. 		}
  18.  
  19.         //…………………………public中的其他成员
  20.  
  21. private:
  22.         T* _start;
  23.         T* _finish;
  24.         T* _end_of_storage;
  25.  
  26. ​

 看绿框框和红框框。 绿框框中的_finish是调用成员函数的对象的成员变量。 它是this指针找到的。这里this指针隐藏了， 其实应该本质是this->_finish, 或者*this._finish.

 红框框中的_finish和_start是v这个对象找到的。 

我们可以把this指针和v比作一个采花许可证， 然后成员函数里面比作一个花园。然后成员变量就是花园里的一朵花。 只有我们在花园中， 而且我们有采花许可证的情况下。 我们才可以采到一朵花。

这里同样的也是这么一个问题。 只有我们在成员函数中， 或者说是类域中。 并且我们有this指针或者直接有一个有一个对象。 我们才可以访问thiis指针指向的变量或者对象本身的变量。 

但是，static不属于任何一个对象。 没有任何一个对象有他的指针。 他就无法被对象访问到。 即使这个对象到了花园。

那么， 有什么方法可以访问到static成员变量呢？

static修饰成员函数

static修饰的成员函数可以用来访问static修饰的成员变量。 它是专门用来访问成员变量的。 

但是，static修饰的成员函数只能访问它的参数、类的静态数据成员和全局变量，而不能访问非静态数据成员。 所以， static也可以用来限制某个函数。 

具体看一下实例：

  1.  
  2. class AA 
  3. {
  4.  
  5. public:
  6. 	AA()
  7. 	{}
  8.  
  9. 	static void SFunc() 
  10. 	{
  11. 		cout << count1 << endl;
  12. 	}
  13.  
  14. private:
  15. 	static int count1;
  16. };
  17.  
  18. int AA::count1 = 1;
  19.  
  20.  
  21. int main() 
  22. {
  23. 	AA().SFunc();
  24. 	return 0;
  25. }

 图中红框框是我们定义的一个静态成员。然后， static修饰的成员变量要在类外面初始化。  这里蓝框框将它在外面初始化。 

绿框框是我们通过静态成员函数访问count1成员。 

以上， 就是本节全部内容。  

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/438528
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号