第十一章 使用类

下面的程序涉及到了类的构造函数，默认构造函数，析构函数，转换函数，友元函数，运算符重载。

//头文件，a.h
#ifndef a_H_//宏名不应以数字打头
#define a_H_

#include<string>

class Animal
{
private:
    std::string animal;
    int weight;
    int num;

public:
    Animal();
    explicit Animal(std::string &, int n = 1, int w = 30);
    ~Animal();
    //运算符重载
    Animal operator+(Animal &aml) const;
    //友元
    friend Animal & operator+(Animal &aml, int);
    //转换函数（C++98中explicit不能用于转换函数，只能用于构造函数）
    operator std::string() const;

    void show();

};
#endif

//类定义
#include "a.h"
#include<string>
#include<iostream>

Animal::Animal()
{
    animal = "none";
    num = weight = 0;
}

Animal::Animal(std::string &aml, int n, int w)
{
    animal = aml;
    num = n;
    weight = w;
}

Animal::~Animal()
{
    std::cout << animal << "->" << num << "->" << weight << "->" << "byb!!" << std::endl;
}

Animal Animal::operator+(Animal &aml) const
{
    return Animal(aml.animal, aml.num+num, aml.weight+weight);
}


Animal::operator std::string() const
{
    return animal;
}

void Animal::show()
{
    std::cout << animal << std::endl << num << std::endl << weight << std::endl;
}

//友元
Animal & operator+(Animal &aml, int n)
{
    aml.num += n;
    return aml;
}

#include<iostream>
#include "a.h"

int main()
{
    {
    std::string aml= "tiger";
    Animal Tiger0(aml, 30, 1);
    Animal Tiger1(aml, 40, 1);
    Animal Tiger2(aml, 10, 3);
    Animal tol_Tiger = Tiger0+Tiger1+Tiger2;//调用重载的运算符‘+’
    tol_Tiger.show();
    }
    {
    std::string aml1= "sheep";
//    Animal Sheep = aml1;//单参数构造函数，隐式类型转换（用关键字explicit限定构造函数，将禁止这种隐式转换）
//    Sheep.show();

    Animal Sheep2(aml1);//显示的调用单参数构造函数
    std::string aml2 = Sheep2;//调用转换函数
    std::cout << aml2 << std::endl;
    }

    {
    Animal What;//隐式地调用默认构造函数
    Animal W2 = What +2;//使用友元
    What.show();
    }

    system("pause");
    return 0;
}

C++提供了另一种访问权限——友元。

友元有3种：友元函数；友元类；友元成员函数。

本章只涉及到友元函数。

在为类重载二元运算符时常常需要友元。

创建友元

将其原型放在类声明中，并在原型声明前加上关键字friend。

其与成员函数的访问权限相同。

类方法和友元是表达类接口的两种不同机制。

类的自动转换和强制类型转换

在C++中，接受一个参数的构造函数为 将类型与该参数相同的值转换成类 提供了蓝图。

即，可以将与构造函数参数类型相同的变量转换为该类对象（隐式转换），C++新增了关键字explicit用于关闭该特性，但仍然允许显式转换。

转换函数

构造函数只用于从某种类型到类类型的转换。要进行相反的转换，必须使用特殊的C++运算符——转换函数。

转换函数是用户定义的强制类型转换，可以像使用强制类型转换那样使用它们。

创建转换函数

operator typename();

转换函数必须是类方法；不能指定返回类型；不能有参数。

当类定义了两种或更多的转换时，可以使用显式强制类型转换指出要使用哪个转换函数。

原则上，最好使用显式转换，而避免隐式转换。

在C++98中，关键字explicit不能用于转换函数，但C++11消除了这个限制，在C++11中可将转换运算符声明为显式的。

使用转换函数时的一个问题

设Stock是一个类，其中定义了单参数构造函数Stock(long)，并且没有使用关键字explicit限定；而且定义了转换函数operate long()；重载了运算符“+”，操作数为Stock类对象。

代码如下：

Stock st1(1000);
long st2 = 200;
Sotck ST;
ST = st1 + st2;

那么第四行是先将st1通过转换函数隐式转换为long整型再对long整型进行"+"操作，之后再转换到Stock类对象；还是先将st2通过构造函数隐式转换为Stock类对象再对Stock类对象进行"+"操作？

为避免以上问题在C++98中，最好用explicit限定构造函数禁止隐式转换。