拷贝函数和构造函数

类的构造函数：

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回void。

构造函数可用于为某些成员变量初始值。

默认的构造函数是没有任何参数的，但是如果需要，构造函数也是可以带参数的。这样在创建对象时就可以给对象赋初值了。

/***
construct.cpp
***/
#include<iostream>
#include<string>
using namespace std;

class Student 
{
    public:
        Student(string,string,char,int);     //构造函数
        ~Student();                    //析构函数
        string name;
        string number;
        char X;
        int year;

        void print(void);
};

Student::Student(string N,string n,char x,int y)
{
    name = N;
    number = n;
    X = x;
    year =y;
}

Student::~Student()
{
    
}
void Student::print()
{
    cout << name << endl;
    cout << number <<endl;
    cout << X << endl;
    cout << year << endl;
}

int main()
{
    cout << "please input name : ";    
    string N;
    cin >> N;
    cout << "please input StudentID :";
    string ID;
    cin >> ID;
    cout << "please input gender (M or W): ";
    char x;
    cin >> x;
    cout << "please input age : ";
    int y;
    cin >> y;
    Student S(N,ID,x,y);
    S.print();
    return 0;
}

初始化成员列表的顺序时按照声明的顺序初始化的，而不是按照初始化列表的顺序进行初始化。

初始化顺序最好要按照变量在类声明的顺序一致，如果初始化变量之存在依赖关系，则初始化会顺序与变量声明顺序存在差异时则会存在有些变量无法初始化成功。若初始化变量之间没有值的依赖时，初始化顺序与变量声明顺序不同则没有关系。

类的析构函数：

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加一个波浪号(~) 它不会返回任何值，他不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件，释放内存）前释放资源。

/****
initiate.cpp
***/

#include<iostream>
using namespace std;

class Student1
{
    public:
        int a = 0;
        int b = 0;
        void fprint()
        {
            cout << "a = " << a << "  b = " << b << endl;
        }
        Student1()
        {
            cout << "have no parameter Student1" << endl;
        }
    //    Student1(int i):b(i),a(b){};   错误初始化顺序
        Student1(int i):a(i),b(a)
        {
            cout << "have parameter Student1" << endl;
        }

        Student1(const Student1& t1)
        {
            cout << "Copy construct func Student1" << endl;
            this->a = t1.a;
            this->b = t1.b;
        }
        Student1& operator = (const Student1& t1)
        {
            cout << "evalute func Student1" << endl;
            this->a = t1.a;
            this->b = t1.b;
            return *this;
        }
};
class Student2
{
    public:
        Student1 test;
        Student2(Student1 &t1)
        {
            t1.fprint();
            cout << "E:  " << endl;
            test = t1;
        }
        //Student2(Student1 &t1):test(t1);
};

int main()
{
    cout << "A: ";
    Student1 A;
    A.fprint();
    
    cout << "B: ";    
    Student1 B(2);
    B.fprint();        
    
    cout << "C; ";
    Student1 C(B);
    C.fprint();

    cout << "D: " << endl;
    Student2 D(C);
    D.test.fprint();
    return 0;
}

运行结果：

exbot@ubuntu:~/wangqinghe/C++/func$ ./initiate

A: have no parameter Student1

a = 0  b = 0

B: have parameter Student1

a = 2  b = 2

C; Copy construct func Student1

a = 2  b = 2

D:

have no parameter Student1

a = 2  b = 2

E: 

evalute func Student1

a = 2  b = 2