初始化列表、explicit关键字

问题：
当类A作为另一个类B的成员的时，在定义的时候其实就已经用了无参构造，那么当在B中再去定义有参构造的时候就不能再去调用A的有参构造了，因为构造函数是在实例化一个对象的同时调用用来初始化该存储空间的，而在声明的时候已经调用了无参构造，那么这样就遇到了不能定义B的有参构造的情况
解决：

初始化列表

#include <iostream>
using namespace std;
class A
{
private:
    int m_a;
public:
    A()
    {
        cout << "A无参构造" << endl;
    }
    A(int a)
    {
        m_a = a;
        cout << "A有参构造" << endl;
    }
    ~A()
    {
        cout << "A析构函数" << endl;
    }
};
class B
{
private:
    int m_b;
public:
    B()
    {
        cout << "B无参构造" << endl;
    }
    B(int b)
    {
        m_b = b;
        cout << "B有参构造" << endl;
    }
    ~B()
    {
        cout << "B析构函数" << endl;
    }
};
class Data
{
private:
    A ob1;
    B ob2;
    int data;
public:
    Data()
    {
        cout << "Date无参构造" << endl;
    }
    Data(int a,int b,int c):ob1(a),ob2(b),data(c) //初始化列表的使用
    {
        cout << "Data有参构造" << endl;
    }
    ~Data()
    {
        cout << "Data析构函数" << endl;
    }
};
void test01()
{
    Data ob3(10,20,30);

}
int main()
{
    test01();
    return 0;
}

调用过程：

对象成员的构造函数 ——》自己的构造函数 ——》自己的析构函数 ——》对象成员的析构函数

运行结果：

explicit关键字：禁止采用隐式转换的方式调用有参构造

如下代码：

#include <iostream>

using namespace std;
class data
{
private:
    int m_a;
public:
    explicit data (int n) //禁止使用隐式转换方式调用有参构造
    {
        m_a=n;
        cout << "有参构造" << endl;
    }
    ~data()
    {
        cout << "析构函数" << endl;
    }
    void showdata()
    {
        cout << "m_a=" << m_a << endl;
    }
};
int main()
{
    data A=10;//隐式转换调用有参构造
    A.showdata();
    return 0;

结果：错误

应该为显示调用，或隐式调用

int main()
{
    //错误：data A=10;
    data A=data(10);
    A.showdata();
    data B(20);
    B.showdata();
    return 0;
}

结果：