构造函数应用实例：

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

class Student
{
public:
    string name;
    string number;
    char X;
    int year;
    Student(string,string,char,int);      //构造函数声明
    void xianshi(void);     //用于输出类成员的值
};

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

void Student::xianshi()     //输出成员的值
{
    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.xianshi();                           //引用输出函数
    return 0;
}

初始化顺序最好要按照变量在类声明的顺序一致,否则会出现下面的特殊情况:

#include<iostream>
 
using namespace std;

class Student1 {
    public:
        int a;
        int b;
        void fprint(){
            cout<<" a = "<<a<<" "<<"b = "<<b<<endl;
         }
         
         Student1(int i):b(i),a(b){ }    //异常顺序：发现a的值为0  b的值为2  说明初始化仅仅对b有效果，对a没有起到初始化作用 
//         Student1(int i):a(i),b(a){ } //正常顺序：发现a = b = 2 说明两个变量都是初始化了的  

         Student1()                         // 无参构造函数
        { 
            cout << "默认构造函数Student1" << endl ;
        }
    
        Student1(const Student1& t1) // 拷贝构造函数
        {
            cout << "拷贝构造函数Student1" << endl ;
            this->a = t1.a ;
        }
    
        Student1& operator = (const Student1& t1) // 赋值运算符
        {
            cout << "赋值函数Student1" << endl ;
            this->a = t1.a ;
            return *this;
        }
      
 };
class Student2
{
    public:
     
    Student1 test ;
    Student2(Student1 &t1){
        test  = t1 ;
    }
//     Student2(Student1 &t1):test(t1){}
};
int main()
{
    
    Student1 A(2);        //进入默认构造函数 
    Student2 B(A);        //进入拷贝构造函数 
    A.fprint();            //输出前面初始化的结果 
}

两种不同的初始化方法结果如下：

异常初始化顺序：

正常初始化顺序：

由上面的例子可知，初始化列表的顺序要跟你在类声明的顺序要一致。否则像上面的那种特殊情况，有些变量就不会被初始化。经过测试发现，类中变量为下面的情况也是能够正常初始化的：也就是说，只要成员变量的初始化不依赖其他成员变量，即使顺序不同也能正确的初始化。

int a;
int b;
int c;
Student1(int i):b(i),a(i),c(i){} 
main:
    Student1 A(2);    
    A.fprint();

结果：

int a;
int b;
int c;
Student1(int i,int j,int k):b(i),a(j),c(k){}
main:
    Student1 A(2,3,4);
    A.fprint();

一个类内可以有多个构造函数，可以是一般类型的，也可以是带参数的，相当于重载构造函数，但是析构函数只能有一个。

class Matrix
{
public:
    Matrix(int row, int col);                                            //普通构造函数
    Matrix(const Matrix& matrix);                                        //拷贝构造函数
    Matrix();                                                            //构造空矩阵的构造函数
    void print(void);
    ~Matrix();
};