C++解析三

类的构造函数
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
下面的实例有助于更好地理解构造函数的概念：

#include <iostream>
using namespace std;
class Line
{
    public:
        void setLength(double len);
        double getLength(void);
        Line();
    private:
        double length;
};

Line::Line(void)
{
    cout << "Object is being created" << endl;
}

void Line::setLength(double len)
{
    cout << "Debug 2" << endl;
    length = len;
}

double Line::getLength(void)
{
    return length;
}

int main()
{
    Line line;
    cout << "Debug 1" << endl;
    line.setLength(6.0);
    cout << "Length of line : " << line.getLength() << endl;
    return 0;
}

编译输出：

kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./constructor
Object is being created
Debug 1
Debug 2
Length of line : 6

带参数的构造函数
默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

#include <iostream>
using namespace std;
class Line
{
    public:
        void setLength(double len);
        double getLength(void);
        Line(double len);
    private:
        double length;
};

Line::Line(double len) //成员函数定义，包括构造函数
{
    cout << "Object is being created" << endl;
    length = len;
}

void Line::setLength(double len)
{
    cout << "Debug 2" << endl;
    length = len;
}

double Line::getLength(void)
{
    return length;
}

int main()
{
    Line line(10.0);
    cout << "Length of default line : " << line.getLength() << endl;//获取默认设置的长度
    line.setLength(6.0);
    cout << "Length of line : " << line.getLength() << endl;
    return 0;
}

编译输出：

kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./constructor_para
Object is being created
Length of default line : 10
Debug 2
Length of line : 6

使用初始化列表来初始化字段：

Line::Line(double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}

上面的语法等同于如下语法：

Line::Line(double len)
{
    length = len;
    cout << "Object is being created, length = " << len << endl;
}

假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：

C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
  ....
}

类的析构函数
类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
下面的实例有助于更好地理解析构函数的概念：

#include <iostream>
using namespace std;
class Line
{
    public:
        void setLength(double len);
        double getLength(void);
        Line();
        ~Line();
    private:
        double length;
};

Line::Line(void) //成员函数定义，包括构造函数
{
    cout << "Object is being created" << endl;
}

Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}

void Line::setLength(double len)
{
    cout << "Debug 2" << endl;
    length = len;
}

double Line::getLength(void)
{
    return length;
}

int main()
{
    Line line;
    line.setLength(6.0);
    cout << "Length of line : " << line.getLength() << endl;
    return 0;
}

编译输出：

kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./deconstructor
Object is being created
Debug 2
Length of line : 6
Object is being deleted

构造函数应用举例：

#include <iostream>
#include <string>
using namespace std;

class Student
{
    public:
        string name;
        string number;
        char X;
        int year;
        Student(string, string, char, int); //构造函数声明
        void display(void);
};

Student::Student(string N, string n, char x, int y) //利用构造函数给类的成员赋值
{
    name = N;
    number = n;
    X = x;
    year = y;
}

void Student::display() //输出成员的值
{
    cout << name << endl;
    cout << number << endl;
    cout << X << endl;
    cout << year << endl;
}

int main()
{
    cout << "输入姓名：";
    string N;
    cin >> N;
    cout << "输入学号：";
    string n;
    cin >> n;
    cout << "输入性别(M或W)：";
    char x;
    cin >> x;
    cout << "输入年龄：";
    int y;
    cin >> y;
    Student S(N, n, x, y); //定义对象并对构造函数赋值
    S.display();    //引用输出函数
    return 0;
}

编译输出：

kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./cons_exam
输入姓名：kevin
输入学号：10
输入性别(M或W)：M
输入年龄：20
kevin
10
M
20

初始化列表的成员初始化顺序:
C++ 初始化类成员时，是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

class CMyClass {
    CMyClass(int x, int y);
    int m_x;
    int m_y;
};

CMyClass::CMyClass(int x, int y) : m_y(y), m_x(m_y)
{
};

你可能以为上面的代码将会首先做 m_y=y，然后做 m_x=m_y，最后它们有相同的值。但是编译器先初始化 m_x，然后是 m_y,，因为它们是按这样的顺序声明的。结果这样的话， m_x 将有一个不可预测的值。有两种方法避免它，一个是总是按照你希望它们被初始化的顺序声明成员，第二个是，如果你决定使用初始化列表，总是按照它们声明的顺序罗列这些成员。这将有助于消除混淆。

 拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：
1) 通过使用另一个同类型的对象来初始化新创建的对象。
2) 复制对象把它作为参数传递给函数。
3) 复制对象，并从函数返回这个对象。
如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：

classname (const classname &obj) {
   // 构造函数的主体
}

在这里，obj 是一个对象引用，该对象是用于初始化另一个对象的。

#include <iostream>
using namespace std;
class Line
{
   public:
      int getLength( void );
      Line( int len );             // 简单的构造函数
      Line( const Line &obj);      // 拷贝构造函数
      ~Line();                     // 析构函数
   private:
      int *ptr;
};
 
// 成员函数定义，包括构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}
 
Line::Line(const Line &obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}
 
Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}
int Line::getLength( void )
{
    return *ptr;
}
 
void display(Line obj)
{
   cout << "line 大小 : " << obj.getLength() <<endl;
}
 
// 程序的主函数
int main( )
{
   Line line(10);
   display(line);
   return 0;
}

编译输出：

kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./cp_constructor 
调用构造函数
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
释放内存

下面的实例对上面的实例稍作修改，通过使用已有的同类型的对象来初始化新创建的对象：

#include <iostream>
using namespace std;
class Line
{
   public:
      int getLength( void );
      Line( int len );             // 简单的构造函数
      Line( const Line &obj);      // 拷贝构造函数
      ~Line();                     // 析构函数
   private:
      int *ptr;
};
 
// 成员函数定义，包括构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}
 
Line::Line(const Line &obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}
 
Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}
int Line::getLength( void )
{
    return *ptr;
}
 
void display(Line obj)
{
   cout << "line 大小 : " << obj.getLength() <<endl;
}
 
// 程序的主函数
int main( )
{
   Line line1(10);
   Line line2 = line1; // 这里也调用了拷贝构造函数
   display(line1);
   display(line2);
 
   return 0;
}

编译输出：

调用构造函数
调用拷贝构造函数并为指针 ptr 分配内存
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
释放内存
释放内存

拷贝构造函数的调用时机

在C++中，下面三种对象需要调用拷贝构造函数！
1. 对象以值传递的方式传入函数参数

class CExample 
{
    private:
        int a;

    public:
        //构造函数
        CExample(int b)
        { 
            a = b;
            cout<<"creat: "<<a<<endl;
        }

        //拷贝构造
        CExample(const CExample& C)
        {
            a = C.a;
            cout<<"copy"<<endl;
        }

        //析构函数
        ~CExample()
        {
            cout<< "delete: "<<a<<endl;
        }

        void Show ()
        {
            cout<<a<<endl;
        }
};
//全局函数，传入的是对象
void g_Fun(CExample C)
{
    cout<<"test"<<endl;
}

int main()
{
    CExample test(1);
    //传入对象
    g_Fun(test);
    return 0;
}

调用g_Fun()时，会产生以下几个重要步骤：
(1). test对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
(2). 然后调用拷贝构造函数把test的值给C。 整个这两个步骤有点像：CExample C(test);
(3). 等g_Fun()执行完后, 析构掉 C 对象。

拷贝构造函数几个原则：
C++ primer p406 ：拷贝构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时，将显示使用拷贝构造函数。当该类型的对象传递给函数或从函数返回该类型的对象时，将隐式调用拷贝构造函数。
C++支持两种初始化形式：
拷贝初始化 int a = 5; 和直接初始化 int a(5); 对于其他类型没有什么区别，对于类类型直接初始化直接调用实参匹配的构造函数，拷贝初始化总是调用拷贝构造函数，也就是说：
A x(2);　　 //直接初始化，调用构造函数
A y = x;　　//拷贝初始化，调用拷贝构造函数
必须定义拷贝构造函数的情况：
只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义拷贝构造函数也可以拷贝；有的类有一个数据成员是指针，或者是有成员表示在构造函数中分配的其他资源，这两种情况下都必须定义拷贝构造函数。

什么情况使用拷贝构造函数：
类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
（1）一个对象以值传递的方式传入函数体
（2）一个对象以值传递的方式从函数返回
（3）一个对象需要通过另外一个对象进行初始化。