游戏研发岗面试中对于c++常遇到的问题（1）（析构函数，const关键字）

析构函数

c++中类的析构函数是类的一种特殊的成员函数，在每次删除所创建的对象的时候执行
析构函数不像构造函数一样可以带参数，析构函数不可带参数
析构函数的名称和类的名称是完全相同的，前面加了（~）做前缀，不会返回任何值
析构函数有助于在跳出程序（关闭文件，释放内存）前释放资源

class Line
{
public:
    Line(void)
    {
        cout << "该对象被创建" << endl;
    }
    ~Line(void)
    {
        cout << "该物体被删除" << endl;
    }
    void print() {
         cout << "测试用" << endl;
    }
};

int main()
{
    Line line;
    line.print();
    
    return 0;
}

所以我们可以看到析构函数的作用

const用法

const修饰普通类型变量

c++中const允许指定一个语义约束，编译器会强制实时这个约束，允许程序要告诉编译器某值是保持不变的
如果在编程中确实需要一个值保持不变，就应该明确使用const，这样获得编译器的帮助

在c++中是用来修饰内置类型变量，自定义对象，成员函数，返回值，函数参数

int main() {
    const int  a = 7;
   
    a = 100;

    cout << a;
    system("pause");
    return 0;
}

如果我们在编译器上写下上述代码 会产生报错

因为 a 被编译器认为是一个常量，其值不允许修改

int main(void)
{
    const int  a = 7;
    int  *p = (int*)&a;
    *p = 8;
    cout<<a;
    system("pause");
    return 0;
}

我们取变量的地址并转换赋值给指向int的指针，然后利用*p=8；重新对变量a地址内的值赋值，然后看输出a的值

我们看到变量仍然是7

所以千万不要轻易对const的变量设法赋值，这会产生意想不到的效果

如果不想让编译器察觉上边对const的操作，我们可以在const前加上volatile关键字
Volatile和const是相反的，易变的，不会被编译器优化，编译器也就不会对a变量进行操作

volatile const int  a = 7;
    int* p = (int*)&a;
    *p = 8;
    cout << a;
    system("pause");
    return 0;

const修饰指针变量

const修饰指针变量有三种情况
1.const修饰指针执行的内容，则内容为不可变量
2.const修饰指针，则指针为不可变量
3.const修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量

const int *p = 8;

指针指向的内容8不可改变，简称左定值，因为const位于*的左边

int main() {
    int a = 8;
    int* const p = &a;
    *p = 9;
    int b = 7;
    p = &b;
}

上述代码运行之后会产生报错

对于const的指针p其指向的内存地址不能发生改变，但是其内容可以发生改变，简称右定向，因为const位于*的右边

int a = 8;
const int * const  p = &a;

对于上述代码，是前面两种情况的结合
const p的指向的内容和指向的内存地址都已固定，不能发生改变

const参数传递和函数返回值

对于const修饰函数参数可以分为三种情况

1.值传递的const修饰传递，一般这种情况不需要const修饰，因为函数会自动产生临时变量复制实参值

void test(const int a) {
	a++;
	cout << a;
}

运行上述代码

2.当const参数为指针的时候，可以防止指针被意外篡改

void test(int* const a)
{
    int t = 999;
    cout << *a << " ";
    a = &t;
}

int main(void)
{
    int a = 8;
    test(&a);
    cout << a; // a 为 9
    system("pause");
    return 0;
}

3.自定义类型的参数传递，需要临时对象复制参数，对临时对象的构造需要调用构造函数，比较浪费时间，
我们采取const外加引用的传递的方法

class Test
{
public:
    Test() {}
    Test(int _m) :_cm(_m) {}
    int get_cm()const
    {
        return _cm;
    }

private:
    int _cm;
};



void Cmf(const Test& _tt)
{
    cout << _tt.get_cm();
}

int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;
}

运行程序输出 8

4.const修饰函数的返回值
1.const修饰内置类型的返回值，修饰和不修饰返回值作用一样
2.const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。
3. const 修饰返回的指针或者引用，是否返回一个指向 const 的指针，取决于我们想让用户干什么。

const修饰类成员函数

const 修饰类成员函数，其目的是防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为 const 成员函数。

注意：const 关键字不能与 static 关键字同时使用，因为 static 关键字修饰静态成员函数，静态成员函数不含有 this 指针，即不能实例化，const 成员函数必须具体到某一实例。

希望我所写的对大家有帮助