类5(转换构造函数)

转换构造函数：

当一个构造函数只有一个参数，而且该参数又不是本类的const引用时，这种构造函数称为转换构造函数。

转换构造函数的作用是将一个其他类型的数据转换成一个类的对象。注意：转换构造函数只能有一个参数。如果有多个参数，就不是转换构造函数：

#include <iostream>
using namespace std;

class Sales_data{
    
    //数据成员
private:
    std::string book_no;
    unsigned units_sold = 1;
    double revenue = 1.0;

public:
    Sales_data() = default;//不接受任何实参，默认构造函数
    Sales_data(const std::string &s): book_no(s){}//只有一个形参，类型转换构造函数
    Sales_data(const std::string &s, unsigned n, double p): book_no(s), units_sold(n), revenue(p * n){}
    Sales_data(std::istream&);

    Sales_data operator+=(const Sales_data &it){
        book_no += it.book_no;
        units_sold += it.units_sold;
        revenue += it.revenue;
        return *this;
    }

    void out_put(std::ostream &os){
        os << book_no << " " << units_sold << " " << revenue << std::endl;
    }

    Sales_data& combine(const Sales_data&);
};

Sales_data& Sales_data::combine(const Sales_data &rhs){
    book_no += rhs.book_no;
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

// Sales_data operator+(const Sales_data &it1, const Sales_data &it2);

int main(void){
    Sales_data("jfl");//构造一个临时Sales_data对象
    Sales_data cnt("hello");
    string null_book = " world";
    cnt.combine(null_book);//null_book被自动转换成Sales_data对象并绑定到引用变量rhs上,
    // 构造出的临时Sales_data对象中book_no值为null_book,units为1,revenue为1.0
    // cnt.combine(" world");//需要进行两步类型转换,error(" world"要先转换为string类型,然后再转换成Sales_data类型)
    cnt.out_put(cout);//输出hello world 2 2
    cnt += null_book;//同上,null_book被自动转换成Sales_data对象
    cnt.out_put(cout);//输出hello world world 3 3
    return 0;
}

 还需要注意的是：编译器只会自动地执行一步类型转换。所以在上例中 cnt.combine("world")；和 cnt += "world")；都是错误的，因为其隐式的使用了两种转换规则，先把 "world" 转换成 string，再把这个临时 string 变量转换成 Sales_data。要使上面调用变成正确的，我们可以先将 "world" 显示的转换成 string 或者 Sales_data：

    cnt.combine(string("world"));
    cnt.combine(Sales_data("world"));
    cnt += string("world");
    cnt += Sales_data("world");

类型转换函数不总是有效：

是否需要从 string 到 Sales_data 的转换依赖于我们对用户使用该转换的看法。在上面的例子中，这种转换可能是对的。 null_book 中的 string 可能表示了一个不存在的 isbn 编号。

但是如果将一个 istream 对象 cin 转换为 Sales_data 的话，显然不是我们想要的结果：

#include <iostream>
using namespace std;

class Sales_data{
friend std::istream &read(std::istream&, Sales_data&);
    
    //数据成员
private:
    std::string book_no;
    unsigned units_sold = 1;
    double revenue = 1.0;

public:
    Sales_data() = default;//不接受任何实参，默认构造函数
    Sales_data(const std::string &s): book_no(s){}//只有一个形参，类型转换构造函数
    Sales_data(const std::string &s, unsigned n, double p): book_no(s), units_sold(n), revenue(p * n){}
    Sales_data(std::istream&);//只有一个形参，类型转换构造函数

    void out_put(std::ostream &os){
        os << book_no << " " << units_sold << " " << revenue << std::endl;
    }

    Sales_data& combine(const Sales_data&);
};

Sales_data& Sales_data::combine(const Sales_data &rhs){
    book_no += rhs.book_no;
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

std::istream &read(std::istream&, Sales_data&);

Sales_data::Sales_data(std::istream &is){
    read(is, *this);
}

istream &read(istream &is, Sales_data &item){
    double price = 0;
    is >> item.book_no >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return is;
}

int main(void){
    Sales_data cnt("hello");
    cnt.combine(cin);
    cnt.out_put(cout);
    return 0;
}

cnt.combine(cin)；先执行转换构造函数 

Sales_data::Sales_data(std::istream &is)

将 cin 转换成 Sales_data 类型，因为该函数体中又调用了 read 函数，所以会产生输入。构造的临时 Sales_data 对象的初始化数据由输入数据产生。因此最终输出：helloworld 2 2

抑制构造函数定义的隐式转换：

我们可以通过将构造函数声明为 explicit 阻止构造转换函数的隐式转换：

#include <iostream>
using namespace std;

class Sales_data{
friend std::istream &read(std::istream&, Sales_data&);
    
    //数据成员
private:
    std::string book_no;
    unsigned units_sold = 1;
    double revenue = 1.0;

public:
    Sales_data() = default;//不接受任何实参，默认构造函数
    explicit Sales_data(const std::string &s): book_no(s){}//加了explicit关键字
    Sales_data(const std::string &s, unsigned n, double p): book_no(s), units_sold(n), revenue(p * n){}
    explicit Sales_data(std::istream&);//加了explicit关键字

    void out_put(std::ostream &os){
        os << book_no << " " << units_sold << " " << revenue << std::endl;
    }

    Sales_data& combine(const Sales_data&);
};

Sales_data& Sales_data::combine(const Sales_data &rhs){
    book_no += rhs.book_no;
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

std::istream &read(std::istream&, Sales_data&);

Sales_data::Sales_data(std::istream &is){
    read(is, *this);
}

istream &read(istream &is, Sales_data &item){
    double price = 0;
    is >> item.book_no >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return is;
}

int main(void){
    Sales_data cnt("hello");
    // cnt.combine(cin);//error
    // cnt.combine(string("world"));//error
    return 0;
}

加了 explicit 关键字后 cnt.combine(cin)；cnt.combine(string("world"))；都是错误的。

explicit 关键字只对一个实参的构造函数有效。需要多个实参的构造函数不能用于执行隐式转换，所以无需将需要多个实参的构造函数声明成 explicit 的，虽然这样做也并没有语法错误。explicit 只能在类内声明构造函数时使用，在外部定义时不应该重复。

explicit 关键字声明的构造函数只能用于直接初始化：

Sales_data cnt(null_book);
Sales_data gel = null_book;

如果没有将对应的构造函数声明成 explicit 的话，这两者初始化方式都是可以的，反之则只有值即初始化是正确的，而拷贝初始化是错误的。

为转换而显示的使用构造函数：

尽管编译器不会将 explicit 的构造函数用于隐式的转换，但是我们可以这样的构造函数显示地强制进行转换：

#include <iostream>
using namespace std;

class Sales_data{
friend std::istream &read(std::istream&, Sales_data&);
    
    //数据成员
private:
    std::string book_no;
    unsigned units_sold = 1;
    double revenue = 1.0;

public:
    Sales_data() = default;//不接受任何实参，默认构造函数
    explicit Sales_data(const std::string &s): book_no(s){}//加了explicit关键字
    Sales_data(const std::string &s, unsigned n, double p): book_no(s), units_sold(n), revenue(p * n){}
    explicit Sales_data(std::istream&);//加了explicit关键字

    Sales_data &operator+=(const Sales_data &it){
        book_no += it.book_no;
        units_sold += it.units_sold;
        revenue += it.revenue;
        return *this;
    }

    void out_put(std::ostream &os){
        os << book_no << " " << units_sold << " " << revenue << std::endl;
    }

    Sales_data& combine(const Sales_data&);
};

Sales_data& Sales_data::combine(const Sales_data &rhs){
    book_no += rhs.book_no;
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

std::istream &read(std::istream&, Sales_data&);

Sales_data::Sales_data(std::istream &is){
    read(is, *this);
}

istream &read(istream &is, Sales_data &item){
    double price = 0;
    is >> item.book_no >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return is;
}

int main(void){
    string cnt = "world";
    Sales_data gel("hello");
    gel.combine(Sales_data(cnt));//显示地强制类型转换
    gel += Sales_data(cnt);
    return 0;
}