Question

Please zoom in so the pictures become high resolution. I need three files, FlashDrive.cpp, FlashDrive.h and user_main.cpp. The programming language is C++. I will provide the Sample Test Driver Code as well as the codes given so far in text below.

The purpose of this assignment is to work with exceptions. As you may recall, I have provided you with a sample class named FlashDrive which has been diagrammed below. I'd like you to enhance this class so that invoking its methods or operators potentially throw exceptions, rather than just printing error messages to cout. Currently, our favorite exception class is std::logic_error. You can create a logic_error by passing a string value to its constructor. You need to #include <stdexcept> to begin working with logic_error. For this assignment, you need to throw exceptions when: • more data has been put onto the drive than it can safely hold (due to writeData ) • a negative number is potentially used as a my_StorageUsed value (due to operator - or bad values being sent to the constructor call) • a negative number is potentially used as a my_StorageCapacity value (due to operator - or bad values being sent to the constructor call) So carefully wind your way through all the operators and methods of the class ensuring that logic_error gets thrown in each of these circumstances. I'd also like you to get operator << and operator >> working for the class Flash Drive: • The << operator should output: Capacity: C, storage used: s where c is the flash drive's capacity and s is the storage used. • The >> should read in values to set the capacity and storage. The capacity should be entered first, followed by the storage used. See the driver below for how your program will be tested FlashDrive 3.0 namespace cs52{ class FlashDrive { // constructors FlashDrive(); FlashDrive( int capacity, int used, bool pluggedIn); void plugin(); void pullout(); void writeData( int amount ); void eraseData( int amount ); void formatDrive(); // basic accessors and modifiers int getCapacity(); void setCapacity( int amount ); int getUsed); void setUsed( int amount ); bool isPluggedIn(); // overloaded +, -, >, <, >>, << friend FlashDrive operator+(const FlashDrive& fdl, const FlashDrive& fd2); friend FlashDrive operator-(const FlashDrive& fdi, const FlashDrive& fd2); friend bool operator>(const FlashDrive& fdi, const FlashDrive& fd2); friend bool operator<(const FlashDrive& fdl, const FlashDrive& fd2); friend ostream &operator<<( ostream &stream, const FlashDrive &fd ); friend istream &operator>>( istream &stream, FlashDrive &fd); int my_StorageCapacity; int my_StorageUsed;

Sample Testing Driver Code:

cs52::FlashDrive empty;
cs52::FlashDrive drive1(10, 0, false);
cs52::FlashDrive drive2(20, 0, false);

drive1.plugIn();
drive1.formatDrive();
drive1.writeData(5);
drive1.pullOut();

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

cs52::FlashDrive combined = drive1 + drive2;
// std::cout << "this drive's filled to " << combined.getUsed( ) << std::endl;

cs52::FlashDrive other = combined - drive1;
// std::cout << "the other drives' filled to " << other.getUsed( ) << std::endl;

// let's throw some exceptions...
try
{
  cs52::FlashDrive f(-1, 0, false);
  std::cout << "Negative capacity initialization test failed; no exception thrown" << std::endl;
}
catch (const char* msg)
{
  std::cout << "Negative capacity initialization test failed; C-string thrown" << std::endl;
  std::cout << msg << "\n";
}
catch (std::logic_error e)
{
  std::cout << "Negative capacity initialization test passed; std::logic_error thrown" << std::endl;
  std::cout << e.what() << std::endl;
}
catch (string e)
{
  std::cout << "Negative capacity initialization test failed; string thrown" << std::endl;
  std::cout << e << std::endl;
}
try
{
  cs52::FlashDrive f(10, -1, false);
  std::cout << "Negative used storage initialization test failed; no exception thrown" << std::endl;
}
catch (const char* msg)
{
  std::cout << "Negative used storage initialization test failed; C-string thrown" << std::endl;
  std::cout << msg << "\n";
}
catch (std::logic_error e)
{
  std::cout << "Negative used storage initialization test passed; std::logic_error thrown" << std::endl;
  std::cout << e.what() << std::endl;
}
catch (string e)
{
  std::cout << "Negative used storage initialization test failed; string thrown" << std::endl;
  std::cout << e << std::endl;
}

try
{
  cs52::FlashDrive f(1, 10, false);
  std::cout << "Capacity < Used storage initialization test failed; no exception thrown" << std::endl;
}
catch (const char* msg)
{
  std::cout << "Capacity < Used storage initialization test failed; C-string thrown" << std::endl;
  std::cout << msg << "\n";
}
catch (std::logic_error e)
{
  std::cout << "Capacity < Used storage initialization test passed; std::logic_error thrown" << std::endl;
  std::cout << e.what() << std::endl;
}
catch (string e)
{
  std::cout << "Capacity < Used storage initialization test failed; string thrown" << std::endl;
  std::cout << e << std::endl;
}

try
{
  drive2.writeData(10000);
  std::cout << "Writing beyond capacity test failed" << std::endl;
}
catch (const char* msg)
{
  std::cout << "Writing beyond capacity test failed; C-string thrown" << std::endl;
  std::cout << msg << "\n";
}
catch (std::logic_error e)
{
  std::cout << "Writing beyond capacity test passed; std::logic_error thrown" << std::endl;
  std::cout << e.what() << std::endl;
}
catch (string e)
{
  std::cout << "Writing beyond capacity test failed; string thrown" << std::endl;
  std::cout << e << std::endl;
}

try
{
  empty = empty - combined;
  std::cout << "Subtracting more data than capacity allows test failed" << std::endl;
}
catch (const char* msg)
{
  std::cout << "Subtracting more data than capacity allows test failed; C-string thrown" << std::endl;
  std::cout << msg << "\n";
}
catch (std::logic_error e)
{
  std::cout << "Subtracting more data than capacity allows test passed; std::logic_error thrown" << std::endl;
  std::cout << e.what() << std::endl;
}
catch (string e)
{
  std::cout << "Subtracting more data than capacity allows test failed; string thrown" << std::endl;
  std::cout << e << std::endl;
}

// read in a FlashDrive...
// the class designer for FlashDrive (that's you!)
// gets to decide which fields matter and should be read in
std::stringstream ss;
ss.str("6 4");
cs52::FlashDrive sample;
ss >> sample;
if (sample.getCapacity() == 6)
{
  std::cout << "instream operator capacity set correctly" << std::endl;
}
else
{
  std::cout << "instream operator capacity set incorrectly" << std::endl;
}
if (sample.getUsed() == 4)
{
  std::cout << "instream operator storage used set correctly" << std::endl;
}
else
{
  std::cout << "instream operator storage used set incorrectly" << std::endl;
}

// print out a FlashDrive...
// the class designer for FlashDrive (that's you!)
// gets to decide which fields matter and should be printed
std::cout << sample << std::endl;

FlashDrive.cpp:

#include
#include
#include "FlashDrive.h"
using namespace std;

namespace cs52
{
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);
}
  
void FlashDrive::setCapacity(int amount)
{
my_StorageCapacity = amount;
}
  
int FlashDrive::getUsed()
{
return (my_StorageUsed);
}
  
void FlashDrive::setUsed(int amount)
{
my_StorageUsed = amount;
}
  
bool FlashDrive::isPluggedIn()
{
return (my_IsPluggedIn);
}
  
FlashDrive operator+(const FlashDrive& f1, const FlashDrive& f2)
{
FlashDrive f3;
  
f3.my_StorageUsed = f1.my_StorageUsed + f2.my_StorageUsed;
  
if (f1.my_StorageCapacity > f2.my_StorageCapacity)
{
f3.my_StorageCapacity = f1.my_StorageCapacity;
}
else
{
f3.my_StorageCapacity = f2.my_StorageCapacity;
}
  
return f3;
}
  
bool operator<(const FlashDrive& f1, const FlashDrive& f2)
{
bool storageUsed = false;
if (f1.my_StorageUsed < f2.my_StorageUsed)
{
storageUsed = true;
}
return storageUsed;
}
  
bool operator>(const FlashDrive& f1, const FlashDrive& f2)
{
bool storageUsed = false;
if (f1.my_StorageUsed > f2.my_StorageUsed)
{
storageUsed = true;
}
return storageUsed;
}
  
FlashDrive operator-(const FlashDrive& f1, const FlashDrive& f2)
{
int error;
FlashDrive f3;
  
if (f1.my_StorageCapacity > f2.my_StorageCapacity)
{
f3.my_StorageCapacity = f1.my_StorageCapacity;
}
else
{
f3.my_StorageCapacity = f2.my_StorageCapacity;
}
  
f3.my_StorageUsed = f1.my_StorageUsed - f2.my_StorageUsed;
  
return f3;
}
  
ostream& operator<<(ostream& out, const FlashDrive& f1)
{
return out;
}
  
std::istream& operator>>(std::istream& in, FlashDrive& f1)
{
return in;
}

} // namespace cs52

FlashDrive.h:

#ifndef FLASHDRIVE_H
#define FLASHDRIVE_H
#include

namespace cs52 {
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();
void setCapacity(int amount);
int getUsed();
void setUsed(int amount);
bool isPluggedIn();
  
friend FlashDrive operator+(const FlashDrive& f1, const FlashDrive& f2);
friend bool operator<(const FlashDrive& f1, const FlashDrive& f2);
friend bool operator>(const FlashDrive& f1, const FlashDrive& f2);
friend FlashDrive operator-(const FlashDrive& f1, const FlashDrive& f2);
friend std::ostream& operator<<(std::ostream& out, const FlashDrive& f1);
friend std::istream& operator>>(std::istream& in, FlashDrive& f1);
  
private:
int my_StorageCapacity; // in kilobytes
int my_StorageUsed; // in kilobytes
bool my_IsPluggedIn; // am I attached to a computer?
};
}

#endif

user_main.cpp:

/* Main function of the C++ program. */

#include

using namespace std;

/*
* This is your main function - my hidden main() will execute this function
* when you "Run", but execute the tests when you hit "Submit"
*/
int user_main() {
// YOUR IMPLEMENTATION GOES HERE
return 0;
}

Answer 1

// FlashDrive.h
#ifndef FLASHDRIVE_H
#define FLASHDRIVE_H

#include <iostream>

namespace cs52{

class FlashDrive{
public:
// constructors
FlashDrive();
FlashDrive(int capacity, int used, bool pluggedIn);

void plugIn();
void pullOut();
void writeData(int amount);
void eraseData(int amount);
void formatDrive();

// basic accessors and modifiers
int getCapacity();
void setCapacity(int amount);
int getUsed();
void setUsed(int amount);
bool isPluggedIn();

// overloaded +, -, >, <, >>, <<
friend FlashDrive operator+(const FlashDrive& f1, const FlashDrive& f2);
friend FlashDrive operator-(const FlashDrive& f1, const FlashDrive& f2);
friend bool operator>(const FlashDrive& f1, const FlashDrive& f2);
friend bool operator<(const FlashDrive& f1, const FlashDrive& f2);
friend std::ostream &operator<<( std::ostream &stream, const FlashDrive &f1 );
friend std::istream &operator>>( std::istream &stream, FlashDrive &f1 );

private:

int my_StorageCapacity; // in kilobytes
int my_StorageUsed; // in kilobytes
bool my_IsPluggedIn; // am I attached to a computer?

};
}

#endif

//end of FlashDrive.h

// FlashDrive.cpp
#include "flashdrive.h"
#include <stdexcept>
using namespace std;

namespace cs52{

// default constructor to initialize capacity, used to 0 and pluggedIn to false
FlashDrive::FlashDrive()
{
       my_StorageCapacity = 0;
       my_StorageUsed = 0;
       my_IsPluggedIn = false;
   }

// parameterized constructor to initialize capacity, used and pluggedIn to passed values if valid
FlashDrive::FlashDrive(int capacity, int used, bool pluggedIn)
{
       my_IsPluggedIn = pluggedIn;
// check that capacity or used is not negative, if it is throw exception
if(capacity < 0 || used < 0)
{
throw logic_error("negative initialization of capacity and/or used");
}

// if capacity < used, throw exception
if(capacity < used)
throw logic_error("Capacity of Flashdrive must be greater or equal to used");

// if all valid, set the capacity and used
my_StorageCapacity = capacity;
my_StorageUsed = used;

}

// set pluggedIn to true
void FlashDrive::plugIn()
{
my_IsPluggedIn = true;
}

// set pluggedIn to false
void FlashDrive:: pullOut()
{
my_IsPluggedIn = false;
}

// function to write amount of data to FlashDrive
void FlashDrive:: writeData(int amount)
{
// validate amount is not negative and neither adding this amount of data will make used > capacity
// if invalid, throw exception
if((amount < 0) || ((my_StorageUsed+amount) > my_StorageCapacity))
throw logic_error("Invalid amount to write to Flashdrive");
my_StorageUsed += amount; // if valid, add amount to used
}

// function to erase amount of data from FlashDrive
void FlashDrive::eraseData(int amount)
{
// validate amount is not negative and neither amount > used data in flashdrive
// if invalid, throw exception
if((amount < 0) || (amount > my_StorageUsed))
throw logic_error("Invalid amount to erase from Flashdrive");
my_StorageUsed -= amount; // if valid, subtract amount from used
}

// function to format the drive i.e set used to 0
void FlashDrive:: formatDrive()
{
my_StorageUsed = 0;
}

// function to return capacity
int FlashDrive:: getCapacity()
{
return my_StorageCapacity;
}

// function to set capacity
void FlashDrive:: setCapacity(int amount)
{
// validate capacity to set is not negative and neither it is greater than the data used in the flashdrive
// if invalid, throw exception
if(amount < 0 || amount < my_StorageUsed)
throw logic_error("Invalid capacity initialization");
my_StorageCapacity = amount; // if valid, update capacity
}

// function to return used storage
int FlashDrive::getUsed()
{
return my_StorageUsed;
}

// function to set used storage
void FlashDrive:: setUsed(int amount)
{
// validate used to set is not negative and neither it is greater than the capacity used in the flashdrive
// if invalid, throw exception
if(amount < 0 || amount > my_StorageCapacity)
throw logic_error("Invalid used initialization");
my_StorageUsed = amount; // if valid, update used
}

// function to return if the flashdrive is plugged or not
bool FlashDrive:: isPluggedIn()
{
return(my_IsPluggedIn == true);
}

// function to add used and set capacity as larger of the two to return a new FlashDrive
FlashDrive operator+(const FlashDrive& f1, const FlashDrive& f2)
{

FlashDrive f3;
f3.my_StorageUsed = f1.my_StorageUsed + f2.my_StorageUsed;
if (f1.my_StorageCapacity > f2.my_StorageCapacity)
{
f3.my_StorageCapacity = f1.my_StorageCapacity;
}
else
{
f3.my_StorageCapacity = f2.my_StorageCapacity;
}

return f3;
}

// function to subtract used of f2 to from f1 and set capacity to be the greater of the two
// will throw exception if f1's used is less than f2's used
FlashDrive operator-(const FlashDrive& f1, const FlashDrive& f2)
{
if(f1.my_StorageUsed < f2.my_StorageUsed)
throw logic_error("Storage used on first flashdrive must be greater than or equal to storage used in second flashdrive");

FlashDrive f3;
if (f1.my_StorageCapacity > f2.my_StorageCapacity)
{
f3.my_StorageCapacity = f1.my_StorageCapacity;
}
else
{
f3.my_StorageCapacity = f2.my_StorageCapacity;
}

return f3;
}

// function that returns true if used of f1 > used of f2. else false
bool operator>(const FlashDrive& f1, const FlashDrive& f2)
{
return f1.my_StorageUsed > f2.my_StorageUsed;
}

// function that returns true if used of f1 < used of f2, else false
bool operator<(const FlashDrive& f1, const FlashDrive& f2)
{
return f1.my_StorageUsed < f2.my_StorageUsed;
}

// function to output capacity and used to output stream
ostream &operator<<( ostream &stream, const FlashDrive &f1 )
{
stream << "Capacity: "<<f1.my_StorageCapacity<<", storage used: "<<f1.my_StorageUsed;
return stream;
}

// function to read capacity and used from input stream
istream &operator>>( istream &stream, FlashDrive &f1 )
{
stream>>f1.my_StorageCapacity>>f1.my_StorageUsed;
return stream;
}

}
//end of FlashDrive.cpp

// user_main.cpp : C++ driver program to test FlashDrive class
#include <iostream>
#include "flashdrive.h"
#include <stdexcept>
#include <sstream>

using namespace std;

int main()
{
cs52::FlashDrive empty;
cs52::FlashDrive drive1(10, 0, false);
cs52::FlashDrive drive2(20, 0, false);

drive1.plugIn();
drive1.formatDrive();
drive1.writeData(5);
drive1.pullOut();

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

cs52::FlashDrive combined = drive1 + drive2;
// std::cout << "this drive's filled to " << combined.getUsed( ) << std::endl;

cs52::FlashDrive other = combined - drive1;
// std::cout << "the other drives' filled to " << other.getUsed( ) << std::endl;

// let's throw some exceptions...
try
{
cs52::FlashDrive f(-1, 0, false);
std::cout << "Negative capacity initialization test failed; no exception thrown" << std::endl;
}
catch (const char* msg)
{
std::cout << "Negative capacity initialization test failed; C-string thrown" << std::endl;
std::cout << msg << "\n";
}
catch (std::logic_error e)
{
std::cout << "Negative capacity initialization test passed; std::logic_error thrown" << std::endl;
std::cout << e.what() << std::endl;
}
catch (string e)
{
std::cout << "Negative capacity initialization test failed; string thrown" << std::endl;
std::cout << e << std::endl;
}

try
{
cs52::FlashDrive f(10, -1, false);
std::cout << "Negative used storage initialization test failed; no exception thrown" << std::endl;
}
catch (const char* msg)
{
std::cout << "Negative used storage initialization test failed; C-string thrown" << std::endl;
std::cout << msg << "\n";
}
catch (std::logic_error e)
{
std::cout << "Negative used storage initialization test passed; std::logic_error thrown" << std::endl;
std::cout << e.what() << std::endl;
}
catch (string e)
{
std::cout << "Negative used storage initialization test failed; string thrown" << std::endl;
std::cout << e << std::endl;
}

try
{
cs52::FlashDrive f(1, 10, false);
std::cout << "Capacity < Used storage initialization test failed; no exception thrown" << std::endl;
}
catch (const char* msg)
{
std::cout << "Capacity < Used storage initialization test failed; C-string thrown" << std::endl;
std::cout << msg << "\n";
}
catch (std::logic_error e)
{
std::cout << "Capacity < Used storage initialization test passed; std::logic_error thrown" << std::endl;
std::cout << e.what() << std::endl;
}
catch (string e)
{
std::cout << "Capacity < Used storage initialization test failed; string thrown" << std::endl;
std::cout << e << std::endl;
}

try
{
drive2.writeData(10000);
std::cout << "Writing beyond capacity test failed" << std::endl;
}
catch (const char* msg)
{
std::cout << "Writing beyond capacity test failed; C-string thrown" << std::endl;
std::cout << msg << "\n";
}
catch (std::logic_error e)
{
std::cout << "Writing beyond capacity test passed; std::logic_error thrown" << std::endl;
std::cout << e.what() << std::endl;
}
catch (string e)
{
std::cout << "Writing beyond capacity test failed; string thrown" << std::endl;
std::cout << e << std::endl;
}

try
{
empty = empty - combined;
std::cout << "Subtracting more data than capacity allows test failed" << std::endl;
}
catch (const char* msg)
{
std::cout << "Subtracting more data than capacity allows test failed; C-string thrown" << std::endl;
std::cout << msg << "\n";
}
catch (std::logic_error e)
{
std::cout << "Subtracting more data than capacity allows test passed; std::logic_error thrown" << std::endl;
std::cout << e.what() << std::endl;
}
catch (string e)
{
std::cout << "Subtracting more data than capacity allows test failed; string thrown" << std::endl;
std::cout << e << std::endl;
}

// read in a FlashDrive...
// the class designer for FlashDrive (that's you!)
// gets to decide which fields matter and should be read in
std::stringstream ss;
ss.str("6 4");
cs52::FlashDrive sample;
ss >> sample;
if (sample.getCapacity() == 6)
{
std::cout << "instream operator capacity set correctly" << std::endl;
}
else
{
std::cout << "instream operator capacity set incorrectly" << std::endl;
}
if (sample.getUsed() == 4)
{
std::cout << "instream operator storage used set correctly" << std::endl;
}
else
{
std::cout << "instream operator storage used set incorrectly" << std::endl;
}

// print out a FlashDrive...
// the class designer for FlashDrive (that's you!)
// gets to decide which fields matter and should be printed
std::cout << sample << std::endl;
return 0;
}

//end of user_main.cpp

Output:

Negative capacity initialization test passed; std::logic_error thrown negative initialization of capacity and/or used Negative used storage initialization test passed; std::logic_error thrown negative initialization of capacity and/or used Capacity < Used storage initialization test passed; std:: logic_error thrown Capacity of Flashdrive must be greater or equal to used Writing beyond capacity test passed; std::logic_error thrown Invalid amount to write to Flashdrive Subtracting more data than capacity allows test passed; std:: logic_error thrown Storage used on first flashdrive must be greater than or equal to storage used in second flashdrive instream operator capacity set correctly instream operator storage used set correctly Capacity: 6, storage used: 4