#include <iostream>
using namespace std;
class C_score{
    
string course;
int score;
public:
C_score(string c, int s):course(c),score(s){
    
cout << "constructing C_score:" <<course<< endl;
}
~C_score(){
    
cout << "dstructing C_score:" <<course<< endl;
}
};
class aa{
    
    public:
        aa(){
    
            cout << "6666" << endl;
        }
};

class Student {
    
public:
    
    Student(string n, string c, int s) : c_score(c, s), name(n)
    {
    
        cout << "constructing Student:" << name << endl;
}
~Student(){
     
cout << "destructing Student:"<<name << endl;
}
private:
    aa a;
    string name;
    int age;
    C_score c_score;
};

int main()
{
    
Student * s = new Student("ZhangSan","c++",88);
Student ss("Lisi", "English", 85);
delete s;
return 0;
}

/*
output:
6666
constructing C_score:c++
constructing Student:ZhangSan
6666
constructing C_score:English
constructing Student:Lisi
destructing Student:ZhangSan
dstructing C_score:c++
destructing Student:Lisi
dstructing C_score:English
*/

以上述为例

在创建一个（含有组合类）对象的过程：

1.运行student类的成员
2.冒号引用，调出函数参数列表
3.执行C_score类
4.执行cscore的成员
5.执行cscore的构造函数
6.执行student的构造函数
按照声明顺序执行成员类的构造函数——>执行自己的构造函数

在析构一个对象的过程：

与自身构造时调用自己以及成员组合类时的构造函数顺序相反

不可以将拷贝构造函数看作一种特殊的构造，它与构造有着不同的规则：
如果我们设置一个构造函数参数是int i，这个时候我们在主函数如果声明这个类型的对象然后对这个对象使用该类型的其他对象进行赋值（拷贝）那么它不会因为没有参数为这个对象的构造函数报错。实践证明上述方法实现了，是因为调用了默认的拷贝构造函数（将对象中的静态成员进行拷贝）

拷贝函数的隐式类型转换

#include <iostream>
using namespace std;
class aa{
    
    public:
        aa(int a){
    
            cout << a << endl;
        }
        ~aa(){
    
            cout << "de" << endl;
        }
        int i;
};

class bb{
    
    public:
        bb(int a){
    
            i = -a;
        }
        int i;
};

void m(aa a){
    
    cout << "fun--m" << endl;
}

int main(){
    
    m(9);
    return 0;
}
/*
output:
9
fun--m
de
*/

m(9)中9不是aa类，但是存在隐式类型转换—产生了一个aa(9)的临时对象，以临时对象作为参数传入m函数中，执行m函数，执行结束后临时对象析构。

注意：
在上面代码区增加了一个m的重载函数

void m(bb a){
    
    cout << "fun--m" << endl;
}

上述程序就会报错，因为存在二义性，编译器不知道应该产生临时变量aa(9)还是bb(9)

#include <iostream>
using namespace std;
class HighWorker {
    
 float income;
public:
    HighWorker(float a = 2000.0){
    income = a;}
    float Getincome(){
    return(income);}
};
class Worker {
    
   float income;
    public:
        Worker(float a = 1200.0) {
     income = a; }
        Worker(HighWorker b) {
     income = 0.75 * b.Getincome(); }
        float Getincome() {
     return (income); }
};
void m(Worker a) {
     cout << a.Getincome() << endl; }
int main(){
      
    Worker a;  m(a); 
    HighWorker b;  m(b);
	return 0;
    }

同时编译器还会为自定义类的对象进行隐式转换，上述在m(b)中，将b转化为Worker(b)的临时对象，执行了*Worker(HighWorker b) { income = 0.75 * b.Getincome(); }*构造函数。
也就是自定义类A中存在以a,b,c,d类为唯一参数的构造函数，我们就可以将a,b,c,d类隐式转换成类A。
但是：转换不能太复杂，不允许多参数，不允许间接转换