精华内容
下载资源
问答
  • C++ 重载输入输出运算符

    千次阅读 多人点赞 2019-08-24 11:55:24
    一、为什么要重载输入输出运算符 平时可以用流 std::cout<<str<<n ; std::cin>>str>>n ; 输出、输入字符串和整型等。但是对于自定义的类,比如 Student 类,却不能直接通过 cout<<...

    一、为什么要重载输入输出运算符

    平时可以用流 std::cout<<str<<n ; std::cin>>str>>n ; 输出、输入字符串和整型等。但是对于自定义的类,比如 Student 类,却不能直接通过 cout<<Student 或 cin>>Student 这样的形式来输出类的内容或给类赋值。为了让自定义的类也支持这样的操作,可以通过重载输出、输入运算符。

    二、重载输出运算符

    ostream& operator << (ostream& os,const 类& n)
    {
    }
    

    1、通常情况下,输出运算符的第一个形参是一个非常量的ostream 对象的引用。(非常量是因为向流写入内容会改变其状态; 用引用是因为流对象不支持复制)
    2、第二个参数一般来说是一个常量的引用,该常量是我们想要输出的类类型。(用引用是因为我们希望避免复制实参; 用常量是因为通常打印对象的时候不需要改变对象的内容)
    3、输入、输出运算符都必须是非成员函数。否则,他们的左侧运算对象将是我们的类的一个对象。所以一般会声明为友元函数(friend),这样输出运算符函数也能使用类的私有成员

    //假设我们定义了类Student,输出运算符函数为成员函数
    class Student
    {
    public:
     ostream  &operator<<(ostream &os);
     ...
    };
    ...
    Student    stu;
    //为了直观,用这种方式调用输出运算符函数
    stu.operator<<(cout);   //stu<<cout ,显然已经错了

    三、重载输入运算符

    与重载输出运算符类似

    四、解析返回值为什么是引用

      流操作符<<和>>,这两个操作符常常希望被连续使用。例如:当执行cout<<a<<b;时,可以等价为(cout<<a)<<b;(cout<<a)是具有新内容的流对象cout,(cout<<a)<<b就相当于(新cout)<<b,操作符左侧仍是ostream类对象cout。因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。
      可选的其它方案包括:返回一个流对象和返回一个流对象指针。
      但是对于返回一个流对象,程序必须重新(拷贝)构造一个新的流对象,也就是说,连续的两个<<操作符实际上是针对不同对象的!这无法让人接受。
      对于返回一个流指针则不能连续使用<<操作符。因此,返回一个流对象引用是惟一选择。这个唯一选择很关键,它说明了引用的重要性以及无可替代性,也许这就是C++语言中引入引用这个概念的原因吧。赋值操作符=。
      这个操作符象流操作符一样,是可以连续使用的,例如:x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值,以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

    五、实现代码

    #include <iostream>
    
    using namespace std;
    
    class Point
    {
    	int x;
    	int y;
    public:
    	Point(int _x=0,int _y=0)
    	{
    		x = _x;
    		y = _y;
    	}
    
    	friend ostream& operator<<(ostream& os,const Point& p);
    	friend istream& operator>>(istream& is,Point& p);
    };
    
    ostream& operator<<(ostream& os,const Point& p)
    {
    	return os << p.x << "," << p.y;
    }
    
    istream& operator>>(istream& is,Point& p)
    {
    	cout << "请输入x的值:";
    	is >> p.x;
    	cout << "请输入y的值:";
    	is >> p.y;
    	return is;
    }
    
    int main()
    {
    	Point p1(1,7);
    	cin >> p1;
    	cout << p1 << endl;
    }

     

    展开全文
  • cout 输出运算符重载" ; std::cout ; //相当于cout.operator(boy1) //boy ; //相当于boy.operator(cout); cout 输入运算符重载" ; cin >> boy1 >> boy2; cout 输出运算符重载" ; std::cout ; system("pause"); ...

    成员函数输出重载

    Human.h

    #pragma once
    #include<string>
    #include <ostream>
    class Human{
    public:
    	Human(const char* name, int age, int salare,int DarkHouse);
    	~Human();
    	std::ostream& operator<<(std::ostream& os);
    
    private:
    	char* name;
    	int age;
    	int salare;
    	int DarkHouse;
    	unsigned int id;
    	static int last_iD;
    };
    
    std::ostream& Human::operator<<(std::ostream& os) {
    	//cout<<为ostream一个对象
    	os << "姓名:" << name << "\t年龄:" << age << "\t薪资:"
    		<< salare << "\t黑马值:" << DarkHouse << "\t编号:" << id << '\n';
    	return os;   //返回cout继续输出
    } 

    main.cpp

    #include"Human.h"
    #include<iostream>
    
    int main() {
    	Human boy("Rock", 38, 58000, 5);
    	//std::cout << boy << ;  相当于cout.operator<<(boy1)
    	boy << std::cout;   //相当于boy.operator<<(cout);
    
        //如果继续输出
        //boy1<<(boy<<cout)  先执行括号内的,返回cout,再执行boy1<<cout
    	system("pause");
    	return 0;
    }

    运行结果:

     这张方法使用起来很不方便

    方法2:使用友元函数

    man.h

    #pragma once
    #include<string>
    #include <ostream>
    class Human{
    public:
    	Human(const char* name, int age, int salare,int DarkHouse);
    	~Human();
    	friend std::ostream& operator<<(std::ostream& os,const Human&human);
    	friend std::istream& operator>>(std::istream& is, Human& human);
    
    private:
    	char* name;
    	int age;
    	int salare;
    	int DarkHouse;
    	unsigned int id;
    	static int last_iD;
    };
    

    main.cpp

    #include"Human.h"
    #include<iostream>
    #include<ostream>
    using namespace std;
    
    
    std::ostream& operator<<(std::ostream& os, const Human& human)
    {
    	//cout<<为ostream一个对象
    	os << "姓名:" << human.name << "\t年龄:" << human.age << "\t薪资:"
    		<< human.salare << "\t黑马值:" << human.DarkHouse << "\t编号:" << human.id << '\n';
    	return os;
    }
    
    std::istream& operator>>(std::istream& is, Human& human) {
    	string name;
    	is >> name>>human.age >> human.salare >> human.DarkHouse >> human.id;
    	human.name = new char[(name.length() + 1)*sizeof(char)];
        //.c_str()可以改成C字符串
    	strcpy_s(human.name, (name.length() + 1) * sizeof(char), name.c_str());
    	return is;
    }
    int main() {
    	Human boy1("Rock", 38, 58000, 5);
    	Human boy2("Jack", 25, 50000, 10);
    	cout << "输出运算符重载" << endl;
    	std::cout << boy1 << boy2;     //相当于cout.operator(boy1)
    	//boy << std::cout;   //相当于boy.operator(cout);
    	cout << "\n输入运算符重载" << endl;
    	cin >> boy1 >> boy2;
    	cout << "\n输出运算符重载" << endl;
    	std::cout << boy1 << boy2;
    	system("pause");
    	return 0;
    }

    运行结果:

     

    展开全文
  • C++输入 / 输出运算符重载-详细解释

    千次阅读 多人点赞 2020-01-18 16:13:32
    为什么需要重载输入输出运算符 有人会问,我直接用 iostream 里面的标准输入输出不好吗,搞这么麻烦? 事实上,你会发现C++里面很多的(尤其是运算符)重载都是 面向对象惹的祸。而用户自定义数据类型的输入输出,...

    为什么需要重载输入输出运算符

    有人会问,我直接用 iostream 里面的标准输入输出不好吗,搞这么麻烦?
    事实上,你会发现C++里面很多的(尤其是运算符)重载都是 面向对象惹的祸。而用户自定义数据类型的输入输出,就是通过重载运算符“<<“和”>>“实现的。

    重载输出运算符

    重载输出运算符”<<“也称为插入运算符,用于用户自定义类型的输出,其定义函数的一般形式为:

    ostream &operator<<( ostream &stream, 类名 对象名 )
    {
    	// 操作代码
    	return stream;
    }
    

    其中,第一个参数stream是对ostream对象的引用,必须是输出流,它可以是其他合法的标识符,但必须与return后面的标识符相同;第二个参数接收将被输出的对象。

    重载输入运算符

    重载输入运算符“>>“也称为提取运算符,用户用于自定义类型的输入,其定义函数的一般格式为:

    istream &operator<<( istream &stream, 类名 &对象名 )
    {
    	// 操作代码
    	return stream;
    }
    

    其中,第一个参数stream是对istream对象的引用,必须是输出流,它可以是其他合法的标识符,但必须与return后面的标识符相同;第二个参数是一个引用,前面的“&”不能省略。

    特别注意

    • 重载输入运算符函数不能是类的成员函数,必须是类的非成员函数
    • 作为非成员函数,重载输入运算符不能访问类的私有成员

    故:输入输出运算符的重载必须用友元函数

    一个代码实现

    // 输入输出运算符的重载
    // 重载输入输出运算符必须用友元函数
    #include <iostream>
    // 为调用system("pause")
    // #include <stdlib.h>
    // Linux 或者 Mac 下应使用 pause();
    // #include <unistd.h>
    // 但这里使用getchar(),因为那个我不会...
    #include <stdio.h>
    
    using namespace std;
    
    class Overload_IO
    {
    public:
    	int a;
    	int b;
    	Overload_IO():a(0),b(0){}
    	Overload_IO(int a, int b):a(a),b(b){}
    	friend ostream &operator<<(ostream &os, const Overload_IO &T);
    	friend istream &operator>>(istream &is, Overload_IO &T);
    };
    
    ostream &operator<<(ostream &os, const Overload_IO &T)
    {
    	os << "a = " << T.a << endl;
    	os << "b = " << T.b << endl;
    
    	return os;
    }
    
    istream &operator>>(istream &is, Overload_IO &T)
    {
    	is >> T.a >> T.b;
    	return is;
    }
    
    int main(int argc, char *argv[])
    {
    	Overload_IO t(1, 2);
    	cout << t << endl;
    
    	cout << "请输入a b:" << endl;
    	cin >> t;
    	cout << t << endl;
    
    	// system("pause");
    	getchar();			// 用于消除输入数据时的回车
    	getchar();
    	return 0;
    }
    
    
    

    运行结果(vscode, Mac)

    a = 1
    b = 2
    
    请输入a b:
    3 4
    a = 3
    b = 4
    
    // 注意这里我又敲了一个回车
    
    展开全文
  • ostream& operator (ostream &out, const people& p1)//输出运算符重载 { out 的值" ; return out; } istream& operator >>(istream& ifs, people& p1) {//重载输入运算符 ifs >> p1.age; ifs >> p1.num; return ...
    #include <iostream>
    using namespace std;
    
    class people {
       // friend ostream& operator <<(ostream& out, const people p1);
       /* friend people& operator ++(people& p1);
        friend people& operator ++(people& p1, int wuyong);*/// 什么时候加上友元函数声明 比如需要访问类中私有类成员 否则不用添加 
    public:
    int age;
        int num;
        people(int age,int num)
        {
            this->num = num;
            this->age = age;
        }
        ~people() {
    
        } 
        people& operator ++() {
            (this->age)++;
            (this->num)++;
            return *this;
        }
        
    };
      ostream& operator <<(ostream &out, const people& p1)//输出运算符重载
    
       {
            out << "p1的值" << p1.age << endl;
            return out;
       }
      istream& operator >>(istream& ifs,  people& p1) {//重载输入运算符
          ifs >> p1.age;
          ifs >> p1.num;
          return ifs;
      }
      people& operator ++(people& p1) {//前置++数重载据类型利用非成员函数实现
          p1.age++;
          p1.num++;
          return p1;
      }
      people& operator ++(people& p1, int wuyong) {//后置++运算符重载利用非成员函数重载
          people temp(p1.age, p1.num);
          p1.age++;
          p1.num++;
          return temp;
      }
      people& operator --(people& p1, int wuyong) {//后置--运算符重载利用非成员函数重载
          people temp(p1.age, p1.num);
          p1.age--;
          p1.num--;
          return temp;
      }
    int main()
    {
        people p1(2,3);
        cin >> p1;
        cout << p1.age << endl;
        
    }
    

    展开全文
  • C++ 输入输出运算符重载 感想

    千次阅读 多人点赞 2017-03-14 17:39:29
    C++中,经常会对输入输出运算符进行重载,而在重载的时候用到了友元(Friends)和引用返回(Returning References),这里对为什么会这么用发表一些思考。 比如,下面的类是一个简单的Student类,其中重载了和>>...
  • C++输入输出运算符重载

    千次阅读 多人点赞 2018-07-26 10:49:48
    ”和流输出运算符“&amp;amp;lt;&amp;amp;lt;”在C++类库中提供的,所有的C++编译系统都会在提供输入流istream和输出流ostream,cin、cout是分别是istream类和ostream类的对象,在类库的头文件中已经对“&...
  • 输出运算符重载 他有两种方式: 使用成员函数(不推荐,该方式没有实际意义,在这里就不代码演示了) 2. 使用友元函数(极力推荐使用该方式) 使用友元函数重载输出运算符 << 需求: 定义Boy类,Boy类...
  • 文章目录一、运算符重载二、复数类CComplex三、输出运算符重载 一、运算符重载 运算符重载: 使对象的运算运算表现得和编译器内置类型一样,使同一个运算符可以有不同的功能。即定义一个重载运算符的函数,使指定的...
  • } 声明一点:我们需要把输入输出运算符重载函数声明为类的友元函数,这样我们就能不用创建对象而直接调用函数。 对上面做句话做一个解释:如果在类中直接定义一个函数,比如在类中定义一个重载“+”的函数,那么在...
  • 重载输入运算符 >> 先了解两个小点: 输入和输出运算符只能用友元函数重载。 友元函数:指某些虽然不是类成员却能够访问类的所有成员的函数。 上示例代码 #include<iostream> using namespace std; ...
  • 结构体重载输入输出运算符

    千次阅读 2019-08-07 21:01:54
    可以直接输入结构体,顺便初始化; #include<bits/stdc++.h> using namespace std; struct node { int x, y, z; friend istream & operator >> (istream&, node &t) { cin >>...
  • C++重载和>>(输入输出运算符

    千次阅读 2015-11-26 14:50:00
    如果自定义了一种新的数据类型,需要用输入输出运算符去处理,那么就要重载。 重载输入运算符: 下面用全局函数的形式重载输入运算符,使它能够读入两个double类型的数据,并转换为一个复数,保存到复数对象
  • c++中类的私有成员是不能被直接访问的,需要通过类中提供的成员函数简介的操作这些数据。同时C++ 能够使用流提取运算符... 但是如果直接在类内部直接重载输入输出运算符,那么在使用时只能通过Obj>>cin ...
  • c++输入输出运算符重载

    千次阅读 2019-04-27 09:18:23
    说明:输入输出运算符重载必须为友元函数,并且必须有输入输出流的返回值,固定格式为: friend istream& operator >> (istream&, 重载类名&); friend ostream& operator << ...
  • C++输入输出运算符重载

    千次阅读 2019-03-10 17:16:23
    通常情况下,输出运算符的第一个形参是一个非常量ostream的引用,之所以使用引用,是因为我们无法直接复制一个ostream的对象,而ostream是非常量是因为向流写入会改变其状态。为了与标准库IO操作一致,重载 &lt;...
  • 通常情况下,输出运算符的第一个形参是一个非常量ostream对象的引用。之所以ostream是非常量是因为向里路写入内容会改变其状态,而该形参的引用时因为我们二u发直接赋值一个ostream对象 第二个形参一般来说一个常量...
  • 设一个程序,利用重载输入运算和重载输出运算实现对一个2X3的矩阵输入输出,重载‘+’运算符实现两个矩阵相加。利用模板的知识,使矩阵可以是int类型、double类型等其他类型 注意:在定义一个类模板的时候,如果...
  • 1.重载输入输出运算符的问题。 (1)重载输入运算符发现的问题。 定义一个复数类,定义c1、c2、 c3、 c4、 c5五个对象。 主函数中 cin &gt;&gt;c1&gt;&gt;c2; 重载输入运算符,输入输出...
  • C++ 能够使用流提取运算符 >> 和流插入运算符输入输出内置的数据类型。您可以重载流提取运算符和流插入运算符来操作对象等用户自定义的数据类型。 在这里,有一点很重要,我们需要把运算符重载函数声明为类...
  • C++ 中,左移运算符<cout 是 ostream 类的对象。ostream 类和 cout 都是在头文件 中声明的。ostream 类将<ostream & ostream::operator << (const char* s){//输出s的代码return * this;}为了使...
  • 题目要求如下: 1) 基本的构造函数; 2) 成员运算符+、-实现复数的加减运算; 3) 友元运算符+、-实现更合理的加减运算; 4) 运算符和>>实现复数类的输出输入
  • (我被灌输的第一印象是输入输出运算符不能重载成成员函数,后来发现不是不能,而是习惯上的选择。) 众所周知,作为类的非静态成员函数,第一个参数隐藏为this指针,这样才能被对象调通过 obj.fun() 的方式实现调用...
  • ”和“cin>>”对标准类型数据进行输入输出的,都要用#include 把头文件包含到本程序文件中。 用户自己定义的类型的数据,是不能直接用“<<”和“>>”来输出和输入的。如果想用它们输出和输入自己声明的类型的...
  • C++内置了多种运算符,支持基本数据类型运算,其中的部分运算符已针对不同操作数类型进行了重载 将这些运算符用于自定义类型时,可进行运算符重载 运算符重载只是一种 “ 语法上的方便 ” ,也就是说这是另一种函数...
  • c++重载流插入运算符和流提取运算符

    千次阅读 多人点赞 2018-06-19 10:01:04
    C++的流插入运算符“&lt;&lt;”和流提取运算符“&gt;&gt;”是C++在类库中提供的,所有C++编译系统都在类库中提供...”进行了重载,使之作为流插入运算符和流提取运算符,能用来输出输入C++标准类...
  • 输入输出运算符重载为模板类的友元函数时,如果只是在类体中写为ostream&amp; operator&lt;&lt;(ostream&amp; out,MyClass&lt;T&gt;&amp; c),编译时将会出现连接错误,解...
  • C++ 运算符重载

    万次阅读 多人点赞 2018-12-26 21:39:21
    前言 本文引用于“C语言中文网...2. C++重载=(C++重载赋值运算符) 3. C++深拷贝和浅拷贝(C++深复制和浅复制) 4. C++运算符重载为友元函数 5. C++实现可变长度的动态数组 6. C++重载&lt;&lt;和&gt;...
  • C++中,标准库本身已经对左移运算符<>分别进行了重载,使其能够用于不同数据的输入输出,...如果我们自己定义了一种新的数据类型,需要用输入输出运算符去处理,那么就必须对它们进行重载。本节以前面的 ...
  • C++里面,我们想打印类的信息,需要重载运算符,这篇博客将介绍如何重载运算符打印类消息。并且介绍这么做的一些规则和原因。重载运算符打印自定义类信息我们用代码来进行说明:我们定义一个Person类,想要打印出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,386
精华内容 12,954
关键字:

c++重载输入输出运算符

c++ 订阅