C++——单参构造函数类的强制类型转换

C++允许指定在类和基本类型之间进行转换的方式。首先，任何接受唯一一个参数的构造函数都可被用作转换函数，将类型与改参数相同的值转换为类

class B;

B(double a); //OK

B(double a,int b); //NO

B(double a, int) //NO

B(double a, int = 0); //OK
B(double a, int b = 10) //OK

在构造函数前面用explicit修饰，限定必须显式的进行强制转换

explicit B(double a, int = 0); //OK

一些使用

#include <iostream>

using namespace std;

class A
{
public:
    double a;
    A(double a)
    {
        this->a = a;
    }
};

class B
{
public:
    int b;
    explicit B(double b)
    {
        this->b = b;
    }
};
int main()
{
    A a_ = 20.4;
    cout << a_.a << endl;
    //事实上这里编译器会给出警告
    //Clang-Tidy: Single-argument constructors must be marked explicit to avoid unintentional implicit conversions
    //必须将单参数构造函数标记为显式，以避免无意的隐式转换
    //《C++ Primer Plus》也是给出这样的解释，所以，尽量在单参构造函数标记为显式

    //B b_ = 30.4; //error: No viable conversion from 'double' to 'B' 从'double'到'A'没有可行的转换
    //在explicit 修饰的作用下，仍然可以显式的转换

    //构造函数注意，这种显式初始化只有在构造函数的形参是一个参数时才起作用
    B b_1 = B(30.4); //or B b_1 = B{ 30.4 }
    cout << b_1.b << endl;

    //强制转换，注意，这种强制转换只有在构造函数的形参是一个参数时才起作用
    B b_2 = (B) 30.4;
    cout << b_2.b << endl;

    B b_3 = (B)30;
    cout << b_3.b << endl;

    return  0;
}

只有在声明中使用了关键字explicit才不能隐式的强制转换，否则，隐式的强制转换还可以用于以下

1.将类对象初始化

B b_ = {20.4};

2.将单参类型赋值给类对象

B b_;

b_ =  20.4;

3.将单参类型传递给接受类对象为参数的函数时

void func (B b,int a);

func(20.4, 3);

4.返回值为类的函数的函数试图返回单参类型时

B func(void)     return 20.4;

5.在上述任意的一种情况下，使用可转换为单参类型的内置类型时

int 可以转换为double

B b_ = 10; //OK

 使用转换函数时注意的问题

不要出现二义性

long d = a_; //error :Conversion from 'A' to 'long' is ambiguous 从'A'到'long'的转换是不明确的

这时候编译器不知道将调用哪个构造函数，因为int 可以转换为long 同样的double 也可以转换为long类型，编译器不会替你做出这个决定

可以把转换函数写成一个类方法，而不是一个类内的转换函数

原则上尽量使用显式的转换函数来避免不必要的错误，应谨慎的使用隐式转换函数。通常，最好选择仅在被显示调用时才会执行的函数

#include <iostream>

using namespace std;

class A
{
public:
    double a;
    A(double a)
    {
        this->a = a;
    }
    operator double() const
    {
        return (int) this->a;
    }
    int A_to_int() const
    {
       return (int) this->a;
    }
};

int main()
{
    A a = 10.4;
    int t = a;
    cout << "a.a(double) is " << a.a <<endl;
    cout << "but to int is " << t << endl;  //隐式转换
    cout << "use class function to int is " << a.A_to_int(); //调用非转换函数的类方法
    return 0;
}