c++ 基础复习 整合

一、编译和链接装载库
https://github.com/huihut/interview#%EF%B8%8F-%E9%93%BE%E6%8E%A5%E8%A3%85%E8%BD%BD%E5%BA%93

'''
1、c++内存类型（5+1）
'''
堆：由程序员维护分配和释放，如果没有释放，程序结束时由操作系统回收。容纳程序动态分配的内存。
栈：由操作系统自动分配和释放，包含：函数的返回地址和参数、存放函数的非static变量、维护函数调用的上下文（调用前后需要保持不变的寄存器）
程序代码区：存放二进制代码
自由存储区：c++ new delete 动态分配和释放
静态/全局存储区：保存static对象、全局变量，对象使用前分配，程序结束时销毁
常量存储区：存放常量不允许修改
'''
2、关于堆的分配算法
'''
#堆的分配算法包括：空闲链表、位图
位图：用0标记空闲，用1标记占用，每个内存单元对应于位图中的一位。如把k个内存分配单元调入内存时，在位图中寻找k个连续0串（耗时）
空闲链表：维护一个已分配内存段和空闲内存段的链表，分配方法有：首次适配、下次适配、最佳适配
'''
3、段错误 or 内存地址不能 read/write
'''
由非法的指针引起的错误，指针指向了不允许读写的地址，程序试图利用指针读写该地址
产生原因：指针初始化为NULL后没有赋值、没有初始化栈中的指针（一般是随机数）
'''
4、不同平台的动态库、静态库格式
'''
windows：动态库ddl、静态库lib、可执行文件exe
linux  ：动态库so、静态库a、可执行文件out or elf
'''
5、c++程序编译的过程
'''
#源程序main.c “预编译器” -> 修改的源程序main.i “编译器” -> 汇编程序main.s “汇编器” -> 可重定位目标程序main.o ”链接器“ -> 可执行程序main
预编译：处理如“#include” “#define” 等预编译指令，生成.i
编译器：进行词法分析、语法分析、语义分析、中间代码生成、目标代码生成、优化，生成.seek
汇编器：把汇编码翻译成机器码，生成.o
链接器：进行地址和空间分配、符号决议、重定位，生成可执行程序
#编译器编译后的.i文件叫做目标文件，已经是可执行文件的格式只是还没有经过链接符号和地址。可执行文件.exe/.elf,.dll/.so,.lib/.a都是目标文件格式存储的
#目标文件的存储结构
FILE header：描述文件的属性是否可执行、是静态链接还是动态链接、入口地址、操作系统
text section：代码段，语句编译成的机器代码
data section：数据段，已初始化的全局变量和静态变量
bbs  section：BBS段，未初始化的全局变量和静态变量
read only section：只读数据段，存放const
comment section：注释信息段，包括编译器版本信息
stack section：堆栈提示段
'''
6、符号
'''
链接的接口称为符号，目标文件之间的拼合实际上是目标文件之间对函数和变量地址的引用，函数和变量统称为符号，函数名和变量名统称为符号名。
'''
7、Linux共享库
'''
linux下的共享库是ELF共享对象，命名：libname.so.x.y.z 
x：主版本号，不同版本号间不兼容需要重编译
y：次版本号，高版本向后兼容
z：发布版本号，不对接口更改，完全兼容
#
系统目录/lib：存放基础和关键共享库，数学库、动态链接器等
系统目录/usr/lib：非关键库，开发库
系统目录/usr/local/lib：第三方应用库
#环境变量
LD_LIBARY_PATH：临时改变某个程序共享库的查找路径不影响其他程序。
LD_PRELOAD：预装载共享库或目标文件
LD_DEBUG：打开动态链接器调制功能
#so 共享库的编写
CMakeLists
'''
8、Windows动态链接库DLL
'''
创建DLL实际上是创建一个可供可执行模块调用的函数；使用c与c++混编时要使用extern "C"修饰
加载windows程序的搜索顺序：可执行文件目录->windows系统目录System->进程的当前目录->PATH环境变量列出的目录
DUMPBIN -export ...\my.dll 查看DLL导出变量、函数、类名的符号、相对虚拟地址
'''
8、运行库 Runtime Library —— 典型程序运行的步骤
'''
1、操作系统创建进程，把控制权交给程序的入口（运行库中的某个入口函数）
2、入口函数对运行库和程序运行环境初始化（堆、I/O、线程、全局变量等）
3、调用main函数，正式开始执行程序主体部分
4、返回到入口函数进行清理工作（全局变量析构、堆销毁、关闭I/O），系统调用结束进程
'''
9、c语言标准库头
'''
标准输入输出、文件操作：stdio.h
字符操作：ctype.h
字符串操作：string.h
数学函数：math.h
资源管理、格式转换：stdlib.h
时间日期：time.h
断言：assert.h


二、C++基础知识

'''
1、const (被 const 修饰（在 const 后面）的值不可改变)
'''
修饰变量，说明该变量不可以被改变；
修饰指针，分为指向常量的指针（pointer to const）和自身是常量的指针（常量指针，const pointer）；
修饰引用，指向常量的引用（reference to const），用于形参类型，即避免了拷贝，又避免了函数对值的修改；
修饰成员函数，说明该成员函数内不能修改成员变量。
#指针
指向常量的指针（pointer to const）
自身是常量的指针（常量指针，const pointer）
#引用
指向常量的引用（reference to const）
没有 const reference，因为引用本身就是 const pointer
// 类
class A
{
private:
    const int a;                // 常对象成员，只能在初始化列表赋值

public:
    // 构造函数
    A() : a(0) { };
    A(int x) : a(x) { };        // 初始化列表

    // const可用于对重载函数的区分
    int getValue();             // 普通成员函数
    int getValue() const;       // 常成员函数，不得修改类中的任何数据成员的值
};

void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数、更新常成员变量
    const A a;                  // 常对象，只能调用常成员函数
    const A *p = &a;            // 指针变量，指向常对象
    const A &q = a;             // 指向常对象的引用

    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量（const 后面是 char，说明指向的字符（char）不可改变）
    char* const p3 = greeting;          // 自身是常量的指针，指向字符数组变量（const 后面是 p3，说明 p3 指针自身不可改变）
    const char* const p4 = greeting;    // 自身是常量的指针，指向字符数组常量
}

// 函数
void function1(const int Var);           // 传递过来的参数在函数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常量
void function4(const int& Var);          // 引用参数在函数内为常量

// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：int* const p = function7();
'''
2、static
'''
修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为 static。
修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。
修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。
'''
3、this指针
'''
this 指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向调用该成员函数的那个对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给 this 指针，然后调用成员函数，每次成员函数存取数据成员时，都隐式使用 this 指针。
当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。
this 指针被隐含地声明为: ClassName *const this，这意味着不能给 this 指针赋值；在 ClassName 类的 const 成员函数中，this 指针的类型为：const ClassName* const，这说明不能对 this 指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）；
this 并不是一个常规变量，而是个右值，所以不能取得 this 的地址（不能 &this）。
在以下场景中，经常需要显式引用 this 指针：
为实现对象的链式引用；
为避免对同一对象进行赋值操作；
在实现一些数据结构时，如 list。
'''
4、内联函数inline
'''
相当于把内联函数里面的内容写在调用内联函数处；
相当于不用执行进入函数的步骤，直接执行函数体；
相当于宏，却比宏多了类型检查，真正具有函数特性；
编译器一般不内联包含循环、递归、switch 等复杂操作的内联函数；
在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数。
// 声明1（加 inline，建议使用）
inline int functionName(int first, int second,...);

// 声明2（不加 inline）
int functionName(int first, int second,...);

// 定义
inline int functionName(int first, int second,...) {/****/};

// 类内定义，隐式内联
class A {
    int doA() { return 0; }         // 隐式内联
}

// 类外定义，需要显式内联
class A {
    int doA();
}
inline int A::doA() { return 0; }   // 需要显式内联
#编译器对 inline 函数的处理步骤
将 inline 函数体复制到 inline 函数调用点处；
为所用 inline 函数中的局部变量分配内存空间；
将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
#优点
内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。
内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。
在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。
内联函数在运行时可调试，而宏定义不可以。
#缺点
代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译，不像 non-inline 可以直接链接。
是否内联，程序员不可控。内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器。
'''
5、虚函数（virtual）可以是内联函数（inline）吗
'''
虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
inline virtual 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
#虚函数内联使用
#include <iostream>  
using namespace std;
class Base
{
public:
    inline virtual void who()
    {
        cout << "I am Base\n";
    }
    virtual ~Base() {}
};
class Derived : public Base
{
public:
    inline void who()  // 不写inline时隐式内联
    {
        cout << "I am Derived\n";
    }
};
int main()
{
    // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 
    Base b;
    b.who();

    // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。  
    Base *ptr = new Derived();
    ptr->who();

    // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
    delete ptr;
    ptr = nullptr;

    system("pause");
    return 0;
} 
'''
6、volatile
'''
volatile int i = 10; 
volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统、硬件、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化。
volatile 关键字声明的变量，每次访问时都必须从内存中取出值（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值）
const 可以是 volatile （如只读的状态寄存器）
指针可以是 volatile，一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时
简单地说就是防止编译器对代码进行优化，编译器在用到这个变量时必须每次都小心地从内存重新读取这个变量的值，而不是使用保存在寄存器里的备份
'''
7、assert()
'''
断言，是宏，而非函数。assert 宏的原型定义在 <assert.h>（C）、<cassert>（C++）中，其作用是如果它的条件返回错误，则终止程序执行。可以通过定义 NDEBUG 来关闭 assert，但是需要在源代码的开头，include <assert.h> 之前。
assert() 使用
#define NDEBUG          // 加上这行，则 assert 不可用
#include <assert.h>
assert( p != NULL );    // assert 不可用
'''
8、sizeof()
'''
sizeof 对数组，得到整个数组所占空间大小。
sizeof 对指针，得到指针本身所占空间大小。
'''
9、#pragma pack(n)
'''
设定结构体、联合以及类成员变量以 n 字节方式对齐
其实之所以有内存字节对齐机制，就是为了最大限度的减少内存读取次数。我们知道CPU读取速度比内存读取速度快至少一个数量级，所以为了节省运算花费时间，只能以牺牲空间来换取时间了。
如强制按照2字节进行对齐，可以理解成所有的内容都是按照2字节进行读取，其他所有的数据成员都是2字节的整数倍，所以也就不用进行内存对其，各个成员在内存中就按照实际顺序进行排列，那么int e就得二次才能读到CPU中
#pragma pack(n) 使用
#pragma pack(push)  // 保存对齐状态
#pragma pack(4)     // 设定为 4 字节对齐
struct test
{
    char m1;
    double m4;
    int m3;
};
#pragma pack(pop)   // 恢复对齐状态
'''
Bit 位域（一个bytes(字节)是8 bit(Bit)）
'''
有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。
Bit mode: 2;    // mode 占 2 位
类可以将其（非静态）数据成员定义为位域（bit-field），在一个位域中含有一定数量的二进制位。当一个程序需要向其他程序或硬件设备传递二进制数据时，通常会用到位域。
位域在内存中的布局是与机器有关的
位域的类型必须是整型或枚举类型，带符号类型中的位域的行为将因具体实现而定
取地址运算符（&）不能作用于位域，任何指针都无法指向类的位域
struct bs 
{ 
int a:8; 
int b:2; 
int c:6; 
}data; 
说明data为bs变量，共占两个字节
struct bs 
{ 
unsigned a:4 
unsigned :0  
unsigned b:4  
unsigned c:4 
} 
这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位
'''
extern "C"
'''
extern "C" 的作用是让 C++ 编译器将 extern "C" 声明的代码当作 C 语言代码处理，可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。
extern "C" 使用
#ifdef __cplusplus
extern "C" {
#endif
void *memset(void *, int, size_t);
#ifdef __cplusplus
}
#endif
'''
10、struct 、 class
'''
#总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。
#区别：struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。
'''
11、union
'''
union是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态
默认访问控制符为 public
可以含有构造函数、析构函数
不能含有引用类型的成员
不能继承自其他类，不能作为基类
不能含有虚函数
匿名 union 在定义所在作用域可直接访问 union 成员
匿名 union 不能包含 protected 成员或 private 成员
全局匿名联合必须是静态（static）的
#include<iostream>
union UnionTest {
    UnionTest() : i(10) {};
    int i;
    double d;
};
static union {
    int i;
    double d;
};
int main() {
    UnionTest u;

    union {
        int i;
        double d;
    };

    std::cout << u.i << std::endl;  // 输出 UnionTest 联合的 10

    ::i = 20;
    std::cout << ::i << std::endl;  // 输出全局静态匿名联合的 20

    i = 30;
    std::cout << i << std::endl;    // 输出局部匿名联合的 30

    return 0;
}
'''
12、C 实现 C++ 类
'''
封装：使用函数指针把属性与方法封装到结构体中
继承：结构体嵌套
多态：父类与子类方法的函数指针不同
'''
13、explicit（显式）关键字
'''
explicit 修饰构造函数时，可以防止隐式转换和复制初始化
explicit 修饰转换函数时，可以防止隐式转换，但 按语境转换 除外
struct A
{
    A(int) { }
    operator bool() const { return true; }
};
struct B
{
    explicit B(int) {}
    explicit operator bool() const { return true; }
};
void doA(A a) {}
void doB(B b) {}
int main()
{
    A a1(1);        // OK：直接初始化
    A a2 = 1;        // OK：复制初始化
    A a3{ 1 };        // OK：直接列表初始化
    A a4 = { 1 };        // OK：复制列表初始化
    A a5 = (A)1;        // OK：允许 static_cast 的显式转换 
    doA(1);            // OK：允许从 int 到 A 的隐式转换
    if (a1);        // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
    bool a6（a1）;        // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
    bool a7 = a1;        // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
    bool a8 = static_cast<bool>(a1);  // OK ：static_cast 进行直接初始化

    B b1(1);        // OK：直接初始化
    B b2 = 1;        // 错误：被 explicit 修饰构造函数的对象不可以复制初始化
    B b3{ 1 };        // OK：直接列表初始化
    B b4 = { 1 };        // 错误：被 explicit 修饰构造函数的对象不可以复制列表初始化
    B b5 = (B)1;        // OK：允许 static_cast 的显式转换
    doB(1);            // 错误：被 explicit 修饰构造函数的对象不可以从 int 到 B 的隐式转换
    if (b1);        // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
    bool b6(b1);        // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
    bool b7 = b1;        // 错误：被 explicit 修饰转换函数 B::operator bool() 的对象不可以隐式转换
    bool b8 = static_cast<bool>(b1);  // OK：static_cast 进行直接初始化
    return 0;
}
'''
14、friend 友元类和友元函数
'''
能访问私有成员
破坏封装性
友元关系不可传递
友元关系的单向性
友元声明的形式及数量不受限制
#使用友元函数计算两点之间的距离
class Point{
public:
    Point(int xx = 0, int yy = 0) { X = xx; Y = yy;}
    int GetX() {return X;}
    int GetY() {return Y;}
    friend float fDist( Point &a, Point &b );
private:
    int X, Y;
};
float fDist(Point &p1, Point &p2){
    double x = double(p1.X - p2.X);//通过对象访问私有数据成员，而不是必须使用Getx()函数
    double y = double(p1.Y - p2.Y);
    return float(sqrt(x*x + y*y));
#友元类
class A{
public:
    int GetX() { return x; }
    friend class B;//B类是A类的友元类
    //其它成员略
private:
    int x;
};
class B{
public:
    void set(int i);
    //其他成员略
private:
    A a;
};
void B :: set(int i){
    a.x = i;//由于B类是A类的友元类，所以在B的成员函数中可以访问A类对象的私有成员
}
'''
15、:: 范围解析运算符
'''
全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的
命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
'''
16、enum 枚举类型
'''
枚举型是预处理指令#define的替代，枚举和宏其实非常类似，宏在预处理阶段将名字替换成对应的值，枚举在编译阶段将名字替换成对应的值
'''
17、左值和右值
'''
右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值
void Print(string& s){
    cout << s;
}
int main(){
    string s="abc";
    Print(s); // OK
    Print("abc"); // Error！！！
}
原因在于s是左值，"abc"是右值，改成void Print(const string& s)就没问题，原因：const为"abc"构造一个临时对象
#c++11
bool Login(User& user) {
    //处理左值传入
    user.count++;
    return true
}
bool Login(User&& user) {
    //处理右值传入 &&右值引用
    user.count++;
    return true
}
#修改，万能引用——模板类 
template<class T>
bool Login(T&& user) {
    // 万能引用
    user.count++;
    return true
}
#&&已经不是右值引用了，而是被称为万能引用，传入右值时，模板特化成bool Login(User&& user)，当传入左值时，模板特化成bool Login(User& user)
'''
18、成员初始化列表
'''
更高效：少了一次调用默认构造函数的过程。
有些场合必须要用初始化列表：
常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面
引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面
没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化
'''
19、面向对象
'''
面向对象三大特征 —— 封装、继承、多态
#封装：
把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。关键字：public, protected, private。不写默认为 private。
#继承：
基类（父类）——> 派生类（子类）
#多态：
多态，即多种状态（形态）。简单来说，我们可以将多态定义为消息以多种形式显示的能力。
多态是以封装和继承为基础的。
C++ 多态分类及实现：
重载多态（Ad-hoc Polymorphism，编译期）：函数重载、运算符重载
子类型多态（Subtype Polymorphism，运行期）：虚函数
参数多态性（Parametric Polymorphism，编译期）：类模板、函数模板
强制多态（Coercion Polymorphism，编译期/运行期）：基本类型转换、自定义类型转换
'''
20、多态
'''
#静态多态：（编译期/早绑定）函数重载
class A
{
public:
    void do(int a);
    void do(int a, int b);
};
#动态多态（运行期期/晚绑定）
虚函数：用 virtual 修饰成员函数，使其成为虚函数
普通函数（非类成员函数）不能是虚函数
静态函数（static）不能是虚函数
构造函数不能是虚函数（因为在调用构造函数时，虚表指针并没有在对象的内存空间中，必须要构造函数调用完成后才会形成虚表指针）
内联函数不能是表现多态性时的虚函数，解释见：虚函数（virtual）可以是内联函数（inline）吗？
class Shape                     // 形状类
{
public:
    virtual double calcArea()
    {
        ...
    }
    virtual ~Shape();
};
class Circle : public Shape     // 圆形类
{
public:
    virtual double calcArea();
    ...
};
class Rect : public Shape       // 矩形类
{
public:
    virtual double calcArea();
    ...
};
int main()
{
    Shape * shape1 = new Circle(4.0);
    Shape * shape2 = new Rect(5.0, 6.0);
    shape1->calcArea();         // 调用圆形类里面的方法
    shape2->calcArea();         // 调用矩形类里面的方法
    delete shape1;
    shape1 = nullptr;
    delete shape2;
    shape2 = nullptr;
    return 0;
}
'''
21、虚函数（virtual）可以是内联函数（inline）吗
'''
虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
inline virtual 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
'''
22、虚（析构）函数
'''
虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。
class Shape
{
public:
    Shape();                    // 构造函数不能是虚函数
    virtual double calcArea();
    virtual ~Shape();           // 虚析构函数
};
class Circle : public Shape     // 圆形类
{
public:
    virtual double calcArea();
    ...
};
int main()
{
    Shape * shape1 = new Circle(4.0);
    shape1->calcArea();    
    delete shape1;  // 因为Shape有虚析构函数，所以delete释放内存时，先调用子类析构函数，再调用基类析构函数，防止内存泄漏。
    shape1 = NULL;
    return 0；
}
#纯虚函数
纯虚函数是一种特殊的虚函数，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。
类里如果声明了虚函数，这个函数是实现的，哪怕是空实现，它的作用就是为了能让这个函数在它的子类里面可以被覆盖（override），这样的话，编译器就可以使用后期绑定来达到多态了。纯虚函数只是一个接口，是个函数的声明而已，它要留到子类里去实现。
虚函数在子类里面可以不重写；但纯虚函数必须在子类实现才可以实例化子类。
虚函数的类用于 “实作继承”，继承接口的同时也继承了父类的实现。纯虚函数关注的是接口的统一性，实现由子类完成。
带纯虚函数的类叫抽象类，这种类不能直接生成对象，而只有被继承，并重写其虚函数后，才能使用。抽象类被继承后，子类可以继续是抽象类，也可以是普通类。
虚基类是虚继承中的基类，具体见下文虚继承。
#虚函数指针、虚函数表
虚函数指针：在含有虚函数类的对象中，指向虚函数表，在运行时确定。
虚函数表：在程序只读数据段（.rodata section，见：目标文件存储结构），存放虚函数指针，如果派生类实现了基类的某个虚函数，则在虚表中覆盖原本基类的那个虚函数指针，在编译时根据类的声明创建。
(虚函数表是一个指针数组，虚函数指针是指向指针数组的指针)
虚函数表很好的讲解：https://blog.twofei.com/496/
'''
23、虚继承
'''
虚继承用于解决多继承条件下的菱形继承问题（浪费存储空间、存在二义性）。
底层实现原理与编译器相关，一般通过虚基类指针和虚基类表实现，每个虚继承的子类都有一个虚基类指针（占用一个指针的存储空间，4字节）和虚基类表（不占用类对象的存储空间）（需要强调的是，虚基类依旧会在子类里面存在拷贝，只是仅仅最多存在一份而已，并不是不在子类里面了）；当虚继承的子类被当做父类继承时，虚基类指针也会被继承。
实际上，vbptr 指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚基类表（virtual table），虚表中记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着公共基类（虚基类）的两份同样的拷贝，节省了存储空间。
#虚继承 vs 虚函数
相同之处：都利用了虚指针（均占用类的存储空间）和虚表（均不占用类的存储空间）
#不同之处：
虚继承:虚基类依旧存在继承类中，只占用存储空间、虚基类表存储的是虚基类相对直接继承类的偏移
虚函数:虚函数不占用存储空间、虚函数表存储的是虚函数地址
#注：普通类
空的类是会占用内存空间的，而且大小是1，原因是C++要求每个实例在内存中都有独一无二的地址。
普通的变量：是要占用内存的，但是要注意对齐原则（这点和struct类型很相似）。
static修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。
#类内部的成员函数
普通函数：不占用内存。
虚函数：要占用4个字节，用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的

三、面试题汇总
参考：https://blog.csdn.net/fakine/article/details/51321544
'''
1、new、delete、malloc、free关系
'''
malloc和free是标准库函数，new和delete是c++运算符，都可以用于申请动态内存和释放内存，只有malloc和free不能满足动态对象的要求，对象在创建时自动执行构造函数、消亡时自动执行析构函数，malloc和free是库函数不是运算符，不能执行构造函数和析构函数，因此c++需要能够自动完成构造函数和析构函数的new和delete。
'''
2、delete与 delete []区别
'''
delete与new配套，delete []与new []配套，delete只会调用一次析构函数，delete[]调用每一个成员的析构函数。
MemTest *mTest1=new MemTest[10];
MemTest *mTest2=new MemTest;
Int *pInt1=new int [10];
Int *pInt2=new int;
delete[]pInt1; //-1-
delete[]pInt2; //-2-
delete[]mTest1;//-3-
delete[]mTest2;//-4-
对于内建简单数据类型，delete和delete[]功能是相同的（1、2）;对于自定义的复杂数据类型（3、4），delete和delete[]不能互用。delete[]删除一个数组，delete删除一个指针。简单来说，用new分配的内存用delete删除；用new[]分配的内存用delete[]删除。
'''
3、子类析构时要调用父类的析构函数吗
'''
定义一个对象时先调用基类的构造函数，再调用派生类的构造函数、析构时先调用派生类的析构函数再调用基类的析构函数。
'''
4、多态是什么
'''
多态是不同对象接收相同信息产生不同的动作，c++的多态性体现在运行和编译两方面，程序运行时的多态性通过继承和虚函数实现，编译时的多态通过函数和运算符重载实现。
纯虚函数的作用：在基类中为其派生类保留一个函数的名字，以便派生类根据需要对它进行定义。作为接口而存在 纯虚函数不具备函数的功能，一般不能直接被调用。
从基类继承来的纯虚函数，在派生类中仍是虚函数。如果一个类中至少有一个纯虚函数，那么这个类被称为抽象类（abstract class）。
抽象类中不仅包括纯虚函数，也可包括虚函数。抽象类必须用作派生其他类的基类，而不能用于直接创建对象实例。但仍可使用指向抽象类的指针支持运行时多态性。
'''
5、什么是“引用”？申明和使用“引用”要注意哪些问题？
'''
引用就是目标变量的别名，申明一个引用的时候切记要对它初始化，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。
'''
6、将“引用”作为函数参数有哪些特点
'''
（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。
（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。
（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
'''
7、常引用
'''
如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；
'''
8、“引用”作为函数返回值类型的格式、好处和需要遵守的规则?
'''
好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error! 
（1）不能返回局部变量的引用(局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。)、（2）不能返回函数内部new分配的内存的引用。（3）可以返回类成员的引用，但最好是const
#流操作符重载返回值申明为“引用”的作用：
流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << endl;　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。 
赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。
'''
9、重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？
'''
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！
重写：是指子类重新定义父类虚函数的方法。和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。
'''
10、有哪几种情况只能用intialization list 而不能用assignment?
'''
当类中含有const、reference 成员变量时它们只能够被初始化而不能做赋值操作；还有一种情况就是，基类无默认构造函数时，有参的构造函数都需要初始化。
'''
11、C++是不是类型安全的？
'''
不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。
'''
12、main 函数执行以前，还会执行什么代码？
'''
全局对象的构造函数会在main 函数之前执行。
'''
13、描述内存分配方式以及它们的区别
'''
1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
'''
14、const与#define 相比，有何优点
'''
const作用：定义常量、修饰函数参数、修饰函数返回值三个作用。被Const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
'''
15、特殊
'''
int (*s[10])(int) 表示的是什么 ：函数指针数组
int id[sizeof(unsigned long)];这个对吗？为什么？ 正确 这个 sizeof是编译时运算符，编译时就确定了  ,可以看成和机器有关的常量。
#复杂声明
void * ( * (*fp1)(int))[10];
float (*(* fp2)(int,int,int))(int);
int (* ( * fp3)())[10]();
分别表示什么意思？
1.void * ( * (*fp1)(int))[10];   fp1是一个指针，指向一个函数，这个函数的参数为int型，函数的返回值是一个指针，这个指针指向一个数组，这个数组有10个元素，每个元素是一个void*型指针。
2.float (*(* fp2)(int,int,int))(int);   fp2是一个指针，指向一个函数，这个函数的参数为3个int型，函数的返回值是一个指针，这个指针指向一个函数，这个函数的参数为int型，函数的返回值是float型。
3.int (* ( * fp3)())[10]();   fp3是一个指针，指向一个函数，这个函数的参数为空，函数的返回值是一个指针，这个指针指向一个数组，这个数组有10个元素，每个元素是一个指针，指向一个函数，这个函数的参数为空，函数的返回值是int型。
'''
16、栈内存与文字常量区
'''
char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;//0  分别指向各自的栈内存
cout << ( str3 == str4 ) << endl;//0  分别指向各自的栈内存
cout << ( str5 == str6 ) << endl;//1指向文字常量区地址相同
cout << ( str7 == str8 ) << endl;//1指向文字常量区地址相同
str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。
'''
17、将程序跳转到指定内存地址
'''
要对绝对地址0x100000赋值，我们可以用(unsigned int*)0x100000 = 1234;那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？
*((void (*)( ))0x100000 ) ( );
首先要将0x100000强制转换成函数指针,即:
(void (*)())0x100000
然后再调用它:*((void (*)())0x100000)();
'''
18、引用和指针区别
'''
1) 引用必须被初始化，指针不必。
2) 引用初始化以后不能被改变，指针可以改变所指的对象。
3) 不存在指向空值的引用，但是存在指向空值的指针。
'''
19、基类的析构函数不是虚函数，会带来什么问题？
'''
当用基类操作派生类，在析构时防止只析构基类而不析构派生类的状况发生
派生类操作派生类没有影响
'''
20、全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的
'''
生命周期不同：
全局变量随主程序创建，随主程序销毁；局部变量在局部函数内部，甚至局部循环体等内部存在，退出就不存在；
使用方式不同：通过声明后全局变量程序的各个部分都可以用到；局部变量只能在局部使用；分配在栈区。 
操作系统和编译器通过内存分配的位置来知道的，全局变量分配在全局数据段并且在程序开始运行的时候被加载。局部变量则分配在堆栈里面 。
'''
21、宏定义和内联函数的区别
'''
1）宏定义不是函数，预处理器用赋值宏代码的方式代替函数的调用，省去了函数压栈退栈过程。
内联函数本质是一个函数，不能包含复杂的控制，如果内敛函数体过大，编译器会自动把这个内联函数变成普通函数
内联函数是在编译的时候进行代码插入，编译器在调用内联函数的地方直接把内联函数内容展开。省去函数的调用开销。
2）宏定义没有类型检查。内联函数在编译的时候进行类型检查
3）宏定义和内联都是进行diamagnetic展开。不同点，宏定义在预编译的时候把所有宏名字替换，内联函数在编译阶段把所有调用内敛函数的地方进行内联函数插入，省去函数压栈清栈
'''

'''

'''

'''

'''

'''