微软等名企面试题--C++篇

声明：

这篇博客的某些题目和答案成果源自于July和何海涛的博客，网址：点击打开链接   点击打开链接

本人只是针对自己情况，把感兴趣的题目都罗列出来；针对其他的题目（不是来自上面两位），写出了自己的算法，仅供自己慢慢学习和品味。如有问题，请在博客下面留言。

1 

问题：给出如下CMyString的声明，要求为该类型添加赋值运算符函数。

class CMyString
{
public:
    CMyString(char* pData = NULL);
    CMyString(const CMyString& str);
    ~CMyString(void);
      
private:
    char* m_pData;
};

当面试官要求应聘者定义一个复制运算符函数时，他会关注如下几点：

·         是否把返回值的类型声明为该类型的引用，并在函数结束前返回实例自身（即*this）的引用？只有返回一个引用，才可以允许连续赋值。否则如果函数的返回值是void，假设有三个CMyString的对象，str1、str2和str3，在程序中语句str1=str2=str3将不能通过编译。

·         是否把传入的参数的类型声明为常量引用？如果传入的参数不是引用而是实例，那么从形参到实参会调用一次构造拷贝函数。把参数申明为引用可以避免这样的无谓消耗，能提高代码的效率。同时，我们在赋值运算符函数内是不会改变传入的实例的状态的，因此应该为传入的引用参数加上const关键字。

·         是否记得释放实例自身已有的内存？如果忘了在分配新内存之前释放自身已有的空间，将出现内存泄露。

·         是否判断传入的参数是不是和当前的实例（*this）是不是同一个实例？如果是同一个，则不进行赋值操作，直接返回。如果事先不判断，就进行赋值，那么在释放实例自身的内存的时候就会导致严重的问题：当*this和传入的参数是同一个实例时，那么一旦释放了自身的内存，传入的参数的内存也同时被释放了，因此再也找不到需要赋值的内容了。

当我们完整地考虑了上述几方面之后，我们可以写出如下的代码：

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;
}

这是一般C++教材上提供的参考代码。如果是面试的是应届毕业生或者C++初级程序员，如果能全面地考虑到前面四点并完整地写出代码，面试官可能会让他通过这轮面试。但如果面试的是C++的高级程序员，面试官可能会提出更高的要求。

面试官会提醒我们在前面的函数中，显示地用delete释放自身m_pData的内存。同时我们也会在析构函数中用delete释放自身m_pData的内存。如果这个类型中添加新的指针成员变量，那么我们至少需要做两处修改，即同时在析构函数和这个赋值运算符函数里添加一条delete语句来释放新指针所指向的内存。一个改动需要在代码中多个地方修改代码，通常是有安全隐患的。通常我们会记得在析构函数里用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，并把strTemp的m_pData指向当前实例（*this）的m_pData。由于strTemp是个局部变量，但程序员运行到if的外面是也就出了的该变量的域，就会自动调用strTemp的析构函数，就会把strTemp.m_pData所指向的内存释放掉。由于strTemp.m_pData指向的内存就是当前实例之前m_pData的内存。这就相当于自动调用析构函数释放当前实例的内存。如果新增加指针成员变量，我们只需要在析构函数里正确地释放，而不需要对赋值运算符函数做任何修改。

2  

分析：这是Adobe公司2007年校园招聘的最新笔试题。这道题除了考察应聘者的C++基本功底外，还能考察反应能力，是一道很好的题目。

在Java中定义了关键字final，被final修饰的类不能被继承。但在C++中没有final这个关键字，要实现这个要求还是需要花费一些精力。

首先想到的是在C++ 中，子类的构造函数会自动调用父类的构造函数。同样，子类的析构函数也会自动调用父类的析构函数。要想一个类不能被继承，我们只要把它的构造函数和析构函数都定义为私有函数。那么当一个类试图从它那继承的时候，必然会由于试图调用构造函数、析构函数而导致编译错误。

可是这个类的构造函数和析构函数都是私有函数了，我们怎样才能得到该类的实例呢？这难不倒我们，我们可以通过定义静态来创建和释放类的实例。基于这个思路，我们可以写出如下的代码：

///

// Define a class which can't be derived from

///

class FinalClass1

{

public:

      static FinalClass1* GetInstance()

      {

            return new FinalClass1;

      }

 

      static void DeleteInstance( FinalClass1* pInstance)

      {

            delete pInstance;

            pInstance = 0;

      }

 

private:

      FinalClass1() {}

      ~FinalClass1() {}

};

这个类是不能被继承，但在总觉得它和一般的类有些不一样，使用起来也有点不方便。比如，我们只能得到位于堆上的实例，而得不到位于栈上实例。

能不能实现一个和一般类除了不能被继承之外其他用法都一样的类呢？办法总是有的，不过需要一些技巧。请看如下代码：

///

// Define a class which can't be derived from

///

template <typename T> class MakeFinal

{

      friend T;

 

private:

      MakeFinal() {}

      ~MakeFinal() {}

};

 

class FinalClass2 : virtual public MakeFinal<FinalClass2>

{

public:

      FinalClass2() {}

      ~FinalClass2() {}

};

这个类使用起来和一般的类没有区别，可以在栈上、也可以在堆上创建实例。尽管类MakeFinal<FinalClass2>的构造函数和析构函数都是私有的，但由于类FinalClass2是它的友元函数，因此在FinalClass2中调用MakeFinal<FinalClass2>的构造函数和析构函数都不会造成编译错误。

但当我们试图从FinalClass2继承一个类并创建它的实例时，却不同通过编译。

class Try : public FinalClass2

{

public:

      Try() {}

      ~Try() {}

};

 

Try temp;

由于类FinalClass2是从类MakeFinal<FinalClass2>虚继承过来的，在调用Try的构造函数的时候，会直接跳过FinalClass2而直接调用MakeFinal<FinalClass2>的构造函数。非常遗憾的是，Try不是MakeFinal<FinalClass2>的友元，因此不能调用其私有的构造函数。

基于上面的分析，试图从FinalClass2继承的类，一旦实例化，都会导致编译错误，因此是FinalClass2不能被继承。这就满足了我们设计要求。

3