输出操作符 ( ＜＜ ) 重载的类内、类外实现

输出操作符 ( << ) 重载

需求

假如我们有这么一个类：

class Person
{
public:
	Person(std::string name, int age) : m_strName(name), m_iAge(age) {}
    
    void setName(std::string name)
    {
    	m_strName = name;
    }
    
    void setAge(int age)
    {
    	m_iAge = age;
    }
    
    std::string getName() const
    {
        return m_strName;
    }
    
    int getAge() const
    {
    	return m_iAge;
    }
    
private:
    std::string m_strName;
    int m_iAge;
};

我们想输出这个类里面的内容：

void main(int argc, char* agrv[])
{
	Person person("小明", 23);
    std::cout << "姓名：" << person.getName() << " 年龄：" << person.getAge() << std::endl;
}

每次输出时都需要写很长的一行代码，这不太友好。
我们希望能够这样输出：

void main(int argc, char* agrv[])
{
	Person person("小明", 23);
    std::cout << person;
}

这样输出就比较方便，同时也避免了在自己写输出代码中不小心写错的问题。
这就需要对 Person 类进行输出操作符重载。

输出操作符重载

首先，我们在类外部定义操作符重载函数。

std::ostream& operator<<(std::ostream& os, const Person& person)
{
    os << "姓名：" << person.getName() << " 年龄：" << person.getAge() << std::endl;
    return os;
}

当重载了输出操作符后，我们使用“<<”就可以直接输出 person 了。

std::cout << person;

// 输出：姓名：小明 年龄：23

在上面重载函数中，可以看到，第一个参数为std::ostream& 的 os，其中std::ostream类型需要传递引用，因为需要对参数进行写操作，os只是参数名称，叫什么无所谓，起名cout也可以，只是在函数体内修改为相应的cout << "姓名: ".......。第二个参数就是你想直接使用std::cout输出的类型，这里就是Person类型。
​

我们注意到，以上函数，我们是写在类外部，我们重载的操作符其实是为这个类去服务的，应该把这个函数写在类内部，使其成为成员函数，这样也保证了封装性。
那我们将重载的函数放入类内部，让它成为成员变量。

class Person
{
public:
	Person(std::string name, int age) : m_strName(name), m_iAge(age) {}
    
    void setName(std::string name)
    {
    	m_strName = name;
    }
    
    void setAge(int age)
    {
    	m_iAge = age;
    }
    
    std::string getName() const
    {
        return m_strName;
    }
    
    int getAge() const
    {
    	return m_iAge;
    }
    
    std::ostream& operator<<(std::ostream& os)
	{
    	os << "姓名：" << this->getName() << " 年龄：" << this->getAge() << std::endl;
    	return os;
	}	
    
private:
    std::string m_strName;
    int m_iAge;
};

函数写在类内部和类外部是不同的，成员函数相比于非成员函数少了一个参数，“Person”类型的参数。想想也是，既然成员函数就是为了这个类输出，那么就不用额外的参数去定义类型了，输出的类型就是本身的类类型，在函数体内，可以使用“this”指针去获取其他成员函数以获得我们想要的信息，当然也可以不使用“this”。
​

我们继续做一下测试。

void main(int argc, char* agrv[])
{
	Person person("小明", 23);
    std::cout << person;		// 报错！！！
}

我们发现，std::cout << person;竟然报错了，重载了输出操作符后并不能正常的输出。
我们再次尝试这样输出：

void main(int argc, char* agrv[])
{
	Person person("小明", 23);
    person << std::cout;		// 正确输出
}

这又是为什么呢？

其实，在类内的成员函数中，非静态成员函数参数隐藏着this参数，而且是第一个参数。我们看到的std::ostream& operator<<(std::ostream& os)实际上为：std::ostream& operator<<(Person *this， std::ostream& os)，那么有这么一个参数，当被外界调用时，它会接收实际值吗？
​

我们知道，其余参数肯定要接收想要的值，那这个this也应该接收相应的值，那它接收的什么呢？
​

它接收的就是调用者的地址。即：a.get();–>get(&a)。
​

我们知道了this的存在，也就是成员函数的参数有两个，在输出时，<<运算符要严格的按照参数的顺序进行书写，即先写this后写os。也就最终输出时是这样的：person << std::cout;。
​

这样也可以输出，但是与我们习惯的输出不一样，正好反了过来，我们并不希望这么输出。所以，通常重载的输出操作符是写在类外的，或者声明为友元函数，不会将其写作成员函数。