81、什么是内存泄露,如何检测与避免?
- 一般我们常说的内存泄漏是指堆内存的泄漏。
- 堆内存是指程序从堆中分配的,大小任意的(内存块的大小可以在程序运行期决定)内存块,使用完后必须显式释放的内存。
- 应用程序般使用malloc,、realloc、 new等函数从堆中分配到块内存,使用完后,程序必须负责相应的调用free或delete释放该内存块,否则,这块内存就不能被再次使用,我们就说这块内存泄漏了!
避免内存泄露的几种方式:
- 计数法: 使用new或者malloc时,让该数+1,delete或free时,该数-1,程序执行完打印这个计数,如果不为0则表示存在内存泄露!
- 一定要将基类的析构函数声明为虚函数;
- 对象数组的释放一定要用delete [];
- 有new就有delete,有malloc就有free,保证它们一定成对出现!
检测工具:
- Linux下可以使用Valgrind工具
- Windows下可以使用CRT库
82、成员初始化列表的概念,为什么用它会快一些?
成员初始化列表的概念
- 在类的构造函数中,不在函数体内对成员变量赋值,而是在构造函数的花括号前面使用冒号和初始化列表赋值。
效率:
用初始化列表会快一些!
原因:
- 对于类,使用成员初始化列表会少了一次调用构造函数的过程;而在函数体中赋值则会多一次调用。
- 而对于内置数据类型则没有差别。
举个例子:
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout << "默认构造函数A()" << endl;
}
A(int a)
{
value = a;
cout << "A(int "<<value<<")" << endl;
}
A(const A& a)
{
value = a.value;
cout << "拷贝构造函数A(A& a): "<<value << endl;
}
int value;
};
class B
{
public:
B() : a(1)
{
b = A(2);
}
A a;
A b;
};
int main()
{
B b;
}
//输出结果:
//A(int 1)
//默认构造函数A()
//A(int 2)
- 从代码运行结果可以看出,在构造函数体内部初始化的对象b多了一次构造函数的调用过程,而对象a则没有。
- 由于对象成员变量的初始化动作发生在进入构造函数之前,对于内置类型没什么影响;
- 但如果有些成员是类,那么在进入构造函数之前,会先调用一次默认构造函数,进入构造函数后所做的事其实是一次赋值操作(对象已存在),所以如果是在构造函数体内进行赋值的话,等于是一次默认构造加一次赋值;
- 而初始化列表只做一次赋值操作。
83、说说移动构造函数
背景:
- 我们用对象a初始化对象b,后对象a我们就不在使用了,但是对象a的空间还在呀(在析构之前),既然拷贝构造函数,实际上就是把a对象的内容复制一份到b中,那么为什么我们不能直接使用a的空间呢?
- 这样就避免了新的空间的分配,大大降低了构造的成本。这就是移动构造函数设计的初衷;
所以我们只要避免第一个指针释放空间就可以了。
避免的方法就是将第一个指针(比如a->value)置为NULL,这样在调用析构函数的时候,由于有判断是否为NULL的语句,所以析构a的时候并不会回收a->value指向的空间;
移动构造函数的参数和拷贝构造函数区别:
- 拷贝构造函数的参数是一个左值引用;
- 移动构造函数的初值是一个右值引用。
- 意味着,移动构造函数的参数是一个右值或者将亡值的引用。
- 也就是说,只用用一个右值,或者将亡值初始化另一个对象的时候,才会调用移动构造函数。
- 而那个move语句,就是将一个左值变成一个将亡/右值。
84、C++中将临时变量作为返回值时的处理过程
- 临时变量,在函数调用过程中是被压到程序进程的栈中的,当函数退出时,临时变量出栈,即临时变量已经被销毁, 临时变量占用的内存空间没有被清空,但是可以被分配给其他变量,所以有可能在函数退出时,该内存已经被修改了,对于临时变量来说已经是没有意义的值了;
- C语言里规定: 16bit程序中,返回值保存在ax寄存器中,32bit程序中,返回值保持在eax寄存器中,如果是64bit返回值,edx寄存器保存高32bit,eax寄存器保存低32bit;
- 由此可见,函数调用结束后,返回值被临时存储到寄存器中,并没有放到堆或栈中,也就是说与内存没有关系了;
- 当退出函数的时候,临时变量可能被销毁,但是返回值却被放到寄存器中与临时变量的生命周期没有关系。
- 如果我们需要返回值,一般使用赋值语句就可以了。
85、如何获得结构成员相对于结构开头的字节偏移量
使用<stddef.h>头文件中的,offsetof宏。
举个例子:
#include <iostream>
#include <stddef.h>
using namespace std;
struct S
{
int x;
char y;
int z;
double a;
};
int main()
{
cout << offsetof(S, x) << endl; // 0
cout << offsetof(S, y) << endl; // 4
cout << offsetof(S, z) << endl; // 8
cout << offsetof(S, a) << endl; // 12
return 0;
}
在Visual Studio 2019 + Win10 下的输出情况如下:
cout << offsetof(S, x) << endl; // 0
cout << offsetof(S, y) << endl; // 4
cout << offsetof(S, z) << endl; // 8
cout << offsetof(S, a) << endl; // 16 这里是 16的位置,因为 double是8字节,需要找一个8的倍数对齐,
当然了,如果加上 #pragma pack(4) 指定4字节对齐方式就可以了。
#pragma pack(4)
struct S
{
int x;
char y;
int z;
double a;
};
void test02()
{
cout << offsetof(S, x) << endl; // 0
cout << offsetof(S, y) << endl; // 4
cout << offsetof(S, z) << endl; // 8
cout << offsetof(S, a) << endl; // 12
}
S结构体中各个数据成员的内存空间划分如下所示,需要注意内存对齐:
86、静态类型和动态类型,静态绑定和动态绑定的介绍
静态类型: 对象在声明时采用的类型,在编译期既已确定;
动态类型: 通常是指一个指针或引用目前所指对象的类型,是在运行期决定的;
静态绑定: 绑定的是静态类型,所对应的函数或属性依赖于对象的静态类型,发生在编译期;
动态绑定: 绑定的是动态类型,所对应的函数或属性依赖于对象的动态类型,发生在运行期;
从上面的定义也可以看出,非虚函数一般都是静态绑定,而虚函数都是动态绑定(如此才可实现多态性)。
举个例子:
#include <iostream>
using namespace std;
class A
{
public:
/*virtual*/ void func() { std::cout << "A::func()\n"; }
};
class B : public A
{
public:
void func() { std::cout << "B::func()\n"; }
};
class C : public A
{
public:
void func() { std::cout << "C::func()\n"; }
};
int main()
{
C* pc = new C(); //pc的静态类型是它声明的类型C*,动态类型也是C*;
B* pb = new B(); //pb的静态类型和动态类型也都是B*;
A* pa = pc; //pa的静态类型是它声明的类型A*,动态类型是pa所指向的对象pc的类型C*;
pa = pb; //pa的动态类型可以更改,现在它的动态类型是B*,但其静态类型仍是声明时候的A*;
C *pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型,因为它指向了NULL;
pa->func(); //A::func() pa的静态类型永远都是A*,不管其指向的是哪个子类,都是直接调用A::func();
pc->func(); //C::func() pc的动、静态类型都是C*,因此调用C::func();
pnull->func(); //C::func() 不用奇怪为什么空指针也可以调用函数,因为这在编译期就确定了,和指针空不空没关系;
return 0;
}
如果将A类中的virtual注释去掉(此时有虚函数了),则运行结果是:
pa->func(); //B::func() 因为有了virtual虚函数特性,pa的动态类型指向B*,因此先在B中查找,找到后直接调用;
pc->func(); //C::func() pc的动、静态类型都是C*,因此也是先在C中查找;
pnull->func(); //空指针异常,因为是func是virtual函数,因此对func的调用只能等到运行期才能确定,然后才发现pnull是空指针;
在上面的例子中:
- 如果基类A中的func不是virtual函数,那么不论pa、pb、pc指向哪个子类对象,对func的调用都是在定义pa、pb、pc时的静态类型决定,早已在编译期确定了。
- 同样的空指针也能够直接调用no-virtual函数而不报错(这也说明一定要做空指针检查啊!),因此静态绑定不能实现多态;
- 如果func是虚函数,那所有的调用都要等到运行时根据其指向对象的类型才能确定,比起静态绑定自然是要有性能损失的,但是却能实现多态特性;
本文代码里都是针对指针的情况来分析的,但是对于引用的情况同样适用。
静态绑定和动态绑定的区别:
- 静态绑定发生在编译期,动态绑定发生在运行期;
- 对象的动态类型可以更改,但是静态类型无法更改;
- 要想实现多态,必须使用动态绑定;
- 在继承体系中只有虚函数使用的是动态绑定,其他的全部是静态绑定;
建议:
绝对不要重新定义继承而来的非虚(non-virtual)函数(《Effective C++ 第三版》条款36)
- 因为这样导致函数调用由对象声明时的静态类型确定了,而和对象本身脱离了关系,没有多态,也这将给程序留下不可预知的隐患和莫名其妙的BUG;
87、引用是否能实现动态绑定,为什么可以实现?
可以!
- 引用在创建的时候必须初始化,在访问虚函数时,编译器会根据其所绑定的对象类型决定要调用哪个函数。
- 注意只能调用虚函数。
举个例子:
#include <iostream>
using namespace std;
class Base
{
public:
virtual void fun()
{
cout << "base :: fun()" << endl;
}
};
class Son : public Base
{
public:
virtual void fun()
{
cout << "son :: fun()" << endl;
}
void func()
{
cout << "son :: not virtual function" <<endl;
}
};
int main()
{
Son s;
Base& b = s; // 基类类型引用绑定已经存在的Son对象,引用必须初始化
s.fun(); //son::fun()
b.fun(); //son :: fun()
return 0;
}
- 虚函数才具有动态绑定;
- 上面代码中,Son类中还有一个非虚函数func(),这在b对象中是无法调用的;
- 如果使用基类指针来指向子类也是一样的。
88、全局变量和局部变量有什么区别?
生命周期不同:
- 全局变量随主程序创建而创建,随主程序销毁而销毁;
- 局部变量在局部函数内部,甚至局部循环体等内部存在,函数退出就不存在。
使用方式不同:
- 通过声明后全局变量在程序的各个部分都可以用到;
- 局部变量分配在堆栈区,只能在局部使用。
操作系统和编译器通过内存分配的位置:
- 全局变量分配在全局数据段,在程序开始运行的时候被加载;
- 局部变量则分配在堆栈里面。
89、指针加减计算要注意什么?
指针加减本质是对其所指地址的移动,移动的步长跟指针的类型是有关系的,因此在涉及到指针加减运算需要十分小心,加多或者减多都会导致指针指向一块未知的内存地址,如果再进行操作就会很危险。
90、怎样判断两个浮点数是否相等?
对两个浮点数判断大小和是否相等不能直接用==来判断,会出错!明明相等的两个数比较反而是不相等!
为什么不能直接比较?
- 计算机表示浮点数(float或double类型)都有一个精度限制,对于超出了精度限制的浮点数,计算机会把它们的精度之外的小数部分截断。因此,本来相等的两个浮点数在计算机中可能就变成不相等的了。
解决方法:
- 对于两个浮点数比较只能通过相减并与预先设定的精度比较,记得要取绝对值!