剑指Offer学习笔记

面试题1：赋值运算符函数

如下为CMyString的声明，请为该类添加赋值运算符函数。

class CMyString{

public:

    CMyString(char* pData = NULL);

    CMyString(const CMyString& str);

    ~CMyString(void);

private:

    char *m_pData;

};

注意点：

1.函数应返回自身的引用，这样才可以进行连续赋值。str1=str2=str3;

2.应该将传入的参数值声明为常量引用，减少复制消耗，并且保证不修改传入的实例。

3.释放自身的内存。

4.判断传入的实例是否就是自身，如果就是自身，那么释放内存时就会将传入的实例释放，导致无法复制。

参考代码：

CMyString& CMyString::operator=(const CMyString& str){

    if (this == &str) {

        return *this;

    }

    delete []m_pData;

    m_pData = NULL;

    m_pData = new char[strlen(str.m_pData)+1];

    strcpy(m_pData, str.m_pData);

    return *this;

}

---

面试题2：实现singleton模式

题目：设计一个类，要求该类只能生成一个实例

注意点：

1.线程安全，考虑到多线程环境，两个线程可能同时创建一个实例。

2.效率高。

3.代码简洁。

单例的两种模式

        懒汉模式：在第一次使用的时候才实例化对象

        饿汉模式：在单例类定义时就实例化对象

代码实现：

懒汉实现：

class LazySingleton{

protected:

    LazySingleton(){

        pthread_mutex_init(&mutex, NULL);

    }

public:

    static pthread_mutex_t mutex;

    static LazySingleton* instance();

    int a;

};

pthread_mutex_t LazySingleton::mutex;

LazySingleton* LazySingleton::instance(){

    pthread_mutex_lock(&mutex);

    static LazySingleton obj;

    pthread_mutex_unlock(&mutex);

    return &obj;

}

饿汉实现：

class HungrySingleton{

protected:

    HungrySingleton(){

    }

private:

    static HungrySingleton* p;

public:

    static HungrySingleton* instance();

};

HungrySingleton* HungrySingleton::p = new HungrySingleton();

HungrySingleton* HungrySingleton::instance(){

    return p;

}