C++学习28 重载>>和<<(输入输出运算符)

在C++中,系统已经对左移运算符“<<”和右移运算符“>>”分别进行了重载,使其能够用于输入输出,但是输入输出的处理对象只能是系统内建的数据类型。系统重载这两个运算符是以系统类成员函数的形式进行的,因此cout<< var语句可以理解为:

cout.operator<<( var )

如果我们自己定义了一种新的数据类型,需要用输入输出运算符去处理,那么就要重载。本节以前面的 complex 类为例说明输入输出运算符的重载。

重载输入运算符>>

下面我们用全局函数的形式重载输入运算符,使它能够读入两个 double 类型的数据,并转换为一个复数,保存到复数对象中:

istream & operator>>(istream & in, complex & A){
    in >> A.real >> A.imag;
    return in;
}

istream 是输入流,cin 就是 istream 类的对象,后续会讲解。因为重载运算符函数需要用到 complex 类的 private 成员变量,为了方便,我们将这个函数声明为 complex 类的友元函数。声明形式如下:

friend istream & operator>>(istream & in , complex & a);

该函数可以按照如下方式使用:

complex c;
cin>> c;

当输入1.45 2.34后,这两个小数就分别成为 complex 对象 c 的实部和虚部了。cin>> c;这一语句其实可以理解为:

operator<<(cin , c);

在重载输入运算符时,采用引用的方式进行参数传递:输入的参数里面包含一个 istream 类的引用,返回值仍然为该引用。这样做的一个明显好处就是可以采用链式输入(也就是连续输入),如下所示:

complex c1, c2, c3;
cin>> c1 >> c2 >> c3;

重载输出运算符<<

同样的,我们也可以模仿上面的方式对输出运算符进行重载,让它能够输出复数。函数在类内部的声明如下:

rriend ostream &(ostream & out, complex & A);

全局函数的实现如下:

ostream & operator<<(ostream & out, complex & A){
    out << A.real <<" + "<< A.imag <<" i ";
    return out;
}

与 istream 相反,ostream 表示输出流,cout 就是 ostream 类的对象。为了能够直接访问 complex 类的私有成员变量,同样需要将这个函数声明为 complex 类的友元函数。由于采用了引用的方式进行参数传递,该输出运算符重载函数可以实现链式输出。

结合输入输出运算符的重载,重新实现 complex 类:

#include <iostream>
using namespace std;
class complex{
private:
    double real;  //复数的实部
    double imag;  //复数的虚部
public:
    complex(): real(0.0), imag(0.0){ };
    complex(double a, double b): real(a), imag(b){ };
    friend complex operator+(const complex & A, const complex & B);
    friend complex operator-(const complex & A, const complex & B);
    friend complex operator*(const complex & A, const complex & B);
    friend complex operator/(const complex & A, const complex & B);
    friend istream & operator>>(istream & in, complex & A);
    friend ostream & operator<<(ostream & out, complex & A);
};
//重载加法运算符
complex operator+(const complex & A, const complex &B){
    complex C;
    C.real = A.real + B.real;
    C.imag = A.imag + B.imag;
    return C;
}
//重载减法运算符
complex operator-(const complex & A, const complex &B){
    complex C;
    C.real = A.real - B.real;
    C.imag = A.imag - B.imag;
    return C;
}
//重载乘法运算符
complex operator*(const complex & A, const complex &B){
    complex C;
    C.real = A.real * B.real - A.imag * B.imag;
    C.imag = A.imag * B.real + A.real * B.imag;
    return C;
}
//重载除法运算符
complex operator/(const complex & A, const complex & B){
    complex C;
    double square = A.real * A.real + A.imag * A.imag;
    C.real = (A.real * B.real + A.imag * B.imag)/square;
    C.imag = (A.imag * B.real - A.real * B.imag)/square;
    return C;
}
//重载输入运算符
istream & operator>>(istream & in, complex & A){
    in >> A.real >> A.imag;
    return in;
}
//重载输出运算符
ostream & operator<<(ostream & out, complex & A){
    out << A.real <<" + "<< A.imag <<" i ";;
    return out;
}
int main(){
    complex c1, c2, c3;
    cin>>c1>>c2;

    c3 = c1 + c2;
    cout<<"c1 + c2 = "<<c3<<endl;
    c3 = c1 - c2;
    cout<<"c1 - c2 = "<<c3<<endl;
    c3 = c1 * c2;
    cout<<"c1 * c2 = "<<c3<<endl;
    c3 = c1 / c2;
    cout<<"c1 / c2 = "<<c3<<endl;
    return 0;
}

在本例中,我们均采用全局函数的形式进行运算符重载,这样在输入输出时方便了不少。

时间: 08-31

C++学习28 重载>>和<<(输入输出运算符)的相关文章

C++学习29 重载[](下标运算符)

前面已经提到,下标操作符[]必须以类的成员函数的形式进行重载.在类中的声明格式如下: 返回值类型 & operator[] (参数) 或 const 返回值类型 & operator[] (参数) 使用第一种声明方式,操作符重载函数不仅可以访问对象,同时还可以修改对象.使用第二种声明方式,操作符重载函数只能访问而不能修改对象. 默认情况下,通过下标访问数组中的元素并不具有检查边界溢出功能,我们可以通过重载实现该功能. 请看下面的代码: #include<iostream> #i

C++运算符重载——输入/输出运算符

为了与IO标准库一致,重载输入输出运算符函数的第一个行参应该是流的引用,第二个行参是对象的引用. 如果重载为类的成员函数,第一个行参应该是对象的引用,第二个行参是流的引用. 使用方式是 ClassObj << cout 这样与标准IO库就不一致了,所以输入输出运算符不能重载为类的成员函数,可以重载为类的友元函数和普通函数. 通常重载输出运算符的第二个行参是const的,因为输出一个类不许要更改它: 但是重载输入运算符的第二个行参必须是非const的,否则无法赋值. 重载的基本方法如下: //重

C++重载&gt;&gt;和&lt;&lt;(输入输出运算符)

在C++中,标准库本身已经对左移运算符<<和右移运算符>>分别进行了重载,使其能够用于不同数据的输入输出,但是输入输出的对象只能是 C++ 内置的数据类型(例如 bool.int.double 等)和标准库所包含的类类型(例如 string.complex.ofstream.ifstream 等). 如果我们自己定义了一种新的数据类型,需要用输入输出运算符去处理,那么就必须对它们进行重载.本节以前面的 complex 类为例来演示输入输出运算符的重载. 重载输入运算符>>

C++ Primer 学习笔记_27_操作符重载与转换(2)--++/--运算符重载、!运算符重载、赋值运算符重载 、String类([]、 +、 += 运算符重载)、&gt;&gt;和&lt;&lt;运算符重载

C++ Primer 学习笔记_27_操作符重载与转换(2)--++/--运算符重载.!运算符重载.赋值运算符重载 .String类([]. +. += 运算符重载).>>和<<运算符重载 一.++/--运算符重载 1.前置++运算符重载 成员函数的方式重载,原型为: 函数类型 & operator++(); 友元函数的方式重载,原型为: friend 函数类型 & operator++(类类型 &); 2.后置++运算符重载 成员函数的方式重载,原型为:

初探C++运算符重载学习笔记&lt;3&gt; 增量减量运算符重载

初探C++运算符重载学习笔记<1> 初探C++运算符重载学习笔记<2> 重载为友元函数     增量.减量运算符++(--)分别有两种形式:前自增++i(自减--i),后自增i++(自减i--) 因此当我们重载该运算符时,要重载相应形式的运算符. T & operator ++() // 前自增++i T & operator ++(int) //后自增 i++ 举例: #include <iostream> using namespace std; c

输入输出运算符重载

C++能够使用流提取运算符>>和流插入运算符<< 来输入输出内置数据类型,也可以重载流提取运算符和流插入运算符来操作对象等用户自定义的数据类型. 我们有时需要把运算符重载函数声明为类的友元函数,这样我们就能不用构造对象而直接调用函数. /*** inputOver.cpp ***/ #include<iostream> using namespace std; class Distance { private: int feet; int inches; public:

Scala学习笔记(1)-- 运算符重载

本文记录我对Scala语言运算符重载的一些理解. 运算符=方法 对于Scala来说,运算符就是普通的方法(再配上一些语法糖).比如下面这个类就重载了加号和减号: 我们可以这样使用MyInt: var myInt = new MyInt(1) myInt = myInt + 1 用javap或者classpy分析一下scalac编译之后的类可以知道,+实际上对应$plus()方法,-对应$minus()方法.也就是说,下面三行代码完全等价: myInt = myInt + 1 myInt = my

C++重载流插入运算符和流提取运算符

C++的流插入运算符“<<”和流提取运算符“>>”是C++在类库中提供的,所有C++编译系统都在类库中提供输入流类istream和输出流类ostream.cin和cout分别是istream类和ostream类的对象.在类库提供的头文件中已经对“<<”和“>>”进行了重载,使之作为流插入运算符和流提取运算符,能用来输出和输入C++标准类型的数据.因此,凡是用“cout<<”和“cin>>”对标准类型数据进行输入输出的,都要用#incl

C++重载自增运算符的效率问题

C++规定后缀形式有一个int类型参数,当函数被调用时,编译器传递一个0做为int参数的值给该函数. increment的前缀形式表示“增加然后取回”,后缀形式表示“取回然后增加”. 1 #include "stdafx.h" 2 #include "assert.h" 3 class A 4 { 5 public: 6 A(int i) 7 :m_i(i) 8 { 9 } 10 // ++i 11 A& operator++() 12 { 13 ++m_i