c++的构造函数

我刚学的知识：c++的构造函数。
在在此之前一直都处于迷惑之中，现在怕忘。所以赶紧把他写下来，用来以后复习，可能有错误的地方，请大牛们指出来。
c++知识相对与c来说更加抽象，但真明白了，也就那一回事。这话是学长说的，而我刚把构造函数学会，还在晕着别的地方。
c++的构造函数分为3种：
//一。不带参的构造函数
*#include"iostream"
using namespace std;
class aaa
{
public:
 aaa()
 {
  cout << "默认构造函数已初始化" << endl;
 }
 ~aaa()
 {}
};
int main()
{
 aaa bbb;
 return 0;

}
}//结果会输出俩个123
//二。带参的构造函数
#include"iostream"
using namespace std;
class aaa
{
 int x;
 int y;
public:
 aaa(int a, int b)
 {
  x = a;
  y = b;
  cout << "("<<a << ","<<b <<")"<< "带参构造函数已初始化" << endl;
 }
 ~aaa()
 {
 }
};
int main()
{
 aaa bbb(1, 2);
三。委托构造函数

#include"iostream"
using namespace std;
int i=0;
class aaa
{
public:
 aaa()//建立一个aaa的构造函数
 {
  cout << "构造函数已初始化" << i++<<endl;
 }
 ~aaa()
 {

 }
};
class bbb:public aaa
{
public:
 bbb() :aaa(){};//bbb的构造函数借用aaa的
};
int main()
{
 bbb lol;//建立一个bbb的对象
 return 0;
}

四。复制构造函数

#include"iostream"
using namespace std;
class aaa
{
 int a;
public:
 aaa(int b)
 {
  a = b;
 }
 aaa(const aaa& c)
 {
  a = c.a;
 }
 void show()
 {
  cout << a << endl;
 }
};
int main()
{
 aaa A(100);
 aaa B = A;//复制
 A.show();
 B.show();
 return 0;
}

1.什么是拷贝构造函数：

CA(const CA& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。
    当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：

① 程序中需要新建立一个对象，并用另一个同类的对象对它初始化，如前面介绍的那样。

② 当函数的参数为类的对象时。在调用函数时需要将实参对象完整地传递给形参，也就是需要建立一个实参的拷贝，这就是按实参复制一个形参，系统是通过调用复制构造函数来实现的，这样能保证形参具有和实参完全相同的值。

③ 函数的返回值是类的对象。在函数调用完毕将返回值带回函数调用处时。此时需要将函数中的对象复制一个临时对象并传给该函数的调用处。如

Box f( )                     //函数f的类型为Box类类型

{Box box1(12,15,18);

return box1;               //返回值是Box类的对象

}

int main( )

{Box box2;                   //定义Box类的对象box2

box2=f( );                   //调用f函数，返回Box类的临时对象，并将它赋值给box2

}

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。
　　自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝
　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

2.C++拷贝构造函数的几个细节

 

1) 以下函数哪个是拷贝构造函数,为什么?

1.X::X( const  X&);   

2.X::X(X);   

3.X::X(X&,  int  a=1);   

4.X::X(X&,  int  a=1, b=2);  

解答：1) 对于一个类X,如果一个构造函数的第一个参数是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数. 

1.X::X( const  X&);   //是拷贝构造函数   

2.X::X(X&,  int =1);  //是拷贝构造函数   

 复制是我节选别人的，还望不要见怪，原谅我这个新手。

2) 一个类中可以存在多于一个的拷贝构造函数吗?  

 解答：类中可以存在超过一个拷贝构造函数,  

1.class  X {      

2.public :      

1. 3.  X( const  X&);      
2. 4.  X(X&);             // OK   

5.};  

注意,如果一个类中只存在一个参数为X&的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.

1.class  X {   

2.public :   

1. 3.  X();   
2. 4.  X(X&);   

5.};   

1. 6.    

7.const  X cx;   

8.X x = cx;     // error   

如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数.
这个默认的参数可能为X::X(const X&)或X::X(X&),由编译器根据上下文决定选择哪一个.

默认拷贝构造函数的行为如下:
     默认的拷贝构造函数执行的顺序与其他用户定义的构造函数相同,执行先父类后子类的构造.
 拷贝构造函数对类中每一个数据成员执行成员拷贝(memberwise Copy)的动作.
 a)如果数据成员为某一个类的实例,那么调用此类的拷贝构造函数.
 b)如果数据成员是一个数组,对数组的每一个执行按位拷贝.
 c)如果数据成员是一个数量,如int,double,那么调用系统内建的赋值运算符对其进行赋值.

3) 拷贝构造函数不能由成员函数模版生成.  

struct  X {   

 template < typename  T>   

X(  const  T& );     // NOT copy ctor, T can't be X   

       template < typename  T>   

      operator=(  const  T& );   // NOT copy ass't, T can't be X   

};   

原因很简单, 成员函数模版并不改变语言的规则,而语言的规则说,如果程序需要一个拷贝构造函数而你没有声明它,那么编译器会为你自动生成一个. 所以成员函数模版并不会阻止编译器生成拷贝构造函数, 赋值运算符重载也遵循同样的规则

3.拷贝构造函数与赋值函数的异同：

1) 拷贝构造，是一个的对象来初始化一片内存区域，这片内存区域就是你的新对象的内存区域赋值运算，对于一个已经被初始化的对象来进行operator=操作

class   A;    

 A  a; 

 A  b=a;   //拷贝构造函数调用 

 //或 

 A  b(a);   //拷贝构造函数调用 

 ///////////////////////////////////     

 A  a; 

 A  b; 

 b =a;   //赋值运算符调用  

你只需要记住，在C++语言里， 

 String   s2(s1); 

 String   s3 = s1; 

 只是语法形式的不同，意义是一样的，都是定义加初始化，都调用拷贝构造函数。

2）一般来说是在数据成员包含指针对象的时候，应付两种不同的处理需求的一种是复制指针对象，一种是引用指针对象 copy大多数情况下是复制，=则是引用对象的    

例子： 

  class   A 

  { 

          int   nLen; 

          char   *   pData; 

  } 

  显然 

  A   a,   b; 

  a=b的时候，对于pData数据存在两种需求 

  第一种copy 

      a.pData   =   new   char   [nLen]; 

      memcpy(a.pData,   b.pData,   nLen); 

  另外一种(引用方式)： 

      a.pData   =   b.pData 

  

  通过对比就可以看到，他们是不同的 

  往往把第一种用copy使用，第二种用=实现

  你只要记住拷贝构造函数是用于类中指针，对象间的COPY 

3）拷贝构造函数首先是一个构造函数，它调用的时候产生一个对象，是通过参数传进来的那个对象来初始化，产生的对象。 

  operator=();是把一个对象赋值给一个原有的对象，所以如果原来的对象中有内存分配要先把内存释放掉，而且还要检查一下两个对象是不是同一个对象，如果是的话就不做任何操作。

还要注意的是拷贝构造函数是构造函数，不返回值  

而赋值函数需要返回一个对象自身的引用，以便赋值之后的操作  

4) 在形式上

类名(形参表列);          //普通构造函数的声明，如Box(int h,int w,int len);

类名(类名& 对象名);     //复制构造函数的声明，如Box(Box &b);

5) 在建立对象时，实参类型不同。系统会根据实参的类型决定调用普通构造函数或复制构造函数。如:

Box box1(12,15,16);           //实参为整数，调用普通构造函数

Box box2(box1);               //实参是对象名，调用复制构造函数

复制是我节选别人的，还望不要见怪，因为感觉大神说的比较全面

大神链接：

http://blog.chinaunix.net/uid-21411227-id-1826742.html