[C/C++]和指针类默认生成的四个函数

序：对于一个空类，编译器默认生成四个成员函数：默认构造函数、析构函数、拷贝构造函数、赋值函数
一，默认构造函数
       默认构造函数（default constructor）就是在没有显式提供初始化式时调用的构造函数。它由不带参数的构造函数，或者为所有的形参提供默认实参的构造函数定义。如果定义某个类的变量时没有提供初始化式就会使用默认构造函数。
　　如果用户定义的类中没有显式的定义任何构造函数，编译器就会自动为该类型生成默认构造函数，称为合成的构造函数（synthesized default constructor）。

        C++语言为类提供的构造函数可自动完成对象的初始化任务
        全局对象和静态对象的构造函数在main()函数执行之前就被调用，局部静态对象的构造函数是当程序第一次执行到相应语句时才被调用。然而给出一个外部对象的引用性声明时，并不调用相应的构造函数，因为这个外部对象只是引用在其他地方声明的对象，并没有真正地创建一个对象。　　
       C++的构造函数定义格式为：　　
               class <类名> 　　
             { 　　
                  public: 　　<类名>(参数表) 　　//...(还可以声明其它成员函数) 　　
             }; 　　
               <类名>::<函数名>(参数表) 　
               　{ 　　//函数体　　} 　　
      如以下定义是合法的：　　
             class T 　　
           { 　　
               public: 　　T(int a=0){i=a;}//构造函数允许直接写在类定义内，也允许有参数表。　　
               private:int i; 　　
           }; 　　

二，析构函数
       当程序员没有给类创建析构函数，那么系统会在类中自动创建一个析构函数，形式为：~A（）{},为类A创建的析构函数。当程序执行完后，系统自动调用自动创建的析构函数，将对象释放。
       默认的析构函数不能删除new运算符在自由存储器中分配的对象或对象成员。如果类成员占用的空间是在构造函数中动态分配的，我们就必须自定义析构函数，然后显式使用delete运算符来释放构造函数使用new运算符分配的内存，就像销毁普通变量一样
#include   <iostream>
using   namespace   std;
class   Pig
{
public:
Pig()
{
cout < < "Pig   constructed " < <endl;
}
~Pig()
{
cout < < "Pig   destructed " < <endl;
}
};
class   Japanese:Pig
{

};
int   main()
{
Japanese   dog;
return   0;
}
输出：
Pig constructed
Pig destructed
如果改成一下new 生成的对象则不调用默认析构函数
int main()
{
Japanese *dog=new Japanese;
return 0;
}
输出就只有：
Pig constructed

三，拷贝构造函数
        CExample(const CExample&); //参数是const 对象的引用&
【注意】如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。
      以类String的两个对象a,b为例，假设a.m_data的内容为“hello”，b.m_data的内容为“world”。
      现将a赋给b，缺省赋值函数的“位拷贝”意味着执行b.m_data = a.m_data。这将造成三个错误：一是b.m_data原有的内存没被释放，造成内存泄露；二是b.m_data和a.m_data指向同一块内存，a或b任何一方变动都会影响另一方；三是在对象被析构时，m_data被释放了两次。
1）默认拷贝构造函数
      对于普通类型的对象来说，它们之间的复制是很简单的，例如：
             int a=88;
             int b=a; //复制
      而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。
下面看一个类对象拷贝的简单例子。
#include <iostream>
using namespace std;

class CExample {
private:
　int a;
public:
　CExample(int b)
　{ a=b;}
　void Show ()
　{
cout<<a<<endl;
}
};

int main()
{
　CExample A(100);
　CExample B=A;
　B.Show ();
　return 0;
}

运行程序，屏幕输出100。
系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。
2）显式拷贝构造函数
#include <iostream>
using namespace std;

class CExample {
private:
int a;
public:
CExample(int b)
{ a=b;}

CExample(const CExample& C)//拷贝构造函数
{
a=C.a;
}
void Show ()
{
cout<<a<<endl;
}
};

int main()
{
   CExample A(100);
   CExample B=A;
   B.Show ();
   return 0;
}

       CExample(constCExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。
          当用一个已初始化过了的对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
          一个对象以值传递的方式传入函数体
          一个对象以值传递的方式从函数返回
          一个对象需要通过另外一个对象进行初始化。
        如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。
     浅拷贝和深拷贝
　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
3）深拷贝（主要应对类中有指针变量的情况）
#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　

补充：软件开发 , C++ ,