c++的 this、static、extern、const类型

港控/mmm° 2022-05-27 01:24 190阅读 0赞

**1.this指针**

定义：一个对象的this指针并不是对象本身的一部分，不会影响sizeof（对象）的结果。this[作用域][Link 1]是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，[编译器][Link 2]会自动将对象本身的地址作为一个隐含[参数传递][Link 3]给函数。this指针是类的一个自动生成、自动隐藏的私有成员，它存在于类的非[静态成员][Link 4]函数中，指向[被调用函数][Link 5]所在的对象。全局仅有一个this指针，当一个对象被创建时，this指针就存放指向对象数据的首地址。

使用：一种情况就是，在类的非[静态成员][Link 4]函数中返回类对象本身的时候，直接使用 return \*this；另外一种情况是当参数与[成员变量][Link 6]名相同时使用this指针，如this->n = n （不能写成n = n）。

说明：

1. this只能在成员函数中使用。

全局函数，静态函数都不能使用this。

2. this在成员函数的开始前构造的，在成员的结束后清除。

这个生命周期同任一个函数的参数是一样的，没有任何区别。

当调用一个类的成员函数时，编译器将类的指针作为函数的this参数传递进去。

如A a;   a.func(10);   此处，编译器将会编译成： A::func(&a, 10);。嗯，看起来和静态函数没差别，对吗？不过，区别还是有     的。编译器通常会对this指针做一些优化的，因此，this指针的传递效率比较高－－如vc通常是通过ecx寄存器来传递this参数。

3. 回答

3.1 this指针是什么时候创建的?

this在非静态成员中有意义，作为右值可以直接在编译时确定其存在，运行时无所谓创建。

3.2 this指针存放在何处？堆，栈，全局变量，还是其他？

由上一问可知，this指针无需显式储存内存中。只要存储对象的内存位置确定，对应的this指针就被确定了。

3.3 this指针如何传递给类中函数的?绑定?还是在函数参数的首参数就是this指针.那么this指针又是如何找到类实例后函数的?

this是通过函数参数的首参数来传递的。this指针是在调用之前生成的。类实例后的函数，没有这个说法。类在实例化时，只分配类中的变量空间，并没有为函数分配空间。自从类的函数定义完成后，它就在那儿，不会跑的。

3.4 this指针如何访问类中变量的？

如果不是类，而是结构的话，那么，如何通过结构指针来访问结构中的变量呢？如果你明白这一点的话，那就很好理解这个问题了。

在C++中，struct是一种类类型，struct和class只有一个区别的：class的成员和继承默认的访问控制权限是private，而struct是public。

this是class或public的对象的指针。

3.5 我们只有获得一个对象后，才能通过对象使用this指针,如果我们知道一个对象this指针的位置可以直接使用吗?

一般来说，对于类成员函数（不论是静态还是非静态的成员函数）都不需要创建一个在运行时的函数表来保存。只有虚函数才会被放到函数表中。

但是，即使是虚函数，如果编译器能明确知道调用的是哪个函数，编译器就不会通过函数表中的指针来间接调用，而是可以直接调用该函数。

**2. static静态成员**

[https://blog.csdn.net/guotianqing/article/details/79828100][https_blog.csdn.net_guotianqing_article_details_79828100]（c语言中static关键字详解）

定义：静态成员，指的是在c++类中声明成员时可以加上static[关键字][Link 7]，这样声明的成员就叫做静态成员（包括[数据成员][Link 8]和成员函数）。即声明为static的类成员或者成员函数便能在类的范围内共同享。

区别对比：

静态[数据成员][Link 8]和普通数据成员区别较大，体现在下面几点：

（1）普通数据成员属于类的一个具体的对象，只有对象被创建了，普通数据成员才会被分配内存。而静态数据成员属于整个类，即使没有任何对象创建，类的静态数据[成员变量][Link 6]也存在。

（2）因为类的静态数据成员的存在不依赖与于任何类对象的存在，类的静态数据成员应该在代码中被显式地初始化，一般要在类外进行，例如上例。在C++11标准中，我们可以为静态成员提供const整数类型的类内初始值，不过要求静态成员必须是字面值常量类型的constexpr（源自C++Primer中文版270页）。

（3）外部访问类的静态成员能直接通过类名来访问，例如：test::getCount()。虽然静态成员不属于类的某个对象，但是我们仍然可以使用类的对象、引用或指针来访问静态成员(源自C++Primer中文版269页)

（4）类的静态成员函数无法直接访问普通[数据成员][Link 8]（可以通过对象名间接的访问），而类的任何成员函数都可以访问类的静态数据成员。

（5）静态成员和类的普通成员一样，也具有public、protected、private3种访问级别，也可以具有返回值、const[修饰符][Link 9]等参数。

**3. extern定义在其他文件**

extern是计算机语言中的一个关键字，可置于变量或者函数前，以表示变量或者函数的定义在别的文件中。提示[编译器][Link 2]遇到此变量或函数时，在其它模块中寻找其[定义][Link 10]，另外，extern也可用来进行链接指定。

extern用在变量声明中常常有这样一个作用：你要在\*.c文件中引用另一个文件中的一个全局的变量，那就应该放在\*.h中用extern来声明这个全局变量。

extern用于变量的用法：

extern int a;//声明一个全局变量a

int a; //定义一个全局变量a

extern int a =0 ;//定义一个全局变量a 并给初值。一旦给予赋值，一定是定义，定义才会分配存储空间。

int a =0;//定义一个全局变量a,并给初值，

声明之后你不能直接使用这个变量，需要定义之后才能使用。

第四个等于第三个，都是定义一个可以被外部使用的全局变量，并给初值。

糊涂了吧，他们看上去可真像。但是**定义只能出现在一处**。也就是说，不管是int a;还是int a=0;都只能出现一次，而那个**extern int a可以出现很多次**。

当你要引用一个全局变量的时候，你就要声明extern int a;这时候extern不能省略，因为省略了，就变成int a;这是一个定义，不是声明。

实际上函数的声明和定义都不需要添加extern关键字，在实际使用的时候也最好不要添加关键字。如果一个函数是不会被其它文件调用的，那么这个函数应该被声明成static的。

[C语言][C]的[关键字][Link 7]extern在函数的声明中起什么作用？

如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别。在一些复杂的项目中，要习惯在所有的函数声明前添加extern修饰。

extern int a; 仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配内存空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。

引用一个定义在其它模块的全局变量或函数（如，[全局函数][Link 11]或变量定义在A模块，B欲引用）有两种方法，一、B模块中include模块A的头文件。二、模块B中对欲引用的模块A的变量或函数重新声明一遍，并前加extern关键字。

**4. const只读**

const是一个C语言（ANSI C）的关键字，具有着举足轻重的地位。它限定一个变量不允许被改变，产生静态作用。使用const在一定程度上可以提高程序的安全性和可靠性。

const修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。

const常量，具有不可变性。 例如：const int Max=100; Max++会产生错误;

可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！本程序中以本次出现的const值为准。

const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像\#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而\#define定义的常量在内存中有若干份拷贝。

常量与只读变量：常量是被编译器放在内存中的只读区域，当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由[编译器][Link 2]限定不允许被修改。[C语言关键字][C 1]const就是用来限定一个变量不允许被改变的[修饰符][Link 9]。

用什么来定义定义常量：enum类型和\#define宏，这两个都可以用来定义常量。

需要注意的是，用const修饰变量时，一定要给变脸初始化，否则之后就不能再进行赋值了。

[https://blog.csdn.net/xingjiarong/article/details/47282255][https_blog.csdn.net_xingjiarong_article_details_47282255]

[https://blog.csdn.net/my\_mao/article/details/22872149][https_blog.csdn.net_my_mao_article_details_22872149]

**5. typedef重定义**

typedef是在计算机编程语言中用来为复杂的声明定义简单的别名，它与宏定义有些差异。它本身是一种存储类的关键字，与auto、extern、mutable、static、register等关键字不能出现在同一个表达式中。

通常讲，typedef要比\#define要好，特别是在有[指针][Link 12]的场合。请看例子：

typedef　char*　pStr1;
     
    #define　pStr2　char*　
     
    pStr1　s1,s2;
     
    pStr2　s3,s4;

在上述的变量定义中，s1、s2、s3都被定义为char \*，而s4则定义成了char，不是我们所预期的[指针变量][Link 13]，根本原因就在于\#define只是简单的字符串替换而typedef则是为一个类型起新名字。

[Link 1]: https://baike.baidu.com/item/%E4%BD%9C%E7%94%A8%E5%9F%9F
[Link 2]: https://baike.baidu.com/item/%E7%BC%96%E8%AF%91%E5%99%A8
[Link 3]: https://baike.baidu.com/item/%E5%8F%82%E6%95%B0%E4%BC%A0%E9%80%92
[Link 4]: https://baike.baidu.com/item/%E9%9D%99%E6%80%81%E6%88%90%E5%91%98
[Link 5]: https://baike.baidu.com/item/%E8%A2%AB%E8%B0%83%E7%94%A8%E5%87%BD%E6%95%B0
[Link 6]: https://baike.baidu.com/item/%E6%88%90%E5%91%98%E5%8F%98%E9%87%8F
[https_blog.csdn.net_guotianqing_article_details_79828100]: https://blog.csdn.net/guotianqing/article/details/79828100
[Link 7]: https://baike.baidu.com/item/%E5%85%B3%E9%94%AE%E5%AD%97
[Link 8]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E6%88%90%E5%91%98
[Link 9]: https://baike.baidu.com/item/%E4%BF%AE%E9%A5%B0%E7%AC%A6
[Link 10]: https://baike.baidu.com/item/%E5%AE%9A%E4%B9%89
[C]: https://baike.baidu.com/item/C%E8%AF%AD%E8%A8%80
[Link 11]: https://baike.baidu.com/item/%E5%85%A8%E5%B1%80%E5%87%BD%E6%95%B0
[C 1]: https://baike.baidu.com/item/C%E8%AF%AD%E8%A8%80%E5%85%B3%E9%94%AE%E5%AD%97
[https_blog.csdn.net_xingjiarong_article_details_47282255]: http://https//blog.csdn.net/xingjiarong/article/details/47282255
[https_blog.csdn.net_my_mao_article_details_22872149]: http://https//blog.csdn.net/my_mao/article/details/22872149
[Link 12]: https://baike.baidu.com/item/%E6%8C%87%E9%92%88
[Link 13]: https://baike.baidu.com/item/%E6%8C%87%E9%92%88%E5%8F%98%E9%87%8F