面试笔试总结（一）之 C++基础

C++

1.智能指针　内存管理　垃圾回收　指针问题　资源管理（内存就是资源）

可以通过引用计数的机制。。。实现内存回收，不要让内存泄漏。

涉及到内存的泄露的问题：

1. 当创建一个对象的时候（new）而在对象使用完毕，没有delete就会发生内存泄漏。
2. 或者有很多指针指向同一块内存，当有一个使用完毕delete了，剩下的指针就会无处可指
3. 循环引用导致的指针泄漏

很多人会忘记，这时候智能指针就派上用处了，可以帮助程序员自动在析构函数中释放。两个类：

第一个问题想法：同归于尽ｓｍａｒｔＰｏｉｎｔｅｒ中的指针就是ｏｂｊｅｃｔ的指针

• 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　ｃｈｅｃｋ　加锁