第11章 使用类

最新推荐文章于 2024-06-19 14:25:46 发布
最新推荐文章于 2024-06-19 14:25:46 发布
阅读量115 收藏
点赞数
分类专栏： c++ primer plus 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59666413/article/details/125454375
版权

11.1 运算符重载

11.2 计算时间：一个运算符重载示例

mytime.h

#ifndef MYTIME_H_
#define MYTIME_H_

class Time
{
    private:
        int hours;
        int minutes;
    public:
        Time();
        Time(int h,int m = 0);
        void AddMin(int m);
        void AddHr(int h);
        void Reset(int h=0,int m=0);
        Time Sum(const Time &t) const;
        Time operator+(const Time &t) const;
        Time operator*(double m) const;
        friend Time operator*(double m,const Time &t);
        void Show() const;
};

#endif

mytime.cpp

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

Time::Time()
{
    hours = minutes = 0;
}

Time::Time(int h,int m)
{
    hours = h;
    minutes = m;
}

void Time::AddMin(int m)
{
    minutes += m;
    hours +=minutes/60;
    minutes = minutes%60;
}

void Time::AddHr(int h)
{
    hours +=h;
}

void Time::Reset(int h,int m)
{
    hours = h;
    minutes = m;
}

Time Time::Sum(const Time &t) const
{
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = t.hours +hours +  sum.minutes/60;
    sum.minutes %= 60;
    return sum;
}

Time Time::operator+(const Time &t) const
{
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = t.hours +hours +  sum.minutes/60;
    sum.minutes %= 60;
    return sum;
}

Time Time::operator*(double m) const
{
    Time result;
    long totalmin = hours*60*m + minutes*m;
    result.hours = totalmin/60;
    result.minutes = totalmin%60;
    return result;
}

Time operator*(double m,const Time &t)
{
    /*Time result;
    long totalmin = t.hours*60*m + t.minutes*m;
    result.hours = totalmin/60;
    result.minutes = totalmin%60;*/
    return t*m;
}

void Time::Show() const
{
    std::cout <<hours << " hours, " << minutes << " min\n";
}

usetime.cpp

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

Time::Time()
{
    hours = minutes = 0;
}

Time::Time(int h,int m)
{
    hours = h;
    minutes = m;
}

void Time::AddMin(int m)
{
    minutes += m;
    hours +=minutes/60;
    minutes = minutes%60;
}

void Time::AddHr(int h)
{
    hours +=h;
}

void Time::Reset(int h,int m)
{
    hours = h;
    minutes = m;
}

Time Time::Sum(const Time &t) const
{
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = t.hours +hours +  sum.minutes/60;
    sum.minutes %= 60;
    return sum;
}

Time Time::operator+(const Time &t) const
{
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = t.hours +hours +  sum.minutes/60;
    sum.minutes %= 60;
    return sum;
}

Time Time::operator*(double m) const
{
    Time result;
    long totalmin = hours*60*m + minutes*m;
    result.hours = totalmin/60;
    result.minutes = totalmin%60;
    return result;
}

Time operator*(double m,const Time &t)
{
    /*Time result;
    long totalmin = t.hours*60*m + t.minutes*m;
    result.hours = totalmin/60;
    result.minutes = totalmin%60;*/
    return t*m;
}

void Time::Show() const
{
    std::cout <<hours << " hours, " << minutes << " min\n";
}

执行结果：

planning time:0 hours, 0 min
coding  time:2 hours, 40 min
fixing time:5 hours, 55 min
total time:8 hours, 35 min
total time * 1.1:9 hours, 26 min

11.3 友元

  • 友元函数
  • 友元类
  • 友元成员函数

创建友元

友元函数是非成员函数，但范文权限和成员函数相同

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

        friend Time operator*(double m,const Time &t);

2、编写函数定义，应为不是成员函数，不加类限定符(time::)，定义中不用关键字friend。

程序用例：

mytime3.h

#ifndef MYTIME3_H_
#define MYTIME3_H_
#include <iostream>
class Time
{
    private:
        int hours;
        int minutes;
    public:
        Time();
        Time(int h,int m = 0);
        void AddMin(int m);
        void AddHr(int h);
        void Reset(int h=0,int m=0);
        Time Sum(const Time &t) const;
        Time operator+(const Time &t) const;
        Time operator*(double m) const;
        friend Time operator*(double m,const Time &t)
            {return t*m;}
        //void Show() const;
        friend std::ostream &operator<<(std::ostream &os,const Time &t);
};

#endif

mytime3.cpp


#include "mytime3.h"

Time::Time()
{
    hours = minutes = 0;
}

Time::Time(int h,int m)
{
    hours = h;
    minutes = m;
}

void Time::AddMin(int m)
{
    minutes += m;
    hours +=minutes/60;
    minutes = minutes%60;
}

void Time::AddHr(int h)
{
    hours +=h;
}

void Time::Reset(int h,int m)
{
    hours = h;
    minutes = m;
}

Time Time::Sum(const Time &t) const
{
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = t.hours +hours +  sum.minutes/60;
    sum.minutes %= 60;
    return sum;
}

Time Time::operator+(const Time &t) const
{
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = t.hours +hours +  sum.minutes/60;
    sum.minutes %= 60;
    return sum;
}

Time Time::operator*(double m) const
{
    Time result;
    long totalmin = hours*60*m + minutes*m;
    result.hours = totalmin/60;
    result.minutes = totalmin%60;
    return result;
}

/*Time operator*(double m,const Time &t)
{
    Time result;
    long totalmin = t.hours*60*m + t.minutes*m;
    result.hours = totalmin/60;
    result.minutes = totalmin%60;
    return t*m;
}*/

/*void Time::Show() const
{
    std::cout <<hours << " hours, " << minutes << " min\n";
}*/

std::ostream &operator<<(std::ostream &os,const Time &t)
{
    os << t.hours << " hours," << t.minutes << " minutes";
    return os;
}

usetime3.cpp

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

using  namespace std;

int main()
{
    Time coding(3,35);
    Time fixing(2,48);
    Time total;

    cout << "coding and fixing:" ;
    cout << coding << ";" << fixing << endl;

    total = coding + fixing;
    cout << "coding + fixing:" << total << endl;

    total = coding*1.17;
    cout << "coding*1.17:" << total << endl;

    cout << "10.0*fixing" << 10.0*fixing << endl;

    return 0;
}

运行结果：

coding and fixing:3 hours,35 minutes;2 hours,48 minutes
coding + fixing:6 hours,23 minutes
coding*1.17:4 hours,11 minutes
10.0*fixing28 hours,0 minutes

11.4重载运算符：作为成员函数还是非成员函数

11.5再谈重载：一个矢量类

示例：

vector.h

#ifndef VECTOR_H_
#define VECTOR_H_
#include <iostream>

namespace VECTOR
{
    class Vector
    {
        public:
            enum Mode{RECT,POL};  //状态成员 RECT直角坐标模式 POL极坐标模式
        private:
            double x;
            double y;
            double mag;
            double ang;
            Mode mode;
            void set_mag();
            void set_ang();
            void set_x();
            void set_y();

        public:
            Vector();
            Vector(double n1,double n2,Mode form = RECT);
            void reset(double n1,double n2,Mode form = RECT);
            ~Vector();
            double xval() const {return x;}
            double yval() const {return y;}
            double magval() const {return mag;}
            double angval() const {return ang;}
            void polar_mode();
            void rect_mode();
            Vector operator+(const Vector &b) const;
            Vector operator-(const Vector &b) const;
            Vector operator-() const;
            Vector operator*(double n) const;
            friend Vector operator*(double n,const Vector &a);
            friend std::ostream &operator<<(std::ostream &os,const Vector &v);
    };
}
#endif

vector.cpp

#include "vector.h"
#include <cmath>

using namespace std;

namespace VECTOR
{
   const double Rad_to_deg = 45.0/atan(1.0);
   void Vector::set_mag()
   {
       mag = sqrt(x*x+y*y);
   } 

   void Vector::set_ang()
   {
        if(x == 0 && y == 0)
            ang = 0;
        else
            ang = atan2(y,x);
   }

   void Vector::set_x()
   {
       x = mag*cos(ang);
   }

   void Vector::set_y()
   {
       y = mag*sin(ang);
   }

   Vector::Vector()
   {
       x = y =mag = ang = 0;
       mode = RECT;
   }

   Vector::Vector(double n1,double n2,Mode form)
   {
       mode = form;
       if(form == RECT)
       {
           x= n1;
           y =n2;
           set_mag();
            set_ang();
       }
       else if(form == POL)
       {
           mag = n1;
           ang = n2;
           set_x();
           set_y();
       }
       else
       {
           cout << "incorrect argument\n";
           cout << "vector set to 0";
           x = y =mag = ang = 0;
            mode = RECT;
       }
   }
   
   void Vector::reset(double n1,double n2,Mode form)
   {
       mode = form;
       if(form == RECT)
       {
           x= n1;
           y =n2;
           set_mag();
            set_ang();
       }
       else if(form == POL)
       {
           mag = n1;
           ang = n2;
           set_x();
           set_y();
       }
       else
       {
           cout << "incorrect argument\n";
           cout << "vector set to 0";
           x = y =mag = ang = 0;
            mode = RECT;
       }
   }

   Vector::~Vector()
   {

   }

   void Vector::polar_mode()
   {
       mode = POL;
   }

   void Vector::rect_mode()
   {
       mode = RECT;
   }

   Vector Vector::operator+(const Vector &b) const
   {
       return Vector((x+b.x),(y+b.y));
   }

   Vector Vector::operator-(const Vector &b) const
   {
       return Vector((x-b.x),(y-b.y));
   }

   Vector Vector::operator-() const
   {
       return Vector((-x),(-y));
   }

   Vector Vector::operator*(double n) const
   {
       return Vector(n*x,n*y);
   }

   Vector operator*(double n,const Vector &a) 
   {
       return a*n;
   }

   std::ostream &operator<< (std::ostream &os,const Vector &v)
   {
       //
       if(v.mode == Vector::RECT)
            os << "(x,y) = (" << v.x << "," << v.y <<")";
        else if(v.mode == Vector::POL)
        {
            os << "(m,a) = (" << v.mag << "," << v.ang <<")";
        }
        else
            os << "vector is invalid";

        return os; 
   }
}

随即漫步（醉鬼走路）：

randwalk.cpp

#include "vector.h"
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    using VECTOR::Vector;
    srand(time(0));
    double direction;
    Vector step;
    Vector result(0.0,0.0);
    unsigned long steps = 0;
    double target;
    double dstep;
    cout <<"enter target distance (q to quite):";
    while(cin >> target)
    {
        cout << "enter step length:";
        if(!(cin >> dstep))
        {
            break;
        }
        while(result.magval() < target)
        {
            direction = rand()%360;
            step.reset(dstep,direction,Vector::POL);
            result = result + step;
            steps++;
        }
        cout << "after " << steps << " steps,the subject has the following location:\n";
        cout << result << endl;
        result.polar_mode();
        cout << "or\n" << result << endl;
        cout << "average outward distance per step = " << result.magval()/steps << endl;
        steps = 0;
        result.reset(0.0,0.0);
        cout << "enter target distance(q to quit):";
    }
    cout << "Byte!\n";
    cin.clear();
    while(cin.get()!='\n')
        continue;
    return 0;
}

运行结果：

enter target distance (q to quite):10
enter step length:1
after 116 steps,the subject has the following location:
(x,y) = (-3.42834,-9.68444)
or
(m,a) = (10.2734,-1.91104)
average outward distance per step = 0.0885634
enter target distance(q to quit):20
enter step length:2
after 117 steps,the subject has the following location:
(x,y) = (6.30402,19.1596)
or
(m,a) = (20.17,1.25293)
average outward distance per step = 0.172393
enter target distance(q to quit):q
Byte!

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

stonewt.h

#ifndef STONEWT_H_
#define STONEWT_H_

class Stonewt
{
    private:
        enum {Labs_per_stn = 14};
        int stone;
        double pds_left;
        double pounds;
    public:
        Stonewt(double lbs);
        Stonewt(int stn,double lbs);
        Stonewt();
        ~Stonewt();
        void show_lbs() const;
        void show_stn() const;
};

#endif

stonewt.cpp

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

using namespace std;

Stonewt::Stonewt(double lbs)
{
    stone = int (lbs)/Labs_per_stn;
    pds_left = int (lbs)%Labs_per_stn +lbs - int(lbs);
    pounds = lbs;
}

Stonewt::Stonewt(int stn,double lbs)
{
    stone = stn;
    pds_left = lbs;
    pounds = stn*Labs_per_stn + lbs;
}

Stonewt::Stonewt()
{
    stone = pounds = pds_left = 0;
}

Stonewt::~Stonewt()
{

}

void Stonewt::show_stn() const
{
    cout << stone << "stone," << pds_left << "pounds\n";
}

void Stonewt::show_lbs() const
{
    cout << pounds << "pounds\n";
}

explicit:只能用于显示转换，不能用于隐式转换。

stone.cpp

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

using namespace std;

void display(const Stonewt &st,int n);

int main()
{
    Stonewt incognito = 275;
    Stonewt wolfe(285.7);
    Stonewt taft(21,8);

    cout << "the celebrity weighed ";
    incognito.show_stn();
    cout << "the detective weighed ";
    wolfe.show_stn();
     cout << "the president weighed ";
    taft.show_lbs();
    incognito = 276.8;
    taft = 325;
    cout << "after dinner,the celebrity weighed ";
    incognito.show_stn();
    cout << "after dinner,the president weighed ";
    taft.show_lbs();
    display(taft,2);
    cout << "the wrestler weiged even more.\n";
    display(422,2);
    cout << "No stone left unearned\n";
    return 0;
}

void display(const Stonewt &st,int n)
{
    for(int i = 0;i<n;i++)
    {
        cout << "Wow| ";
        st.show_stn();
    }
}

运行结果：

the celebrity weighed 19stone,9pounds
the detective weighed 20stone,5.7pounds
the president weighed 302pounds
after dinner,the celebrity weighed 19stone,10.8pounds
after dinner,the president weighed 325pounds
Wow| 23stone,3pounds
Wow| 23stone,3pounds
the wrestler weiged even more.
Wow| 30stone,2pounds
Wow| 30stone,2pounds
No stone left unearned

转换函数：

宜向华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算时间——一个运算符重载示例
Eumenides_Suki的博客
04-14 467
运算符重载 运算符重载是一种形式的C++多态。前面介绍过C++是如何使用户能够定义多个名称相同但特征标（参数列表）不同的函数的。这种被称为函数重载或函数多态，旨在让您能够用同名的函数来完成相同的基本操作，即使这种操作被用于不同的数据类型。运算符重载将重载的概念拓展到运算符上，允许赋予C++运算符多种含义。 实际上，很多C++运算符已经被重载。例如，将*运算符用于地址将得到存储在这个地址中的值；但将...
《C++ Primer Plus》学习笔记 | 第11章 使用类
大虎牙的博客
02-17 317
第11章 使用类 如果函数使用常规参数而不是引用参数，将发生什么情况呢？ 如果忽略了析构函数，又将发生什么情况呢？ 运算符重载，它允许将标准C++运算符用于类对象。 友元，这种C++机制使得非成员函数可以访问私有数据。 介绍如何命令C++对类执行自动类型转换。 11.1 运算符重载 运算符重载是一种形式的C++多态。 要重载运算符，需使用被称为运算符函数的特殊函数形式。 运算符函数格式如下...
C++PrimerPlus（第六版）中文版：第十一章使用类-计算时间：一个运算符重载示例（使用Sum函数未使用运算符重载）
只会写HelloWorld的专栏
09-19 100
首先是不用运算符重载的情况，用带有0字样的文件来标识。 mytime0.h 该文件定义了类Time ，文件内容如下 ： #pragma once #ifndef MYTIME0_H_ #define MYTIME0_H_ class Time { private: int hours; int minutes; public: Time(); Time(int h, int m = 0); void AddMin(int m); void AddHr(int h); void Rese
友元
weixin_54719957的博客
03-25 272
学习C++中，我们使用类，我们发现C++控制对类对象私有部分的访问，通常公有部分提供唯一的访问途径，这给C++带来了限制，友元能够帮我们很好的解决这个问题。 解决这种问题的方式： 1.严格按照A=B*2.75形式来写 2.使用非成员函数（友元） Time operator*(double m, const Time & t); 这种函数却无法访问私有部分，我们在类声明中加上friend,从而形成友元。 friend Time operator*(double m, const Time &am
【C++ Primer Plus】第11章 使用类
chaiky的博客
09-16 886
运算符重载。 友元函数。 重载
【C++ Primer Plus】第11章 使用类 编程练习
ReconTiner的博客
08-18 420
本文为为C++ Primer Plue 第11章 使用类编程练习的个人解答，如有错误请多多指教。
《C++ Primer Plus（第六版）》（18）（第十一章 使用类 笔记）
肥宝的实验室
12-21 2426
重载函数，友元函数，类型转换。
第十一章第一题（Triangle类）（Triangle class）
jxh1025_的博客
10-27 4042
第十一章第一题（Triangle类）（Triangle class） 11.1（Triangle类）设计一个名为Triangle的类来继承GeometricObject类。该类包括： 三个名为side1、side2和side3的double类型数据域表示这个三角形的三条边，他们的默认值是1.0。 一个无参构造方法，创建一个默认的三角形。 一个创建指定side1、side2和side3值的三角形的构造方法。 所有三个数据域的访问器方法。 一个名为getArea（）的方法返回三角形的面积。 一个名为get
Python编程从入门到实践课后答案:第十一章
weixin_41827268的博客
11-28 3177
11-1 城市和国家 ：编写一个函数，它接受两个形参：一个城市名和一个国家名。这个函数返回一个格式为City, Country 的字符串，如Santiago, Chile 。将 这个函数存储在一个名为city_functions.py的模块中。 创建一个名为test_cities.py的程序，对刚编写的函数进行测试（别忘了，你需要导入模块unittest 以及要测试的函数）。编写一个名为test_...
数据库系统概论第十一章习题
qq_36684096的博客
02-14 5942
1.数据库中为什么要并发控制？并发控制技术能保证事务那些特性？ 答：如果事务是串行执行，会让大部分资源得不到利用，数据库采用并发采用，使多个事 务可以同时进行，充分利用系统资源，但这会使事务ACID特性遭到破坏，因此需要采 用并发控制；隔离性、一致性。 2.并发操作可能产生哪几类数据不一致？用什么方法能避免不一致情况。 答：丢失修改（两事务同时修改）、不可重复读（一个事务读之后，另一...
第11章构建房地产类网站.ppt
11-12
第11章构建房地产类网站.ppt
第十一章 Object类和包装类.md
10-24
==与equals的比较，包装类的使用
第11章 类和对象.pptx
06-23
类与对象的PPT演示，C++，为初学者提供可靠的学习资料
第11章 常用类1
08-08
字符串是Java编程中不可或缺的一部分，本章主要讨论的是Java中的常用类，特别是包装类和字符串类`String`。首先，我们需要理解包装类（Wrapper Class）在Java中的作用和重要性。 包装类是Java为基本数据类型提供的...
疯狂android资料：第十一章多媒体应用开发.doc
11-26
疯狂 Android 资料第十一章多媒体应用开发 本章节主要讲解 Android 中多媒体应用开发，涵盖音频和视频的播放控制。Android 提供了常见音频、视频的编码、解码机制，并支持多种音频和视频格式。下面将详细介绍音频和...
C++ day3
2301_81402136的博客
06-17 255
【代码】C++ day3。
C语言中的内存分配方式（静态分配、动态分配）定义以及区别
2402_85246552的博客
06-17 265
这种分配方式主要用于局部变量，特别是那些大小在编译时无法确定，或者需要在程序运行时改变大小的变量。：malloc函数用于在堆（heap）上分配指定字节数的内存，并返回一个指向该内存区域的指针。内存分配发生在程序运行时，所以内存大小和生命周期可以在运行时动态改变。内存分配在程序编译时就已经确定，所以内存大小和生命周期都是固定的。静态分配的变量在函数调用时，它们的内存空间会在函数调用栈帧中分配，并在函数返回时释放。动态分配的变量的内存空间在堆上，函数调用时传递的是指针，所以函数调用的开销相对较小。
项目篇：加入Python程序之如何在Python中使用C++？
最新发布
Francis的博客
06-19 210
项目篇：加速Python程序之如何在Python中使用C++？通常像一些耗时的操作，我们期望在C++中去实现，然后使用Python去调用对应的接口，或者因为底层库的原因，需要支持对外的Python API，那么我们通常需要支持在Python中访问C++，如何实现呢？方法比较多，本节以pybind11为例，引入一个完整的项目工程模版，如果你后续有这种需求，可以基于模版去修改。注：(懒人版)本节的所有...
文件操作（1）（C语言版）
m0_75235246的博客
06-17 1055
前言：为什么要学习文件操作
jquery第11章网上蔚蓝书店
11-20
jquery 第11章介绍了网上蔚蓝书店的网站开发，书店的在线销售系统通过使用 jQuery 实现了许多交互功能，使用户在浏览和购买图书时更加便捷和快速。 该章节首先介绍了网上蔚蓝书店网站的整体设计和功能模块，包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值