std::string s = "hello c++";

请问创建了几个string呢？如果你脱口而出1个，那么面试官八成会狡黠一笑，让你回家等通知去了。

那么答案是什么呢？是1个或者2个。什么，你逗我呢？

先别急，我们分情况讨论。首先是c++11之前。

在c++11前题目里的表达式实际上会导致下面的行为：

1. 首先"hello c++"是const char[N]类型的，不过它在表达式中于是退化成const char *
2. 然后因为s实际上是处于“声明即定义”的表达式中，因此适用的只有复制构造函数，而不是重载的=
3. 因此等号的右半边必须也是string类型
4. 因为正好有从const char *到string的转换规则，因此把它转换成合适的类型
5. 转换完会返回一个新的string的临时量，它会作为参数调用复制构造函数
6. 复制构造函数调用完成后s也就创建完毕了。

在这里我们暂且忽略了string的写时复制等黑科技，整个过程创建了s和一个临时量，一共两个string。

很快c++11就出现了，同时还带来了移动语义，然而结果并没有改变：

1. 前面步骤相同，字符串字面量隐式转换成string，创建了一个临时量
2. 临时量是个右值，所以绑定给右值引用，因此移动构造函数被选择
3. 临时量里的数据移动到s里，s创建完成

移动语义减少了不必要的内部数据的复制，但是临时量还是会被创建的。

有进捣鼓编译器的朋友可能要说了，编译器是不生成这个临时量的。是这样的，编译器会用复制省略（copy elision）优化这段代码。

是的，复制省略在c++11里就已经被提到了，不过那时候它是可选的，并不强制编译器支持这一优化。因此你在GCC和clang上观察到的不一定能代表全部的c++编译器的情况，所以我们仍以标准为基础推演了理论上的行为。

到目前为止答案都是2，然而很快有意思的事情发生了——复制省略在c++17里成为了被标准化的行为。

在c++17里除非必要，否则临时量（现在叫做右值的结果对象，一个右值只有在实际需要存在一个临时变量的情况下才会创建一个临时变量，这个过程叫做实质化，创建出来的那个临时量就是该右值的结果对象）不会被创建，换而言之，T obj = expr这样的形式会以expr产生结果直接调用合适的构造函数，而不会进行临时量的创建和复制构造函数的调用，不过为了保证语义的完整性，复制构造函数仍然被要求是可访问的，毕竟类本身不允许复制构造的话复制初始化本身就是不正确的，不能因为复制省略而导致错误的代码被编译通过。

所以现在过程变成了下面这样子：

1. 编译器发现表达式是string的复制初始化
2. 右侧是表达式会隐式转换产生一个string的纯右值用于初始化同一类型的s
3. 判断复制构造函数是否可用，然后发现符合复制省略的条件
4. 寻找string里是否有符合要求的构造函数
5. 找到了string::string(const char *)，于是直接调用
6. s初始化完成

因此，在c++17下只会创建一个string对象，这比移动语义更加高效。这也是为什么我说题目的答案既可以是1也可以是2的原因。

同时我们还发现，在复制构造时的类型转换不管复制有没有被省略都是存在的，只不过换了一个形式，这就是我们后面要讲的内容。

隐式转换是如何工作的

复习完基础知识，我们可以进入正题了。

隐式转换可以分为两个部分，标准定义的转换和用户自定义的转换。我们先来看看它们是什么。

标准转换

也就是编译器里内置的一些类型转换规则，比如数组退化成指针，函数转换成函数指针，特定语境下要求的转换（if里要求bool类型的值），整数类型提升，数值转换，数据类型指针到void指针的转换，nullptr_t到数据类型指针的转换等。

底层const和volatie也可以被转换，只不过只能添加不能减少，可以把T*转换成const T*，但反过来是不可以的。

这些转换基本都是针对标量类型和数组这种内置的聚合类型的。

如果想要指定自定义类型的转换规则，则需要编写用户自定义类型转换的接口了。

用户自定义转换

说了这么多，也该看看用户自定义转换了。

用户能控制的自定义转换接口一共也就两个，转换构造函数和用户定义转换函数。

转换构造函数就是只类似T(T2)这样的构造函数，它拥有一个显式的T2类型的参数，通过这个构造函数可以实现从T2转换类型至T1的效果。

用户定义转换函数是类似operator T2()这样的类方法，注意不需要指定返回值。通过它可以实现从T1转换到T2。可转换的类型包括自身T1（还可附加cv限定符，或者引用）、T1的基类（或引用）以及void。

举个例子：

struct A {};

struct B {
    // 转换构造函数
    B(int);
    B(const A&);

    // 用户定义转换函数，不需要显式指定返回值
    operator A();
    operator int();
}

T  <---转换构造函数---  其他类型

T  ---用户定义转换函数--->  其他类型

template <typename T>
struct SmartPointer {
    //...
    T *ptr = nullptr;
    // 方便判断指针是否为空
    explicit operator bool() {
        return ptr != nullptr;
    }
};

SmartPointer<int> p = func();
if (p) {
    p << 1; // 这是不允许的
}

template <typename T>
struct SmartPointer {
    //...
    T *ptr = nullptr;
    explicit operator bool() {
        return ptr != nullptr;
    }

    // 配合模板参数
    operator T*() {
        return ptr;
    }

    /* 自动推到返回值，与上一个同义
    operator auto() {
        return ptr;
    }
    */
};

SmartPointer<int> p = func();
int *p1 = p;

struct D;
struct B {
    virtual operator D() = 0;
};
struct D : B
{
    operator D() override { return D(); }
};
 
int main()
{
    D obj;
    D obj2 = obj; // 不调用 D::operator D()
    B& br = obj;
    D obj3 = br; // 通过虚派发调用 D::operator D() 
}

struct A {};
struct B {
    operator A() const;
};

const B b;
const A &a = b;

struct A
{
    operator int() const;
};

A a;
bool b = a;

template <typename T>
struct SmartPointer {
    //...
    T *ptr = nullptr;
    operator bool() {
        return ptr != nullptr;
    }

    T& operator*() {
        return *ptr;
    }
};

auto ptr = get_smart_pointer();
if (ptr) {
    // ptr 是int*的包装，现在我们想取得ptr指向的值
    int value = p;
    // ...
}

template <typename T>
struct SmartPointer {
    //...
    T *ptr = nullptr;
    explicit operator bool() {
        return ptr != nullptr;
    }
};

struct A
{
    operator int&();
};

int&& b = A();

int num = 0;
const int &a = num;
int &b = num;
int &&c = 100;
const int &d = 100;

int a = 10;
long &b = a;
std::cout << b << std::endl;

c.cpp: In function ‘int main()’:
c.cpp:6:11: error: cannot bind non-const lvalue reference of type ‘long int&’ to an rvalue of type ‘long int’
    6 | long &b = a;
      | 

long b1 = a;
const long &b2 = a;

void func(unsigned int &)
{
    std::cout << "lvalue reference" << std::endl;
}

void func(const unsigned int &)
{
    std::cout << "const lvalue reference" << std::endl;
}

int main()
{
    int a = 1;
    func(a);
}

template <typename... Args>
void format_and_print(const std::string &s, Args&&... args)
{
    // 实现格式化并打印出结果
}

std::string info = "%d + %d = %d\n";
format_and_print(info, 2, 2, 4);
format_and_print("%d * %d = %d\n", 2, 2, 4);

void func(int arr[])
{
    std::cout << (sizeof arr) << std::endl;
}

int main()
{
    int a[100] = {0};
    std::cout << (sizeof a) << std::endl;
    func(a);
}

template <std::size_t N>
void func(int (&arr)[N])
{
    std::cout << (sizeof arr) << std::endl; // 400
    std::cout << N << std::endl; // 100
}

struct A{
    A(const std::string &s): _s{s} {}
    std::string _s;
};

void func(const A &s)
{
    std::cout << s._s << std::endl;
}

int main()
{
    func("two-steps-implicit-conversion");
}

test.cpp: In function 'int main()':
test.cpp:15:10: error: invalid initialization of reference of type 'const A&' from expression of type 'const char [30]'
   15 |     func("two-steps-implicit-conversion");
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test.cpp:8:20: note: in passing argument 1 of 'void func(const A&)'
    8 | void func(const A &s)
      |           ~~~~~~~~~^

struct A{
    A(bool b)
    {
        _s = b ? "received true" : "received false";
    }
    std::string _s;
};

void func(const A &s)
{
    std::cout << s._s << std::endl;
}

int main()
{
    int num = 0;
    func(num); // received false
    unsigned long num2 = 100;
    func(num2); // received true
}

struct A{
    A(const std::string &s): _s{s} {}
    std::string _s;
};

void func(const A &s)
{
    std::cout << s._s << std::endl;
}

int main()
{
    func(std::string{"two-steps-implicit-conversion"});
}