面试笔试总结（一）之 C++基础
C++
1.智能指针 内存管理 垃圾回收 指针问题 资源管理（内存就是资源）
可以通过引用计数的机制。。。实现内存回收，不要让内存泄漏。
涉及到内存的泄露的问题：
- 当创建一个对象的时候（new）而在对象使用完毕，没有delete就会发生内存泄漏。
- 或者有很多指针指向同一块内存，当有一个使用完毕delete了，剩下的指针就会无处可指
- 循环引用导致的指针泄漏
很多人会忘记，这时候智能指针就派上用处了，可以帮助程序员自动在析构函数中释放。两个类：
第一个问题想法：同归于尽ｓｍａｒｔＰｏｉｎｔｅｒ中的指针就是ｏｂｊｅｃｔ的指针
- smartpointer类构造函数析构函数：有一个自己的构造函数把传过来的object指针付给自己，销毁时候ｄｅｌｅｔｅ自己就ok了。
- 有一个私有成员：ｏｂｊｅｃｔ的指针 ｐｔｒ。
- 构造完成就相当于object的ｐｔｒ就是object的ｐ。
- 所以释放自己的ｐｔｒ就相当于销毁ｏｂｊｅｃｔ的ｐ；
class Object {
public:
int a,b;
};
int main(){
while(true){
smartPointer p(new Object());
Process(p);
}
}
void Process(Object &p){
//do something;
}
class smartPointer{
public:
smartPointer(Object *p){
ptr=p;
}
~smartPointer(){
delete ptr;
}
private: Object *ptr;
};
第二个问题：
引用计数类～～～～～～～～～～～！！！！！！！！！！记录当前有多少指针指向这个内存。
ＳＴＬ不是基于引用计数的：ｏｕｔｏ＿ｐｔｒ 同一时刻一个指针只能有一个被一个对象拥有。。。缺点：不能赋值操作，不能参数传递～，
基于计数的：ｂｏｏｓｔ库的ｓｈａｒｅｄ＿ｐｔｒ！！！！！！！！！
可能在：
构造，复制，赋值＝
发生指针指向和指针计数的问题
定义指向ｃｏｕｎｔｅｒ的指针Ｓmartpointeｐｒｏ
定义指向内存（object）的指针ｃｏｕｎｔｅｒ
友元类 可以访问Ｃｏｕｎｔｅｒ类的成员
class Object {
public:
int a,b;
};
int main(){
while(true){
smartPointer p(new Object());
Process(p);
}
}
void Process(Object &p){
//do something;
}
class Conter_Smartpointer{
public:
Conter_Smartpointer(Object *p){／／普通的构造 产生新内存
cSp=new Counter(p);
}
Conter_Smartpointer(Conter_Smartpointe &p){／／指向同样的内存，复制
cSp=p.cSp;
cSp->cnt++;
}
Conter_Smartpointer& operate=(Conter_Smartpointer &p){／／赋值
//right++ left --
cSp->cnt--;被右边的覆盖掉了，指向右边的内存了 原来的引用计数减一
p.cSp->cnt++;
if(cSp->cnt == 0){
delete cSp;
}
cSp=p.cSp;
}
~Conter_Smartpointer(){
cSp->cnt--;
if(cSp->cnt == 0){
delete cSp;
}
}
private: Counter *cSp;／／指向同一个ｃｏｕｎｔｅｒ
};
class Counter(){
ｆｒｉｅｎｄ ｃｌａｓｓ Conter_Smartpointer；／／Conter_Smartpointer可以访问ｃｏｕｎｔｅｒ类的成员（包括私有成员）
pravite:
int cnt;
Object *ptr;
Counter(){
p=NULL;
cnt=0;
}
Counter(Object *p){
ptr = p;
cnt=1;
}
第三个问题：
父亲指向儿子，儿子指向父亲，没有一个先释放。。环
解决：ｂｏｏｓｔ：：ｗｅａｋ＿ｐｔｒ
赋值传递：对传入的实参进行拷贝～在函数里处理不会影响原来的对象
引用：相反
资源管理（内存就是资源）：
在ｃ＋＋常利用对资源的包装～防止内存泄漏
２.单例模式
设计模式：
一个类只能一个对象～
应用于：系统日志的输出，一个界面只有一个鼠标 鼠标类。。
１.一个类只能一个对象～
２.内存的释放
３.线程安全，多个类产生一个对象
有什么问题：
class Singleton(){
private:
Singleton(){
}
static Singleton* instance;
public：
static Singleton* GetInstance(){
if(instance == NULL){
instance = new Singleton();
}
}
}
想要产生一个类只能通过ＧｅｔＩｎｓｔａｎｃｅ（）
让构造函数是私有的，这样别的类就不能访问这个构造函数
函数传递 和赋值的问题：可能会产生多个对象的问题
无析构：因为无对象：ｓｔａｔｉｃ 定义的类属于整个类，不存在析构。ｓｔａｔｉｃ一旦被构造赋值，就不允许修改。在静态存储区。
对于释放内存的问题，ｎｅｗ出来的在堆中产生，必须手动释放
ｓｔａｉｃ在静态存储区，这样操作系统自动释放内存
方法一：如何保证线程安全＆＆内存不用手动释放
static Singleton instance;当再次调用就直接使用instance：保证只产生一个对象
class Singleton(){ private: Singleton(){ } Singleton(Singleton &p){ } Singleton& operate = (const Singleton &p){ } public： static Singleton* GetInstance(){ static Singleton instance; return &instance; } }
方法二：保证线程安全
double ｃｈｅｃｋ 加锁
