1 class Counter
 2 {
 3
 4 public:
 5          // 类Counter的构造函数
 6          // 特点：以类名作为函数名，无返回类型
 7          Counter()
 8          {
 9                 m_value = 0;
10          }
11
12 private:
13
14          // 数据成员
15          int m_value;
16 }

 1 class Complex
 2 {
 3
 4 private :
 5         double    m_real;
 6         double    m_imag;
 7
 8 public:
 9
10         //    无参数构造函数
11         // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
12         // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
13         Complex(void)
14         {
15              m_real = 0.0;
16              m_imag = 0.0;
17         }
18
19         //    一般构造函数（也称重载构造函数）
20         // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
21         // 例如：你还可以写一个 Complex( int num)的构造函数出来
22         // 创建对象时根据传入的参数不同调用不同的构造函数
23         Complex(double real, double imag)
24         {
25              m_real = real;
26              m_imag = imag;
27          }
28
29         //    复制构造函数（也称为拷贝构造函数）
30         //    复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
31         //    若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述
32         Complex(const Complex & c)
33         {
34                 // 将对象c中的数据成员值复制过来
35                 m_real = c.m_real;
36                 m_img    = c.m_img;
37         }
38
39         // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
40         // 例如：下面将根据一个double类型的对象创建了一个Complex对象
41         Complex::Complex(double r)
42         {
43                 m_real = r;
44                 m_imag = 0.0;
45         }
46
47         // 等号运算符重载
48         // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
49         // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
50         Complex &operator=( const Complex &rhs )
51         {
52                 // 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
53                 if ( this == &rhs )
54                 {
55                         return *this;
56                 }
57
58                 // 复制等号右边的成员到左边的对象中
59                 this->m_real = rhs.m_real;
60                 this->m_imag = rhs.m_imag;
61
62                // 把等号左边的对象再次传出
63                // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
64                // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
65                 return *this;
66         }
67
68 };

 1 void main()
 2 {
 3         // 调用了无参构造函数，数据成员初值被赋为0.0
 4         Complex c1，c2;
 5
 6         // 调用一般构造函数，数据成员初值被赋为指定值
 7         Complex c3(1.0,2.5);
 8         // 也可以使用下面的形式
 9         Complex c3 = Complex(1.0,2.5);
10
11         //    把c3的数据成员的值赋值给c1
12         //    由于c1已经事先被创建，故此处不会调用任何构造函数
13         //    只会调用 = 号运算符重载函数
14         c1 = c3;
15
16         //    调用类型转换构造函数
17         //    系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
18         c2 = 5.2;
19
20        // 调用拷贝构造函数( 有下面两种调用方式)
21         Complex c5(c2);
22         Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
23
24
25
26 }

      Complex(const Complex & c){// 将对象c中的数据成员值复制过来m_real = c.m_real;m_img = c.m_img;}    

 1  Complex test1(const Complex& c)
 2   {
 3           return c;
 4   }
 5
 6   Complex test2(const Complex c)
 7   {
 8          return c;
 9    }
10
11    Complex test3()
12    {
13           static Complex c(1.0,5.0);
14           return c;
15    }
16
17   Complex& test4()
18   {
19          static Complex c(1.0,5.0);
20          return c;
21   }
22
23   void main()
24   {
25         Complex a,b;
26
27         // 下面函数执行过程中各会调用几次构造函数，调用的是什么构造函数？
28
29        test1(a);
30        test2(a);
31
32        b = test3();
33        b = test4();
34
35        test2(1.2);
36        // 下面这条语句会出错吗？
37        test1(1.2);     //test1( Complex(1.2 )) 呢？
38   }

 1 #include <iostream.h>
 2 #include <string.h>
 3 class Person
 4 {
 5 public :
 6
 7         // 构造函数
 8         Person(char * pN)
 9         {
10               cout << "一般构造函数被调用 !\n";
11               m_pName = new char[strlen(pN) + 1];
12               //在堆中开辟一个内存块存放pN所指的字符串
13               if(m_pName != NULL)
14               {
15                  //如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
16                    strcpy(m_pName ,pN);
17               }
18         }
19
20         // 系统创建的默认复制构造函数，只做位模式拷贝
21         Person(Person & p)
22         {
23                   //使两个字符串指针指向同一地址位置
24                  m_pName = p.m_pName;
25         }
26
27         ~Person( )
28         {
29                 delete m_pName;
30         }
31
32 private :
33
34         char * m_pName;
35 };
36
37 void main( )
38 {
39         Person man("lujun");
40         Person woman(man);
41
42         // 结果导致   man 和    woman 的指针都指向了同一个地址
43
44         // 函数结束析构时
45         // 同一个地址被delete两次
46 }
47
48
49 // 下面自己设计复制构造函数，实现“深拷贝”，即不让指针指向同一地址，而是重新申请一块内存给新的对象的指针数据成员
50 Person(Person & chs);
51 {
52          // 用运算符new为新对象的指针数据成员分配空间
53          m_pName=new char[strlen(p.m_pName)+ 1];
54
55          if(m_pName)
56          {
57                  // 复制内容
58                 strcpy(m_pName ,chs.m_pName);
59          }
60
61         // 则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了
62 }