编译器的隐式转换规则

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

class base {
public:
    base () { cout << "base ()" << endl; }
    base (int a) { cout << "base (int)" << endl; } 
};

class base_1  {
public:
    base_1 (const base &b)  { cout << "base_1 (base)" << endl; }
};
class base_2  {
public:
    base_2 (const base_1 &b)  { cout << "base_2 (base)" << endl; }
};
void test_base_2 (const base_2 &a) 
{
}

void test_base_1 (const base_1 &a) 
{
}

void test_base (const base &a) 
{
}
int main () {
    // base_2 d2(10);           // 出错 编译器进行两次隐式类型转换 int => base => base1
    base b;
    base_2 d3(b);               // 正确 编译器进行一次隐式类型转换 base => base1
    base_2 d3(base(10));        // 正确 编译器 进行一次显示转换 int => base 进行一次隐式类型转换 base => base1

    base_1 b1(10);              // 正确 编译器进行一次隐式类型转换 int => base

    // test_base_2(b);          // 出错 编译器进行两次隐式类型转换 base => base1 => base2
    test_base_2(b1);            // 正确 编译器进行一次隐式类型转换 base1 => base2

    test_base_1(b);             // 正确 编译器进行一次隐式类型转换base => base1
    // test_base_1(10);            // 出从 编译器进行两次隐式类型转换int => base => base1

    test_base(10);              // 正确 编译器进行一次隐式类型转换int => base
    return 0;
}