C++ 常见问题总结

一、 C/C++

const

作用：

1. 修饰变量，说明该变量不可以被修改

2. 修饰指针，分为指向常量的指针和指针常量

3. 常量引用，经常用于形参类型，避免了拷贝，又避免了函数对参数的修改

4. 修饰成员函数，说明该成员函数内不能修改成员变量

使用：

/ 类
class A
{
private:
    const int a;                // 常对象成员，只能在初始化列表赋值

public:
    // 构造函数
    A() { };
    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;          // 指针变量，指向字符数组常量
    char* const p3 = greeting;          // 常指针，指向字符数组变量
    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();

static

作用：
1. 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在main函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值，系统就会用默认值初始化它。

2. 修饰普通函数，表明函数的作用范围，仅在定义函数的文件内才能使用。在多人开发项目时，为了防止与他人命名的函数重名，可以用static修改函数。

3. 修饰成员变量，修饰成员变量时所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员

4. 修饰成员函数，修饰成员函数是得不需要生成对象就可以访问该函数，但是static函数内不能访问非静态成员

this 指针

1. this 指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向正在被改成愿函数操作的那个对象。

2. 当对一个对象调用成员函数时，编译程序会先将对象的地址赋给 this 指针，然后调用成员函数，每次成员函数存取数据成员时，都会隐含使用 this 指针。

3. 当一个成员函数被调用时，自动向他传递一个隐含的参数，该参数是一个指向这个成员函数所在

对象的指针。

4. this 指针被隐含地声明为：ClassName *const this, 这意味着不能给 this 指针赋值；在ClassName类中的 const 成员函数中， this 指针的类型为：const ClassName* const , 这说明 this 指针指向的这种对象是不能修改的（不能对这种对象的数据成员进行赋值操作）。

5. this 并不是一个常规变量，而是个右值，所以不能取 this 的地址。

6. 在以下场景中，经常需要显示引用this 指针：
        a. 为实现对象的链式引用；
        b. 为避免对同一对象进行赋值操作；
        c. 在实现一些数据结构时。

inline 内联函数

特征：
1. 相当于把内联函数里的内容写在调用内联函数的地方；

2. 相当于不用执行进入函数的步骤，直接执行函数体；

3. 相当于宏，却比宏多了类型检查，真正具有函数特性；

4. 不能包含循环、递归、switch 等复杂操作；

5. 在类声明中定义的函数，除了虚函数的其他函数都会自动隐士的当成内联函数。

使用：

// 声明1（加 inline，建议使用）
inline int functionName(int first, int secend,...);

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

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

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

// 类外定义，需要显式内联
class A {
    int doA();
}
inline int A::doA() { return 0; }   // 需要显式内联

编译器对内联函数的处理步骤：
1. 将inline 函数体复制到inline 函数的调用处；

2. 为所有 inline 函数中的局部变量分配内存空间；

3. 将inline 函数的输入参数和返回值映射到调用方法的局部变量空间中；

4. 如果inline 函数有多个返回点，将其转变为inline 函数代码块末尾的分支（使用GOTO）。

优点：

1. 内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。

2. 内联函数相比于宏函数来说，在代码展开时，会做安全检查或者自动类型转换（同普通函数），而宏定义则不会。

3. 在类中声明同时定义的成员函数，自动转换为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。

4. 内联函数在运行时可调试，而宏定义不可以。

缺点：

1. 代码膨胀。内联函数是以代码膨胀为代价，消除函数调用带来的开销，如果执行函数体内代码的时间相比于函数调用的开销大，那么效率的收获会很少。

2. inline 函数无法随着函数库升级而升级。inline 函数的改变需要重新编译， 不像 non-inline 可以直接链接。

3. 是否内联，程序员不可控。内联函数只是对编译器的建议，是否内联，决定权在于编译器。

虚函数（virtual）可以是内联函数（inline）吗？

1. 虚函数可以是内联函数，内联函数是可以修饰虚函数的，但是当虚函数表示多态的时候不能内联。

2. 内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现多态性时不可以内联。

3. 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;
} 

assert()

断言，是宏，而非函数。assert 宏的原型定义在<assert.h> 、 <assert> 中，其作用是如果它的返回条件错误，则终止程序执行。可以通过 NDEBUG 来关闭 assert ，但是需要在源代码的开头， include <assert.h> 之前。

使用：

#define NDEBUG          // 加上这行，则 assert 不可用
#include <assert.h>

assert( p != NULL );    // assert 不可用

sizeof()

sizeof 对数组，取得整个数组所占空间大小。

sizeof 对指针，得到指针本身所占空间大小。