关闭

C++学习笔记(三)

标签: c++运算符重载重载流插入运算符重载流提取运算符sdut电子时钟的运算符重载
828人阅读 评论(0) 收藏 举报
分类:

 运算符重载

热身:

电子时钟的运算符重载:

在主函数main()中指定开始时间和结束时间,并调用相应成员函数,显示从开始时间到结束时间之间所有时间对象的值,其格式见示例输出。

输入

输入6个整数,之间用一个空格间隔;分别表示开始时间的时、分、秒和结束时间的时、分、秒的值

输出

从开始时间到结束时间之间所有时间对象的值;每个值占一行,格式为hh:mm:ss

示例输入

01 01 01 01 01 10

示例输出

01:01:01
01:01:02
01:01:03
01:01:04
01:01:05
01:01:06
01:01:07
01:01:08
01:01:09
01:01:10

提示

输入
11 10 12 10 12 56
输出
The begin time is not earlier than the end time!
#include <iostream>

using namespace std;

class Time   //设计一个Time类
{
    private:
        int hour;
        int minute;
        int second;
    public:
        Time() {}
        Time(int hour,int minute,int second);
        Time operator ++ ();
        void disPlay();
        int compare(Time &);
};


Time :: Time(int hour,int minute,int second)   //构造函数
{
    this->hour = hour;
    this->minute = minute;
    this->second = second;
}
Time Time::operator++ ( )    // 重载了++ ,使其++类时,类内部的属性按照时分秒逐步增加的规则增加
{
        if(++second >= 60)
        {
            second -= 60;

            if( ++minute >=  60)
            {
                minute -= 60;
                ++hour;
            }
        }
}
void Time::disPlay()     //输出时分秒的方法
{
    if(hour <10) cout<<"0"<<hour<<":";
    else  cout<<hour<<":";
    if(minute < 10) cout<<"0"<<minute<<":";
    else cout<<minute<<":";
    if(second <10) cout<<"0"<<second;
    else cout<<second;
    cout<<endl;
}
//判断第一个对象的时分秒,与第二个时分秒的关系,第一个时分秒在第二个时分秒之前则输出true,否则输出false
int Time::compare(Time & t)    
{
    if(hour > t.hour)
    {
        return false;
    }else if(hour== t.hour&& minute > t.minute)
    {
        return false;
    }else if(hour == t.hour && minute == t.minute && second > t.second)
    {
        return false;
    }else
    {
        return true;
    }
}


int main()
{
    int h1,h2,m1,m2,s1,s2;
    cin>>h1>>m1>>s1;
    cin>>h2>>m2>>s2;
    Time time1(h1,m1,s1);
    Time time2(h2,m2,s2);
  
    if(! time1.compare(time2) )    // 判断两个对象的关系,是否符合第一各对象的时间在第二各对象的时间前面
    {
        cout<<"The begin time is not earlier than the end time!"<<endl;
    }else
    {


        while(time1.compare(time2))  //判断两个对象的关系,作为结束条件
        {
            time1.disPlay();
            ++time1;
        }
    }
    return 0;
}
运算符重载
运算符重载实质是函数重载
函数类型  operator 运算符名称 (形参列表)
{ 对运算符的重载处理 }
运算符重载后其原有功能仍存在,并未消失。
规则:
(1).c++不允许用户自己定义新的运算符,只能对已有的运算符重载。
(2).不能重载的运算符"."(成员运算符) ".*"(成员指针访问运算符) " :: "(域运算符) "sizeof"(长度运算符) " ?: "(条件运算符)
(3).不能改变运算符运算对象
(4).不能改变运算符优先级
(5).不能改变运算符的结合性
(6).重载运算符的函数不能有默认参数。
(7).重载的运算符必须和用户定义的自定义类型一起使用,其参数至少应是一个类的对象。
(8).运算符= 和 &不必用户重载。=:
重载流插入运算符和流提取运算符
istream  & operator >> (istream &,自定义 &);
ostream & operator << (ostream &,自定义 &);
只能将他们定义为友元函数或普通函数,而不能将它们定义为成员函数。
例:
#include <iostream>

using namespace std;

class Complex
{
    private:
        double real;
        double imag;
    public:
        Complex() {}
        Complex(double real,double imag);
        Complex operator + (Complex &c);    //重载运算符+,可让Compex的对象相加
        friend ostream & operator << (ostream &,Complex &);  //重载《《流输出运算符,输出Complex对象
        friend istream & operator >> (istream &,Complex &);   //重载》》流输入运算符,输入Complex对象
        
};

Complex::Complex(double real,double imag)
{
    this->real = real;
    this->imag = imag;
}

Complex Complex::operator + (Complex& c)
{
    Complex c1;
    c1.real = real + c.real;
    c1.imag = imag + c.imag;
    return c1;
}


ostream & operator <<(ostream &output,Complex & c)
{
    output<<"real:"<<c.real;
    output<<"imag"<<c.imag<<endl;

    return output;
}

istream & operator >> (istream &input,Complex &c)
{
    cout<<"input real part and imaginary part of complex number"<<endl;
    input>>c.real>>c.imag;

    return input;
}
int main()
{
    Complex c1,c2,c3;
    cin>>c1>>c2;
    cout<<c1<<c2;
    c3 = c1 + c2;
    cout<<c3<<endl;
    return 0;
}
不同类型数据见的转换
转换构造函数进行类型转换
#include <iostream>

using namespace std;

class Complex
{
    private:
        double real;
        double imag;
    public:
        Complex(double num)    //转换构造汉函数
        {
            real = num;
            imag = 0;
        }

        Complex(int real,int imag)  // 实现初始化的构造函数
        {
            this->real = real;
            this->imag = imag;
        }
        Complex() { }    // 默认构造函数
        void getComplex()
        {
            cout<<"real:="<<real<<"     imag="<<imag<<endl;
        }

        friend Complex operator + (Complex c1,Complex c2)  //重载运算符 +
        {
            Complex c;
            c.real = c1.real + c2.real;
            c.imag = c1.imag + c2.imag;
            return c;
        }
};
int main()
{
    Complex c1(1,2),c2,c3;
    c2 = c1 + Complex(10);
    /*
        Complex(10),是建立了一个Complex的临时对象,调用
        转换构造函数建立对象
    */
    c3 = c1 + 3.5;
/*
c1 + 3.5 编译系统把它解释为operator + (c1,3,5),由于2.5不是Complex类对象,系统先调用转换构造函数Complex(3.5)
类临时对象,其值为(3.5,0i),相当于operator(c1,Complex(3.5)).
*/
    cout<<"c1="<<endl;
    c1.getComplex();

    cout<<"c2="<<endl;
    c2.getComplex();

    cout<<"c3="<<endl;
    c3.getComplex();
    return 0;
}
转换构造函数也是一种构造函数,只有一个参数。
类型转换函数
#include <iostream>

using namespace std;

class Complex
{
    private:
        double real;
        double imag;
    public:
        Complex(int real,int imag)  // 实现初始化的构造函数
        {
            this->real = real;
            this->imag = imag;
        }
        Complex() { }    // 默认构造函数
        operator double()
        {
            return real;
        }
};
int main()
{
    Complex c1(1,2);
    double d;
    d =  c1 + 3.4 ;   //将一个double类型的数据与Complex类对象相加
    cout<<d<<endl;
    return 0;
}
类型装换函数是将一个类的对象转换成另一各数据类型。
operator  类型名()
{类型转换语句}
在函数名前不能指定函数类型,函数没有参数。


1
0

猜你在找
【直播】机器学习&数据挖掘7周实训--韦玮
【套餐】系统集成项目管理工程师顺利通关--徐朋
【直播】3小时掌握Docker最佳实战-徐西宁
【套餐】机器学习系列套餐(算法+实战)--唐宇迪
【直播】计算机视觉原理及实战--屈教授
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之矩阵--黄博士
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之凸优化--马博士
【套餐】Javascript 设计模式实战--曾亮
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:85121次
    • 积分:1662
    • 等级:
    • 排名:千里之外
    • 原创:77篇
    • 转载:6篇
    • 译文:1篇
    • 评论:10条