Question

I have provided you with a sample class named FlashDrive which has been diagrammed below. Using the FlashDrive class provided earlier, upgrade the class so that it supports various operators. Make operator+ combine together the contents of two FlashDrive, as long as the contents does not exceed the size. Make operator- subtract one FlashDrive contents from another, as long as the size or contents don't go negative. Support the >> and << operators to allow instances to be read from cin or written to cout. Make the boolean operators <, >, <= and >= test FlashDrive's contents. Make the boolean operator == and != test all of the data members of a TrashCan for an exact match.

Sample Driver Code ainclude kio stream #include FlashDrive. h using namespace std; void main FlashDrive drive1 10, 0, false FlashDrive drive20 20, e, false drive plugIn FlashDrive drivel formatDrive drivel writeData 5); FlashDrive FlashDrive( int capacity, int used, bool pluggedln drivel pullout drive 2. plugin void plug In(); drive2.formatDrive void pullout drive2.write Data 1); void write Data( int amount); drive 2.pullout void erase Data( int amount): FlashDrive combined drivel drive2; void formatDrive(); this drive's filled to combined. getused cout int get Capacity(): endl void setCapacity int amount). FlashDrive other int get Used(): cout the other drive's filled to other getused void set Used( int amount endl if (combined other) int my StorageCapacity; cout "looks like combined is bigger endl; int my StorageUsed: bool my lsPluggedIn else cout "looks like other is bigger endl if (drive2 other f looks like drive2 is bigger endl cout else looks like other is bigger endl cout if (drive 2 drive1 cout "looks like drive2 is smaller endl else cout "looks like drive1 is smaller endl;

Answer 1

//FlashDrive header file declaration
//FlashDrive.h
#ifndef FLASDRIVE_H
#define FLASDRIVE_H
#include<iostream>
using namespace std;
class FlashDrive
{
public:
   FlashDrive();
   FlashDrive(int capacity, int used, bool pluggedIn);

   void plugIn();
   void pullOut();

   void writeData(int amount);
   void eraseData(int amount);

   void formatDrive();
   int getCapacity();

   int getUsed();
   void setUsed(int amount);

   bool isPluggedIn();

   //declaratio of overload +,-
   friend FlashDrive operator+(FlashDrive &f1,FlashDrive &f2);
   friend FlashDrive operator-(FlashDrive &f1,FlashDrive &f2);

   //declaratio of overload <,<=
   friend bool operator<(FlashDrive &f1,FlashDrive &f2);
   friend bool operator<=(FlashDrive &f1,FlashDrive &f2);

   //declaratio of overload >,>=
   friend bool operator>(FlashDrive &f1,FlashDrive &f2);
   friend bool operator>=(FlashDrive &f1,FlashDrive &f2);

   //declaratio of overload ==, !=
   friend bool operator==(FlashDrive &f1,FlashDrive &f2);
   friend bool operator!=(FlashDrive &f1,FlashDrive &f2);

   //declaratio of overload <<,>>
   friend ostream& operator<<(ostream&out, FlashDrive &f);
   friend istream& operator>>(istream&out, FlashDrive &f);

private:
   int my_StorageCapacity;
   int my_StorageUsed;
   bool my_IsPluggedIn;
};

#endif FLASDRIVE_H

--------------------------------------------------------------------------------------------------------

//implemenation of FlashDrive.cpp
//FlashDrive.cpp
#include "FlashDrive.h"
FlashDrive::FlashDrive()
{
   my_StorageCapacity=0;
   my_StorageUsed=0;
   my_IsPluggedIn=false;
}
FlashDrive::FlashDrive(int capacity, int used, bool pluggedIn)
{
   my_StorageCapacity=capacity;
   my_StorageUsed=used;
   my_IsPluggedIn=pluggedIn;
}

void FlashDrive::plugIn()
{
   my_IsPluggedIn=true;
}
void FlashDrive::pullOut()
{
   my_IsPluggedIn=false;
}

void FlashDrive::writeData(int amount)
{
   my_StorageUsed+=amount;
}
void FlashDrive::eraseData(int amount)
{
   my_StorageUsed-=amount;
}

void FlashDrive::formatDrive()
{
   my_StorageUsed=0;
}
int FlashDrive::getCapacity()
{
   return my_StorageCapacity;
}

int FlashDrive::getUsed()
{
   return my_StorageUsed;
}
void FlashDrive::setUsed(int amount)
{
   this->my_StorageUsed=amount;
}

bool FlashDrive::isPluggedIn()
{
   return my_IsPluggedIn;
}

FlashDrive operator+(FlashDrive &f1,FlashDrive &f2)
{
   FlashDrive combined;

   combined.my_StorageCapacity=f1.getCapacity()+f2.getCapacity();
   combined.my_StorageUsed=f1.getUsed()+f2.getUsed();

   return combined;
}
FlashDrive operator-(FlashDrive &f1,FlashDrive &f2)
{
   FlashDrive combined;

   combined.my_StorageCapacity=f1.getCapacity()-f2.getCapacity();
   combined.my_StorageUsed=f1.getUsed()-f2.getUsed();

   return combined;
}

bool operator<(FlashDrive &f1,FlashDrive &f2)
{
   return f1.getCapacity() < f2.getCapacity()
       && f1.getUsed() < f2.getUsed();
}
bool operator>(FlashDrive &f1,FlashDrive &f2)
{
   return f1.getCapacity() > f2.getCapacity()
       && f1.getUsed() > f2.getUsed();
}

bool operator<=(FlashDrive &f1,FlashDrive &f2)
{
   return f1.getCapacity() <= f2.getCapacity()
       && f1.getUsed() <= f2.getUsed();
}
bool operator>=(FlashDrive &f1,FlashDrive &f2)
{
   return f1.getCapacity() >= f2.getCapacity()
       && f1.getUsed() >= f2.getUsed();
}

bool operator==(FlashDrive &f1,FlashDrive &f2)
{
   return f1.getCapacity() == f2.getCapacity()
       && f1.getUsed() == f2.getUsed()
       && f1.isPluggedIn() ==f2.isPluggedIn();
}
bool operator!=(FlashDrive &f1,FlashDrive &f2)
{
   return f1.getCapacity() != f2.getCapacity()
       && f1.getUsed() != f2.getUsed()
       && f1.isPluggedIn() !=f2.isPluggedIn();
}
//overloaiding << operator
ostream & operator << (ostream &out, FlashDrive &f)
{
   out << "Capacity : "<<f.my_StorageCapacity
   << "Used : " << f.my_StorageUsed
   << "Plugged In : " << f.my_IsPluggedIn <<endl;

    return out;
}
//overloaiding >> operator
istream & operator >> (istream &in, FlashDrive &f)
{
    cout << "Enter capacity";
   in >> f.my_StorageCapacity;
    cout << "Enter used used ";
   in >> f.my_StorageUsed;

    return in;
}

--------------------------------------------------------------------------------------------------------

//Test cpp file for FlashDrive class
//Main.cpp
#include<iostream>
//include header file
#include "FlashDrive.h"
using namespace std;
//main method
int main()
{

   //Create an object of FlashDrive
   FlashDrive drive1(10,0,false);
   FlashDrive drive2(20,0,false);

   //calling methods
   drive1.plugIn();
   drive1.formatDrive();
   drive1.writeData(5);
   drive1.pullOut();

   drive2.plugIn();
   drive2.formatDrive();
   drive2.writeData(1);
   drive2.pullOut();

   FlashDrive combined
       =drive1+drive2;

   cout<<"this drive's filled to "
       <<combined.getUsed()<<endl;

   FlashDrive other
       =combined-drive1;

   cout<<"this other drive's filled to "
       <<combined.getUsed()<<endl;

   if(combined>other)
   {
       cout<<"looks like combined is bigger..."          
           <<endl;
   }
   else{
       cout<<"looks like other is bigger..."          
           <<endl;
   }

   if(drive2>other)
   {
       cout<<"looks like drive2 is bigger..."          
           <<endl;
   }
   else{
       cout<<"looks like other is bigger..."          
           <<endl;
   }

       if(drive2>drive1)
   {
       cout<<"looks like drive2 is bigger..."          
           <<endl;
   }
   else{
       cout<<"looks like drive1 is bigger..."          
           <<endl;
   }

   system("pause");
   return 0;
}

--------------------------------------------------------------------------------------------------------

Sampel result :