C++ Special: 复制构造函数、虚析构函数、运算符重载（友元）

参考链接：

http://www.cnblogs.com/mr-wid/archive/2013/02/20/2919842.html

http://blog.csdn.net/hackbuteer1/article/details/7558868

http://blog.csdn.net/starlee/article/details/619827

一般而言，C++创建一个新类的时候，需要留意是否需要写自己的复制构造函数和运算符重载。这和Java创建一个新类的时候，需要考虑是否需要覆盖Override其中的equals, hashCode方法一样。

一般而言，需要些自己的复制构造函数的时候，是当你的类成员存在数组、指针成员的时候。这时候创建一个复制类的时候，如果默认的行为是进行浅复制。如果需要深复制的时候，则需要自己定义一个复制构造函数。如下面的例子：

#include <iostream>
    #include <cstring>

    using namespace std;

    class Book
    {
        public:
            Book( const char *name )
            {
                bookName = new char [strlen(name)+1];
                strcpy(bookName, name);
            }
            Book( const Book &obj )     //显式定义复制构造函数
            {
                bookName = new char [strlen(obj.bookName)+1];       //调用复制构造函数时再次申请一处新的空间
                strcpy(bookName, obj.bookName);
            }
            ~Book() { delete []bookName; }      //释放申请的空间
            void showName(){ cout<<"Book name: " << bookName << endl; }

        private:
            char *bookName;
    };

    int main()
    {
        Book CPP("C++ Primer");
        Book T = CPP;       //使用 CPP 初始化对象 T
        CPP.showName();
        CPP.~Book();        //手动释放对象CPP所申请的空间

        T.showName();

        return 0;
    }

而运算符重载则发生在同样的功能在对应输入类型不同的时候，行为不同的情况。运算符重载一般以成员方法、友元方法的形式存在。因为运算符重载的实质其实是函数重载。函数重载指的是，函数的名字相同，只是输入类型不同的时候，重写函数行为的方式。注意，一般不以返回值作为重载的识别方式。语法如下：

1）作为类的成员方法：

 

#include <iostream>
using namespace std;
class Complex
{
public:
	Complex(){
		real=0;
		imag=0;
	}
	Complex(double r,double i){
		real=r;
		imag=i;
	}
	Complex operator+(Complex &c2); //声明重载运算符的函数
void display( );
private:
double real;
double
imag
;
};
Complex Complex
∷operator+(Complex &c2) //
定义重载运算符的函数
{
Complex c;
c.real=real+c2.real;
c.
imag
=
imag
+c2.
imag
; return c;}

2）作为友元函数（友元可以访问该类的私有成员）

#include <iostream>
using namespace std;
class Complex
{public:
Complex( ){real=0;
imag =0;}
Complex(double r,double i){real=r;
imag =i;}
friend Complex operator + (Complex &c1,Complex &c2);//
重载函数作为友元函数
void display( );
private:
double real;
double imag;

友元的存在是为了只需要在友好的类里面声明一下这个函数、类是友元。之后就可以在类外任何地方定义。而且在友元函数、友元类内可以使用该类的私有成员。

那么，对于虚构方法而言，为什么需要使用虚的呢？虚析构函数一般定义在父类的析构函数上。参考这篇博客（http://blog.csdn.net/starlee/article/details/619827）便知：为了使用向上转型的指针指向子类对象的时候，能真正调用到子类的析构函数。否则，当你delete父类的指针的时候，调用的是父类的析构函数。

class ClxBase
{
public:
    ClxBase() {};
    virtual ~ClxBase() {};

    virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };
};

class ClxDerived : public ClxBase
{
public:
    ClxDerived() {};
    ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; }; 

    void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };
};

int main() {
  ClxBase *pTest = new ClxDerived;
  pTest->DoSomething();
  delete pTest;
}

输出结果是：


Do something in class ClxDerived!
Output from the destructor of class ClxDerived!
    

这个很简单，非常好理解。
    

但是，如果把类ClxBase析构函数前的virtual去掉，那输出结果就是下面的样子了：


Do something in class ClxDerived!
    

也就是说，类ClxDerived的析构函数根本没有被调用！一般情况下类的析构函数里面都是释放内存资源，而析构函数不被调用的话就会造成内存泄漏。