C++复制构造函数，类型转换构造函数，析构函数,引用，指针常量和常量指针

复制构造函数
形如className :: className(const &)   /   className :: className(const className &)后者能以常量对象作为参数
如不写复制构造函数，则编译器默认提供，为了完成对象的复制功能

它起作用有三个工作环境：

1.一个对象初始化另一个同类的对象

 Simple c2(c1);
 Simple c2 = c1;//初始化

2.如果某函数有一个参数是类的一个对象，那么该函数被调用时，类的复制构造函数被调用

 Simple A
 {
     pbulic:
     A(){};
     A(A & a)
     {
         cout<<.....<<endl;
     }
 };
 void Fun(A a1){}
 int main()
 {
     A a;
     Fun(a);//.....
     return ;
 }

3.如果函数的返回值是类的对象时，则函数返回是，类的复制构造函数被调用

 class Simple
 {
     pbulic:
         int x;
         Simple(int n){x = n;};
         Simple(const Simple & a)
         {
             x = a.x;
             cout<<"Copy constructor called"<<endl;
         }
 };
 Simple Fun()
 {
     Simple b();
     return b;//作为复制构造函数的参数
 }
 int main()
 {
     cout<<Fun().x<<endl;// Copy constructor called 100
     return ;
 }

注意：对象间的赋值不导致复制构造函数的调用

A c1,c2;
c2 = c1 ;//不会调用
A C3(C1);//这是初始化操作，会调用赋值构造函数

在函数参数列表中，为节省开销，不引发复制构造函数的调用，使用ClassName & 引用类型为参数，
又为了确保实参值不变，再在引用前加上const关键字。复制构造函数往往加const和&，具体可以点这里

---

类型转换构造函数

它的目的是实现类型的自动转换，并且只有一个参数。当需要的时候，编译系统会自动调用转换构造函数，建立

一个无名的临时对象(或临时变量)。

 class Complex
 {
 public:
     double real, imag;
     Complex( int i)
     {//类型转换构造函数
         cout << "IntConstructor called" << endl;
     real = i; imag = ;
     }
     Complex(double r,double i) {real = r; imag = i; }
 };
 int main ()
 {
     Complex c1(,);
     Complex c2 = ;
     c1 = ; // 9被自动转换成一个临时Complex对象
     cout << c1.real << "," << c1.imag << endl;
     return ;
 }            

 class Complex
 {
 public:
     double real, imag;
     explicit Complex( int i)
     {//显式类型转换构造函数
         cout << "IntConstructor called" << endl;
         real = i; imag = ;
     }
     Complex(double r,double i) {real = r; imag = i; }
 };
 int main ()
 {
     Complex c1(,);
     Complex c2 = Complex();
     c1 = ; // error, 9不能被自动转换成一个临时Complex对象
     c1 = Complex() //ok
     cout << c1.real << "," << c1.imag << endl;
     return ;
 }

---

析构函数:~类名(){}

它没有返回值和参数，一个类对应一个析构函数，在类的对象消亡时自动调用，也可以手动调用进行对象消亡的善后工作。如果懒的去写，编译器自动会生成缺省析构函数，但是什么也不做，如果写了，就不自动生成了。

 class Simple
 {
 private :
     char * p;
 public:
     Simple()
     {
         p = new char[];
     }
     ~ Simple () ;
 };
 Simple ::~ Simple()
 {
     delete [] p;
 }

在对一个对象进行delete时，调用一次析构函数，在delete[]对象数组时，会调用n次析构函数，取决于数组大小。此外：

 class CMyclass
 {
 public:
     ~CMyclass() { cout << "destructor" << endl; }
 };
 CMyclass obj;
 CMyclass fun(CMyclass sobj )
 { //参数对象消亡也会导致析
 //构函数被调用
     return sobj; //函数调用返回时生成临时对象返回
 }
 int main()
 {
     obj = fun(obj); //函数调用的返回值（临时对象）被
     return ; //用过后，该临时对象析构函数被调用
 }
 //destructor形参对象消亡
 //destructor临时对象消亡
 //destructor全局对象消亡

new出来的对象或对象数组，不delete就不会消亡，就不会调用析构函数！！不是new出来的，则在生命期结束会自动调用

---

关于引用：引用是C++有的，C所没有的，标志为 &，即C的取地址符。它的声明为这样

 int n = ;
 int & r = n; //r为 int & 类型  

其中r和n指向同一片地址空间 ，对 r和n的修改都会改变原来是4的那个值，相当于为n取了个别名r

在定义引用时一定要将其初始化成引用某个变量。并且之后不会引用别的变量
只能引用变量，不能引用常量和表达式

一个简单而又形象的，见得次数很多的例子：交换元素

 void swap( int * a, int * b)
 {
     int tmp;
     tmp = * a;
     * a = * b;
     * b = tmp;
 }
 int n1, n2;
 swap(& n1,& n2) ; // n1,n2的值被交换

 //用了引用
 void swap( int & a, int & b)
 {
     int tmp;
     tmp = a;
     a = b;
     b = tmp;
 }
 int n1, n2;
 swap(n1,n2) ; // n1,n2的值被交换

 //en ..交换还可以这样写，当然远不如swap(a,b)写的快哈
     int a = ;
     int b = ;
     a = a + b;
     b = a - b;
     a = a - b;
     cout<<a<<" "<<b<<endl;
     a = a ^ b;
     b = a ^ b;
     a = a ^ b;
     cout<<a<<" "<<b<<endl;

引用还可以作为函数的返回值

 int n = ;
 int & SetValue()
 {
     return n;
 }
 int main()
 {
     SetValue() = ;
     cout << n;return ;
 } //输出： 40

---

关于常引用：

int n;
const int & r = n;
r = 10;//error 不能通过常引用r改变n的值
n = 30;//n的值可以变化
const T & 和T & 是不同的类型!!!
T & 类型的引用或T类型的变量可以用来初始化const T & 类型的引用。
int n = 8;
int & r1 = n;
const int r2 = r1;//初始化const T & 类型的引用。
const T 类型的常变量和const T & 类型的引用则不能用来初始化T &类型的引用，
除非进行强制类型转换

---

常量指针：

 //1.
 int n,m
 const int * p = n;//常量指针
 *p = //error  不可以通过修改常量指针修改指向的内容
 n = ;//ok
 p = & m;//ok 常量指针可以指向别的内容
 
 //2.不可以把常量指针赋值给非常量指针(强转可以)，反之可以
 const int * p;
       int * p2;
 p1 = p2; //ok
 p2 = p1; //error
 p2 = (int * ) p1; //ok,强制类型转换

指针常量：

 int a,b;
 int const *p = & a;
 * p = ;//通过指针修改所指向的内容，ok
 p = & b;//error  不可更改所指向的地址

这两个不要搞混淆了。。。。

简单的记忆，抓住第一个是常量在前，就意味着整个后面的地址内容是个常量，不可以通过指针去修改它，但是指向谁是可以变的；指针常量，这个常量在指针后面，表明这个指针所指向的地址不能变了，但你可以用它修改地址所对应的内容。。

---

动态内存分配：

变量: int * px = new int; //大小为sizeof(int)
数组: int * pn = new int[20];
释放动态分配的内存：
int * px = new int;
delete px;//只能删除一次
//数组
int * pn = new int[20];
delete [] pn;