C++ 重点关键字

final

用于类后或者函数后，声明该类/函数，不可被继承/覆盖。

例如：

1. class Base final {...} //不能作为基类，即禁止继承

2. void print const final; //函数声明，禁止函数被覆盖（多用于类继承）

override

用于声明某函数是覆盖覆盖基类虚函数

例如：

class Base {

public:

virtual void get() const;//基类虚函数

}；

class Son ：public Base {

public:

void get() const override; // 表明该函数是覆盖基类同名虚函数智勇，便于检查继承覆盖函数的正确性。

}

auto 和 decltype

二者都用于类型推导，不同的是

1. auto将赋值语句右值计算后赋给左值（变量），所以它是实实在在执行了右值表达式；而decltype则是用某表达式/变量的返回值/推导值，来声明变量，它不执行语句。

例如：

int m = 1;

auto i = m + 2; m+2 执行后结果为int,所以i被声明为int

decltype(m + 2) i = 10; 这里编译器只是分析 “m+2”表达式结果类型为int，而没有执行m+2；

2. auto忽略顶层const，而decltype会保留。

3. decltype((变量))的结果是引用，而decltype(变量)结果是变量类型。

const

四种用法

---

 1.修饰变量起到限定只读作用；

void func(const int a, const string str)

{...}

const int* func(...)

{...}

2.const int* p :  不能通过指针p去修改对象的值。但对象本身可以被赋值。

3.int* const p : 指针不可变

4. void func(...) const

{...}

保证本段函数不修改调用它的对象，或者常量对象可以调用本函数，或者对象在本段函数内是安全的。

那么const int* func(const int, const string&, const char*) const &/&&

{...}这又该怎么解读呢？自己去探索吧！

---

特点：被修饰常量不可改值（只读）；有类型检查；通常保存在符号表中，不分配内存；效率高；

与#define的区别：宏只是机械替换，不做类型检查；使用多少次（赋值），就查找多少次内存，效率低；const可以修饰指针，宏不可以；const可以控制在函数内部值不可变。

extern

置于变量或者函数前，表示定义在别的文件中。提示，遇到次变量或函数时，在别处寻找定义。或者：多文件共享变量。

extern "C"---调用C代码（需要按照C规则编译）；

 operator

用于重载运算符时

TYPE operator 运算符（形参...）

{

　　......

}

 sizeof

sizeof(对象)

sizeof(变量或者表达式)

struct大小计算 （字节对齐）

结构体顺序存储，为了加快CPU的取数速度，编译器会对结构体进行处理。让基本数据类型的数据处于能被其大小整除的地址上。比如int型，第一个存在 4-8地址 ，中间有一个char 在8-9地址，那么下一个int 在12-16,中间的10-11就需要字节填充。这样一来，结构体的sizeof就会增大。

字节对齐准则

1. 结构体变量的首地址能够被其最宽基本类型成员的大小所整除。
2. 结构体的每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要，编译器会在成员之间加上填充字节（internal adding）。
3. 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要，编译器会在最末一个成员后加上填充字节（trailing padding）。
空结构体大小1字节，用于占位。

简单例子

1 struct
2 {
3   char c;
4   int i;
5   double d;
6   short s;    
7 }

1+填充3+4+8+2=18？ 8的倍数=24

我们来看一个嵌套的例子

 1 struct stu
 2 {  
 3       short i;  
 4       struct   
 5       {  
 6            char c;  
 7            int j;  
 8       } ss; //嵌套时，要注意内嵌的struct首地址仍然要整除内部最大类型大小 
 9       int k;  
10 }

2+填充2+1+填充3+4+4=16

 1 #include <iostream>
 2 
 3 struct stu
 4 {  
 5       short i;  
 6       struct   
 7       {  
 8            char c;  
 9            int j;  
10       } ss; //嵌套时，要注意内嵌的struct首地址仍然要整除内部最大类型大小 
11       int k;  
12 }s1;
13 
14 struct
15 {
16   char c;
17   int i;
18   double d;
19   short s;    
20 }s2;
21 
22 
23 
24 int main()
25 {
26     std::cout << sizeof(s1) << "  " << sizeof(s2) <<std::endl;
27     return 0;
28 }

C++ code

 

 union的sizeof

联合体重叠式存储，成员共享一段内存。

sizeof(union) = max(sizeof( union(i) )

 

数组的sizeof

1.字符串，多一个'/0'

2.当数组为形参时，大小相当于指针sizeof，大小即地址=计算机内部地址总线的宽度(32位4B， 64位8B)

3.函数，返回值的大小

 static

静态数据成员属于类，而非对象，一个类只有一份；

静态成员函数属于类，而非对象，不能使用this指针来访问，只能访问静态数据和静态成员函数；

静态数据成员，必须在类外进行初始化，初始化使用作用域运算符标明所属类；

如： int Demo::staticVName = 1;

有时候，我们为了比避免父类的静态变量影响子类，可以在子类中定义一个与父类相同的static变量。这不会引起错误，因为有name mangling存在。（会对重载的变量和函数进行处理，以达到区分的目的）

另外，static关键字还有以下作用

隐藏（只在本文件、函数中可见）

保持变量的持久化（函数中的static变量可以持久化，且可以控制可见范围）

 1 void testStatic()
 2 {
 3     static int m = 100;
 4     cout << "函数被调用:" << m << endl;
 5     m--;
 6 }
 7 
 8 int main() 
 9 {
10     for (int i = 0; i < 10; ++i)
11         testStatic();
　　　　cout << m << endl;//错误，main函数不可见 m
12 }

 

默认初始化为0

 new 与 malloc

new:C++运算符；new-delete;使用简单，不计算大小，不需要类型转换；自动调用构造、析构函数；内存申请失败，抛出异常；不能进行重新分配；进行类型检查；可设置内存分配器；

malloc:C语言标准库函数；malloc-free; 需要计算大小，需要显示类型转换；不调用；申请失败，返回NULL; 可利用relloc重新分配内存；不检查类型；不可设置内存分配器。

 union

用union类型测试大端小端存储

参考资料

https://blog.csdn.net/yixianfeng41/article/details/54668327（main）

https://www.cnblogs.com/songdanzju/p/7422380.html

https://www.cnblogs.com/puheng/p/9575379.html

https://bbs.csdn.net/topics/70227932