C/C++面试题：编写类String的构造函数、析构函数和赋值函数。

考点：构造函数、析构函数和赋值函数的编写方法
出现频率：☆☆☆☆☆
已知类String的原型为：
        class String
        {
        public:
                String(const char *str = NULL);     //普通构造函数
                String(const String &other);        //拷贝构造函数
                ~ String(void);                    //析构函数
                String & operator =(const String &other); //赋值函数
        private:
                char *m_String;                  //私有成员，保存字符串
        };
解析：
程序代码如下：

 #include <iostream>
        using namespace std;
        class String
        {
        public:
                String(const char *str = NULL);          //普通构造函数
                String(const String &other);             //拷贝构造函数
                ~ String(void);                         //析构函数
                String & operator =(const String &other);  //赋值函数
        private:
                char *m_String;    //私有成员，保存字符串
        };
        
        String::~String(void)             
        {
                cout << "Destructing"<< endl;
                if (m_String != NULL)                  //如果m_String不为NULL，释放堆内存
                {
                        delete [] m_String;
                        m_String = NULL;                //释放后置为NULL
                }
        }
        
        String::String(const char *str)      
        {
                cout << "Construcing" << endl; 
                if(str == NULL)                        //如果str为NULL，存空字符串""
                {
                        m_String = new char[1];            //分配一个字节
                        *m_String = '';                   //将之赋值为字符串结束符
                }     
                else
                {
                        m_String = new char[strlen(str) + 1]; //分配空间容纳str内容
                        strcpy(m_String, str);              //拷贝str到私有成员
                }
        }
        
        String::String(const String &other)  
        {
                cout << "Constructing Copy" << endl;
                m_String = new char[strlen(other.m_String) + 1];  //分配空间容纳str内容
                strcpy(m_String, other.m_String);               //拷贝str到私有成员
        }
        
        String & String:perator = (const String &other)   
        {
                cout << "Operate = Function" << endl; 
                if(this == &other)             //如果对象与other是同一个对象
                {                           //直接返回本身
                        return *this;
                }
                delete [] m_String;           //释放堆内存
                m_String = new char[strlen(other.m_String)+1];         
                strcpy(m_String, other.m_String);
        
                return *this;
        }
        
        int main()
        {
                String a("hello");            //调用普通构造函数
                String b("world");           //调用普通构造函数
                String c(a);                //调用拷贝构造函数
                c = b;                     //调用赋值函数
        
                return 0;
        }

1）普通构造函数：这里判断了传入的参数是否为NULL。如果是NULL，初始化一个字节的空字符串（包括结束符''）；如果不是，分配足够大小长度的堆内存保存字符串。
（2）拷贝构造函数：只是分配足够小长度的堆内存保存字符串。
（3）析构函数：如果类私有成员m_String不为NULL，释放m_String指向的堆内存，并且为了避免产生野指针，将m_String赋为NULL。
（4）赋值函数：首先判断当前对象与引用传递对象是否是同一个对象，如果是，不做操作直接返回；否则先释放当前对象的堆内存，然后分配足够大小长度的堆内存拷贝字符串。
程序的执行结果如下：

 Construcing
        Construcing
        Construcing Copy
        Operate = Function
        Destructing
        Destructing
        Destructing
这里代码第63~66行会发生构造函数以及赋值函数的调用，而析构函数的调用发生在main()函数退出时