10.3作业

#include <iostream>
 
 
using namespace std;
 
 
//定义一个复数类 5 + 3i
class Complex
{
private:
    int real;         //实部
    int vir;          //虚部
 
 
public:
    Complex() {}
    Complex(int r, int v):real(r), vir(v) {}         //有参构造
 
 
    //定义展示函数
    void show()
    {
        if(vir>=0)
        {
            cout<<real<<" + "<<vir<<"i"<<endl;
        }else
        {
            cout<<real<<vir<<"i"<<endl;
        }
    }
 
 
    //全局函数版实现加运算符重载
    friend const Complex operator+ (const Complex &L, const Complex &R);
 
 
    //成员函数版实现运算符重载
    const  Complex  operator- ( const Complex  &R)const
    {
        Complex c;
 
 
        c.real = this->real - R.real;
        c.vir = this->vir - R.vir;
 
 
        return c;
    }
 
 
    //成员函数版实现关系运算符的重载:实部>实部  && 虚部>虚部
    bool operator>(const Complex &R)const
    {
        return this->real>R.real&&this->vir>R.vir;
    }
 
 
    //重载中括号运算符
    int & operator[](int index)
    {
        if(index == 0)
        {
            return real;          //返回实部
        }else if(index == 1)
        {
            return vir;           //返回虚部
        }
    }
 
 
 
 
    //重载+=运算符:实部+=实部   虚部+=虚部
    Complex & operator+=(const Complex &R)
    {
        this->real += R.real;
        this->vir += R.vir;
 
 
        return *this;                //返回自身的引用
    }
 
 
    //重载负号运算符: 实部= -实部, 虚部 = -虚部
    Complex operator-()
    {
        Complex c;
        c.real = -this->real;
        c.vir = -this->vir;
 
 
        return c;
    }
 
 
    //重载前置自增运算符重载函数:实部 = 实部+1   虚部=虚部+1
    Complex &operator++()
    {
        ++this->real;
        ++this->vir;
 
 
        return *this;
    }
 
 
    //重载后置自增运算符重载函数:实部 = 实部+1   虚部=虚部+1
    Complex operator++(int)
    {
        Complex c;
 
 
        c.real = this->real++;
        c.vir = this->vir++;
 
 
        return c;
    }
 
 
 
 
    //将全局函数版实现的输出运算符重载函数设置成友元
    friend ostream &operator<<(ostream &L, Complex &c);
 
 
    //重载小括号运算符,做一个仿函数
    void operator()(string s)
    {
        cout<<s<<endl;
    }
 
 
    //重载小括号运算符,做一个仿函数
    void operator()()
    {
        cout<<520<<" "<<1314<<endl;
    }
 
 
    //重写类型转换运算符
    operator int()
    {
        return real;         //将该数据类型向int类型转换后,使用的是real的值
    }
 
 
 
 
};
 
 
//全局函数版实现加号运算符重载:实部+实部  虚部+虚部
const Complex operator+ (const Complex &L, const Complex &R)
{
    //定义一个临时空间
    Complex c;
 
 
    c.real = L.real + R.real;
    c.vir = L.vir + R.vir;
 
 
    return c;
}
 
//重载输出运算符函数
ostream &operator<<(ostream &L, Complex &c)
{
    if(c.vir>=0)
    {
        L<<c.real<<" + "<<c.vir<<"i"<<endl;
    }else
    {
        L<<c.real<<c.vir<<"i"<<endl;
    }
 
 
    //返回左操作数自身的引用
    return L;
}
 
 
int main()
{
    Complex c1(5,3);
    c1.show();                    //5+3i
 
 
    Complex c2(2,-1);
    c2.show();                      //2-1i
 
 
    Complex c3 = c1-c2;             //调用加法运算符重载函数  c1.operator-(c2)
 
 
    c3.show();                      //3+4i
 
 
 
 
    if(c3 > c2)              //调用关系运算符重载函数
    {
        cout<<"yes"<<endl;
    }else
    {
        cout<<"no"<<endl;
    }
 
 
    c3[0] = 5;               //将实部进行修改成5,调用中括号运算符重载
    c3.show();                  //5+4i
 
 
    c3 += c2;            //调用+=运算符重载函数
    c3.show();             //7+3i
 
 
    Complex c4 = -c3;      //调用-号运算符重载
    c4.show();              //-7 - 3i
    c3.show();            //7+3i
 
 
    Complex c5 = ++c3;          //调用前置自增运算符重载函数
    c5.show();                  //8+4i
    c3.show();                   //8+4i
 
 
    Complex c6 = c3++;           //调用后置自增运算符重载函数
    c6.show();                   //8+4i
    c3.show();                   //9+5i
 
 
    cout<<c3;                //cout.operator<<(c3)
 
 
    c3("hello world");      //c3.operator()("hello world");
    c3();
 
    
    int num = (int)c3;            //调用类型转换运算符重载函数
    cout<<"num = "<<num<<endl;
 
    return 0;
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
首先,我们需要将作业按照需要的主存量进行排序: D (10K) < E (20K) < C (50K) < A (15K) < B (60K) 接下来,我们进行可变式分区存储管理。 初始状态下,整个主存空间都是一个空闲分区,大小为 100K。 10.1 时刻,作业 A 进入输入井。由于需要 15K 主存,我们选择将其放入空闲分区的前端,剩余空间为 85K。 10.3 时刻,作业 B 进入输入井。由于需要 60K 主存,我们选择将其放入空闲分区的后端,剩余空间为 25K。 10.5 时刻,作业 C 进入输入井。由于需要 50K 主存,我们需要寻找一个空闲分区来存放它。此时,我们可以选择将作业 A 移动到空闲分区的后端,腾出一个大小为 50K 的空闲分区,将作业 C 放入其中。此时,剩余空间为 35K。 10.6 时刻,作业 D 进入输入井。由于需要 10K 主存,我们选择将其放入空闲分区的前端,剩余空间为 25K。 10.7 时刻,作业 E 进入输入井。由于需要 20K 主存,我们需要寻找一个空闲分区来存放它。此时,我们可以选择将作业 D 移动到空闲分区的后端,腾出一个大小为 10K 的空闲分区,将作业 E 放入其中。此时,剩余空间为 15K。 现在,所有作业都已经进入了主存。接下来,我们进行高级调度和低级调度。 首先,根据 SJF 算法进行高级调度。当前在主存中的作业按照需要计算时间从小到大排列: D (24 分钟) < E (12 分钟) < C (24 分钟) < A (42 分钟) < B (30 分钟) 接下来,根据 SJF 算法进行低级调度。先选择运行需要计算时间最小的作业 E,运行时间为 12 分钟,结束运行时间为 10.7 + 0.2 = 10.9 时刻。此时,空闲分区的情况如下: 前段空闲分区(10K)- D - 中段空闲分区(50K)- C - 后段空闲分区(15K) 接下来,选择运行需要计算时间最小的作业 D,运行时间为 24 分钟,结束运行时间为 10.9 + 0.4 = 11.3 时刻。此时,空闲分区的情况如下: 前段空闲分区(34K)- C - 后段空闲分区(15K) 接下来,选择运行需要计算时间最小的作业 C,运行时间为 24 分钟,结束运行时间为 11.3 + 0.48 = 11.78 时刻。此时,空闲分区的情况如下: 前段空闲分区(34K)- 空闲分区(50K)- 后段空闲分区(15K) 接下来,选择运行需要计算时间最小的作业 A,运行时间为 42 分钟,结束运行时间为 11.78 + 0.84 = 12.62 时刻。此时,空闲分区的情况如下: 前段空闲分区(34K)- 空闲分区(50K)- 后段空闲分区(43K) 最后,选择运行需要计算时间最小的作业 B,运行时间为 30 分钟,结束运行时间为 12.62 + 0.6 = 13.22 时刻。此时,空闲分区的情况如下: 前段空闲分区(34K)- 空闲分区(10K)- 后段空闲分区(43K) 至此,所有作业都已经运行完毕。计算各作业进入主存时间、开始运行时间、结束运行时间、周转时间(以分钟为单位),结果如下: 作业名 进入主存时间 开始运行时间 结束运行时间 周转时间 A 10.1 11.78 12.62 1.52 B 10.3 13.22 13.82 3.52 C 10.5 11.3 11.78 1.28 D 10.6 10.9 11.3 0.7 E 10.7 10.9 10.9 0.2
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值