剑指offer_Cpp（1）

1、sizeof的一些注意事项

（1）定义一个空类型，里面没有任何成员变量和成员函数，对该类型求sizeof，得到结果是多少？

空类型的实例不包含任何信息，所以本来求sizeof应该是0，但是声明该类型的实例时，必须在内存中占有一定空间，否则无法使用这些实例。至于占多少内存是由编译器决定的，在Visual Code中，每个空类型的实例占用1字节的空间。

（2）如果在该类型中添加一个构造函数和析构函数，再对该类型求sizeof，得到的结果又是多少？

答案还是1，调用构造函数和析构函数只需要知道函数的地址即可，而这些函数的地址只与类型相关，而与类型的实例无关，编译器也不会因为这两个函数而在实例内添加任何额外的信息

（3）如果把析构函数定义为虚函数呢？

编译器一旦发现一个类型中含有虚函数，就会为该类型生成虚函数表，并在该类型的每个实例中添加一个指向虚函数表的指针。在32位的机器上，一个指针占用4字节的空间，因此求sizeof得到4；如果是64位的机器，则一个指针占用8字节的空间，因此求sizeof得到8。

class NullClass{
public:
    NullClass(){};
    ~NullClass(){};
};
void func()
{
    NullClass tmp;
    cout<<sizeof(tmp)<<endl;
}
// 输出结果为：1

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

// 如下为类型CMyString的声明，请为该类型添加赋值运算符函数
class CMyString
{
public:
    CMyString(char* pData=nullptr);
    CMyString(const CMyString& str);
    ~CMyString(void);
    
private:
    char* m_pData; 
};

编写赋值运算符函数需要注意以下几点：

（1）是否把返回值声明为该类型的引用，并在函数结束前返回实例自身引用（*this)。只有返回引用才能允许链式赋值。

（2）是否把传入参数的类型声明为常量引用。声明为引用可以避免实参到形参的拷贝，加上const限定符是因为，函数体内不会改变传入实例的状态。

（3）是否释放自身已有的内存，如果在分配新内存之前忘记释放自身已有的内存会造成内存泄漏

（4）是否判断传入参数与当前实例是不是同一个，如果是，则不进行赋值，直接返回。如果不提前判断，那么释放自身内存的时候，传入参数的内存同时也会被释放，导致赋值不成功。

经典解法，初级程序员

CMyString& CMyString::operator=(const CMyString& str)
{
    if(this==&str)
        return *this;
    delete[] m_pData;
    m_pData = nullptr;
    
    m_pData = new char[strlen(str.m_pData)+1];
    strcpy(m_pData,str.m_pData);
    return *this;
}

上述的解法没有考虑异常安全的问题，假如内存不足，导致呢new char抛出异常，那么此时m_pData将是一个空指针，非常容易导致程序崩溃。避免上述问题的解法有两种：第一种，先用new分配内存，再用delete释放原来的内容；第二种，先创建一个临时的实例，再交换临时实例和原来的实例

考虑异常安全的解法，高级程序员

// 第二种解法
CMyString& CMyString::operator=(const CMyString& str)
{
    if(this!=&str)
    {
        CMyString strTemp(str);
        char* pTemp = strTemp.m_pData;
        strTemp.m_pData = m_pData;
        m_pData = pTemp;    
	}
    return *this;
}
// 由于交换了strTemp与this的m_pData指针，所以双方指向的内存被交换了，此时strTemp是在函数体内构造的，出了函数会自动调用析构函数释放内存。

3、面试题目2：单例模式

​ 单例模式(Singleton Pattern，也称为单件模式)，使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

定义一个单例类：
（1）私有化它的构造函数，以防止外界创建单例类的对象；

（2）使用类的私有静态指针变量指向类的唯一实例；

（3）使用一个公有的静态方法获取该实例。

单例模式有两种：懒汉模式和饿汉模式

懒汉模式：单例实例在第一次被使用时才进行初始化，这叫做延迟初始化

情况一

// version 1.0
class Singleton
{
private:
	static Singleton* instance;
private:
	Singleton(){};
    ~Singleton(){};
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
public:
	static Singleton* getInstance()
    {
		if(instance==nullptr)
        {
            instance = new Singleton();
		}
        return instance;
	}
};
// 初始化静态成员
Singleton* Singleton::instance = nullptr;

上述设计的单例模式会出现内存泄漏的情况，有两种解决方法：

（1）使用智能指针；

（2）使用静态的嵌套类对象

对于第二种解决方法，代码如下：

// version 1.1
class Singleton
{
private:
    static Singleton* instance;
private:
	Singleton(){};
    ~Singleton(){};
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
private:
	class Deletor{
    public:
        ~Deletor()
        {
            if(Singleton::instance != nullptr)
                delete Singleton::instance;
			}

    };
    static Deletor deletor;
public:
    static Singleton* getInstance()
    {
        if(instance==nullptr)
        {
            instance = new Singleton();
			}
        return instance;
	}

};
// 初始化静态成员
Singleton* Singleton::instance = nullptr;
Singleton::Deletor Singleton::deletor;

当程序结束时，系统会调用静态成员deletor的析构函数，该析构函数会删除单例的唯一实例。

为什么要内嵌类，不能在Singleton析构函数里面删除

如果在自身的析构函数里面delete指向单例的instance，那么会调用instance的析构函数，从而造成无限递归

上述方法是非线程安全的，要在多线程环境下实现单例还需要加锁来实现线程同步，可以使用双检测锁模式（DCL: Double-Checked Locking Pattern)

// version 1.2
class Singleton
{
private:
    static Singleton* instance;
    static std::mutex m_mutex;
private:
    Singleton(){};
    ~Singleton(){};
    Singleton(const Singleton&){};
    Singleton& operator(const Singleton&){};
private:
    class Deletor
    {
        ~Deletor()
        {
            if(instance!=nullptr)
            {
                delete Singleton::instance;
			}
		}
	};
    static Deletor deletor;
public:
    static Singleton* getInstance()
    {
        if(instance==nullptr)
        {
            std::unique_lock<std:::mutex>lock(m_mutex);
            if(instance==nullptr)
            {
                instance = new Singleton();
			}
		}
        return instance;
	}    
};

// 初始化静态成员
Singleton* Singleton::instance = nullptr;
Singleton::Deletor Singleton::deletor;
std::mutex Singleton::m_mutex;

通过加锁可以实现线性安全，但是比较繁琐，C++11提供了一种比较优雅的方式

// version 1.3
class Singleton
{
private:
    Singleton(){};
    ~Singleton(){};
    Singleton(const Singleton&){};
    Singleton& opertor=(const Singleton&){};
    
public:
    static Singleton& getInstance()
    {
        static Singleton instance;
        return instance;
	}
};

C++11保证了local static对象的线程安全。对于local static对象，其初始化在第一次执行到该对象的初始化语句，可能多个线程同时到达初始化这里，为了保证线程安全，只有第一个到达的线程才会执行初始化，其他线程执行到这里就会阻塞等待，直到local static初始化完成！

饿汉模式：指单例实例在程序运行时被立即执行初始化

// version 1.4
class Singleton
{
private:
	static Singleton instance;
private:
    Singleton(){};
    ~Singleton(){};
    Singleton(const Singleton&){};
    Singleton& operator(const Singleton&){};
public:
    static Singleton& getInstance()
    {
        return instance;
	}
}
// 初始化静态成员
Singleton Singleton::instance;

由于在main函数之前已经初始化，所以没有线性安全问题。但是static Singletion instance和static Singleton& getInstance()二者的初始化顺序不确定，如果在初始化完成前调用getInstance()方法会返回一个未定义的实例。

4、面试题3：查找重复数字

在一个长度为n的数组里的所有数字都在0~n-1的范围内。数组种某些数字是重复的，但是不知道有那几个数字重复了，也不知道每个数字重复了几次。请找出数组种任意一个重复的数字。

常用的做法是排序，但是快排时间复杂度为O(nlogn)，还可以用哈希表，哈希表可以把时间复杂度降到O(n)，但是需要空间复杂度O(n)为代价！

由于这个数组比较特别，可以另一种算法，使得时间复杂度降为O(n)，同时不增加空间为代价。算法的思想：从数组首元素开始遍历，判断当前元素m是否与下标一致，如果一致继续遍历下一个元素；否则，判断当前元素m是否与第m个数字相等，如果相等，就找到一个重复的数字；如果不相等把当前元素m与第m个元素交换，然后继续判断此时的元素是否与当前下标一致，直到满足才遍历下一个元素，遍历过后的数字都是放在对应下标的。

int findRepeatNumber(vector<int>&nums)
{
    int len = nums.size();
    if (len==0||len==1) return -1;
    for(auto&num : nums)
    {
        if(num<0||num>len-1)
            return -1;
    }   
	for(int i=0;i<len;++i)
    {
        while(nums[i]!=i)
        {
            if(nums[i]==nums[nums[i]])
                return nums[i];
            swap(nums[i],nums[nums[i]]);
		}
	}
    return -1;
}

可以自己设置测试用例：

• 长度为n的数组里面包含一个或者多个重复数字（正常用例）

• 数组中不包含重复数字（异常用例1）

• 无效输入，比如空数组，长度为n的数组中包含0~n-1之外的数字（异常用例2）
  
  

5、面试题4：不修改数组找出重复数字

在一个长度为n+1的数组中，所有的数字范围均在1~n，所以至少有一个元素是重复的，请找出任意一个重复的数字，但不能改变数组！

在上一题中，通过把数组中的元素放回对应的位置找到重复的数字，这一过程中涉及了数组里面元素的交换，修改了数组。当前需求是不修改数组，显然把数组复制到一个新的数组中再执行上述的解法即可，但是这样会使空间复杂度变为O(n)！

如何在不增加空间为代价，快速找出重复数字呢？

可以用二分查找，把数组一分为二，第一段1_{m，第二段是m}n。分别统计这两段范围内数字的个数，如果第一段数字个数超过m，那么肯定存在重复数字，继续将这一段进行二分查找，否则第二段含有重复数字！直到找到一个重复的数字。

int findRepeatNumber2(vector<int>&nums)
{
    int len = nums.size();
    if(len==0||len==1) return -1;
    for(int& num: nums)
    {
		if(num<1||num>len-1)
            return -1;
    }
    
    int left = 1;
    int right = len-1;
    while(left<=right)
    {
        int mid = (right-left)/2+left;
        auto count = [&](){
            int ans=0;
            for(auto&num :nums)
                if(num>=left&&num<=mid)
                    ++ans;
			return ans;};
        if(left==right)
        {
            if(count()>1)
                return left;
            else
                break;
		}
        if(count()>(mid-left+1))
            right = mid;
        else
            left = mid+1;
	}
    return -1;  
}

按照二分查找的思路，如果输入长度为n的数组，那么匿名函数count()会被调用O(logn)次，而每次需要遍历一遍数组，需要O(n)时间，所以总的时间复杂度为O(nlogn)，空间复杂度为O(1)。

从上述分析可以看出，我们采用什么算法取决于面试官提的不同需求，假如要找出所有的重复数字或者优先考虑时间忽略空间又该怎么做？在动手写代码之前要先把需求分析好。

6、面试题5：二维数组中的查找

在一个二维数组中，每一行都按照从左往右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有这个整数。

// 类似如下的二维数组
[ 1  2  8  9
  2  4  9  12
  4  7  10 13
  6  8  11 15 ]

根据数组递增的规律，从左下角或者右上角开始搜索会比较方便。比如从右上角搜索，假设右上角的元素如果不是目标元素，若目标元素比右上角元素大就向下走，假如目标函数比右上角元素小那么就向左走，以此类推，如果到达边界还没有找到，那就是没有这个元素。

bool Find(vector<vector<int>>&nums,int target)
{
    int m = nums.size();
    int n = nums[0].size();
    if(m>0&&n>0)
    {
        int row = 0;
        int column = n-1;
        while(row<m&&column>=0)
        {
            if(nums[row][column]==target)
                return true;
            else if(nums[row][column]<target)
                ++row;
            else
                --column;
        }
    }
    return false;
}

7、字符串

C/C++中字符串都是以’\0’作为结尾，因此每个字符串都有一个额外的字符开销，稍不留神就会造成字符串的越界。比如下面的代码：

char str[10];
strcpy(str,"0123456789");

"0123456789"看似只有10个字符，但是还有一个结束符，所以一共为11个字符，而str数组只申请了10个字符的内存，因此会造成越界。

C/C++把常量字符串放在单独的一个内存区域。当几个指针赋值给相同的常量字符串时，它们实际上会指向相同的内存地址。但是用常量内存初始化数组，情况却不一样，可以看下面的例子：

int main()
{
    char str1[] = "hello world";
    char str2[] = "hello world";
    
    char* str3 = "hello world";
    char* str4 = "hello world";
    
    if(str1==str2)
    	std::cout<<"str1 and str2 are same\n";
    else
        std::cout<<"str1 and str2 are not same\n";
    
    if(str3==str4)
        std::cout<<"str3 and str4 are same\n";
    else
        std::cout<<"str3 and str4 are not same\n";
    
    return 0;
}