Question

Project 2 - Flashdrive 1.0

I have provided you with a sample class named FlashDrive which has been diagrammed below and described in the online course content. For this unit, I'd like you to identify additional member variables (data) that would be appropriate for the class FlashDrive. I would also like you to identify additional methods (functions) that would be appropriate for the class FlashDrive. Submit a .h file for FlashDrive with the new possible methods and members you have identified commented and explained. YOU ARE NOT REQUIRED TO CODE UP ANYTHING MORE THAN THE .H FILE, BUT I MAY AWARD YOU EXTRA CREDIT IF YOU DO...

FlashDrive methods:

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( );

FlashDrive data members:

int my_StorageCapacity;
int my_StorageUsed;
bool my_IsPluggedIn;

Sample driver code

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

void main( )
{
  int i;
  cout << "Welcome to Howie's Flash USB Drive Store!"
       << endl;
  cout << "How much memory do you need? ";
  cin >> i;

  FlashDrive f(i, 0, false);
  cout << "Let's format the drive..." << endl;
  f.formatDrive();
  cout << "Let's plug in the drive..." << endl;
  f.plugIn();
  cout << "Let's write some data..." << endl;
  f.writeData( 10 );
  cout << "Let's unplug the drive..." << endl;
  f.pullOut();

  cout << "Enjoy your drive!!" << endl;
}

Answer 1

ANSWER :

/main.cpp

#include <iostream>

#include <string>

#include "FlashDrive.h"

using namespace std;

using namespace cs52;

int main()

{

cs52::FlashDrive drive1(10, 0, false);

cs52::FlashDrive drive2(20, 0, false);

drive1.plugIn();

std :: cout << "This should return as TRUE: " << drive1.isPluggedIn() << std::endl;

drive1.formatDrive();

drive1.writeData(5);

std :: cout << "This should return as 5: " << drive1.getUsed() << std::endl;

drive1.pullOut();

std :: cout << "This should return as FALSE: " << drive1.isPluggedIn() << std::endl << std::endl;

drive2.plugIn();

drive2.formatDrive();

drive2.writeData(1);

drive2.pullOut();

cs52::FlashDrive combined = drive1 + drive2;

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

cout << "its capacity is " << combined.getCapacity() << endl;

cout << "Is it plugged in by default? " << combined.isPluggedIn() << endl << endl;

cs52::FlashDrive other = combined - drive1;

cout << "other(diff)'s filled to " << other.getUsed() << endl;

cout << "its capacity is " << other.getCapacity() << endl;

cout << "Is it plugged in by default? " << other.isPluggedIn() << endl << endl;

if (combined > other) {

cout << "looks like combined is bigger than other..." << endl;

}

else {

cout << "this should not print" << endl;

cout << "looks like other is bigger..." << endl;

}

if (drive2 > other) {

cout << "looks like drive2 is bigger than other..." << endl;

}

else {

cout << "looks like other is bigger than drive 2..." << endl;

}

if (drive2 < drive1) {

cout << "looks like drive2 is smaller than drive1..." << endl;

}

else {

cout << "looks like drive1 is smaller than drive2..." << endl;

}

}//END OF MAIN

==============================================================================

//FlashDrive.cpp

#include <iostream>

#include <string>

#include "FlashDrive.h"

using namespace std;

using namespace cs52;

namespace cs52 {

//constructors:

//DEFAULT:

FlashDrive::FlashDrive() {

my_IsPluggedIn = 0;

my_StorageCapacity = 0;

my_StorageUsed = 0;

}

FlashDrive::FlashDrive(int capacity, int used, bool pluggedIn) {

bool okInput(1);

//potentially unwanted stuff:

if (capacity < 0) {

cout << "ERROR: Capacity can only be positive." << endl;

okInput = 0;

}

if (used < 0) {

cout << "ERROR: Used data can only be positive " << endl;

okInput = 0;

}

if (used > capacity) {

cout << "ERROR: The amount of used data cannot exceed the capacity." << endl;

okInput = 0;

}

if (okInput) {

my_IsPluggedIn = pluggedIn;

my_StorageCapacity = capacity;

my_StorageUsed = used;

}

else {

my_IsPluggedIn = 0;

my_StorageCapacity = 0;

my_StorageUsed = 0;

}

}

//***************************************************************************************

//PLUG IN/PULL OUT

void FlashDrive::plugIn() {

if (my_IsPluggedIn)

cout << "The FlashDrive is already plugged in! " << endl;

else

my_IsPluggedIn = 1;

}

void FlashDrive::pullOut() {

if (my_IsPluggedIn)

my_IsPluggedIn = 0;

else

cout << "The FlashDrive is already pulled out! " << endl;

}

void FlashDrive::writeData(int amount) {

if (my_IsPluggedIn) {

if ((amount + my_StorageUsed) > my_StorageCapacity)

cout << "ERROR: Adding desired data will exceed storage capacity. " << endl;

else

my_StorageUsed += amount;

}

else

cout << "The FlashDrive must be plugged in in order to write to it! " << endl;

}

void FlashDrive::eraseData(int amount) {

if (my_IsPluggedIn) {

if ((my_StorageUsed - amount) < 0)

cout << "ERROR: Deleting desired data results in negative storage. " << endl;

else

my_StorageUsed -= amount;

}

else

cout << "The FlashDrive must be plugged in in order to erase from it! " << endl;

}

//******************************************************************************************

//This deletes all data from the flashdrive.

void FlashDrive::formatDrive() {

my_StorageUsed = 0;

}

int FlashDrive::getCapacity() {

return(my_StorageCapacity);

}

/****************************************************************************************/

void FlashDrive::setCapacity(int amount) {

if (amount >= my_StorageUsed)

my_StorageCapacity = amount;

else

cout << "ERROR: The formatted storage capacity must exceed or equate to the storage used." << endl;

}

/*****************************************************************************************/

int FlashDrive::getUsed() {

return(my_StorageUsed);

}

/*******************************************************************************************/

void FlashDrive::setUsed(int amount) {

if (amount > my_StorageCapacity)

cout << "ERROR: The amount of used data cannot exceed the storage capacity." << endl;

else

my_StorageUsed = amount;

}

//this returns true if the flashdrive is plugged in.

bool FlashDrive::isPluggedIn() {

return(my_IsPluggedIn);

}

/**************************************************************************************************/

//This overloads the " + " operator. This intakes two flashdrives and returns a new instance spawned with

//combined capacities and combined storages, that is plugged in.

FlashDrive operator +(const FlashDrive& flash1, const FlashDrive& flash2) {

FlashDrive temp = FlashDrive((flash1.my_StorageCapacity + flash2.my_StorageCapacity), (flash1.my_StorageUsed + flash2.my_StorageUsed), 1);

return(temp);

}

FlashDrive operator -(const FlashDrive& flash1, const FlashDrive& flash2) {

bool okInput(1);

if ((flash1.my_StorageCapacity - flash2.my_StorageCapacity) < 0) {

cout << "ERROR: Capacity can only be positive." << endl;

okInput = 0;

}

if ((flash1.my_StorageUsed - flash2.my_StorageUsed) < 0) {

cout << "ERROR: Used data can only be positive " << endl;

okInput = 0;

}

// if used > capacity :

if ((flash1.my_StorageUsed - flash2.my_StorageUsed) > (flash1.my_StorageCapacity - flash2.my_StorageCapacity)) {

cout << "ERROR: The amount of used data cannot exceed the capacity." << endl;

okInput = 0;

}

//if none of the potential pitfalls occured, return the appropriate "differentiated" FlashDrive. Else, return an empty one.

if (okInput) {

FlashDrive temp = FlashDrive((flash1.my_StorageCapacity - flash2.my_StorageCapacity), (flash1.my_StorageUsed - flash2.my_StorageUsed), 1);

return(temp);

}

else

{

FlashDrive temp = FlashDrive();

return(temp);

}

}

bool operator >(const FlashDrive& flash1, const FlashDrive& flash2) {

if (flash1.my_StorageCapacity > flash2.my_StorageCapacity)

return(1);

else

return(0);

}

bool operator <(const FlashDrive& flash1, const FlashDrive& flash2) {

if (flash1.my_StorageCapacity < flash2.my_StorageCapacity)

return(1);

else

return(0);

}

} //end of NAMESPACE definition

================================================================================

//FlashDrive.h

#ifndef FLASHDRIVE

#define FLASHDRIVE

#include <iostream>

#include <string>

using namespace std;

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();

int getCapacity();

void setCapacity(int amount);

int getUsed();

void setUsed(int amount);

bool isPluggedIn();

//OVERLOADED OPERATORS:

friend FlashDrive operator +(const FlashDrive& flash1, const FlashDrive& flash2);

friend FlashDrive operator -(const FlashDrive& flash1, const FlashDrive& flash2);

friend bool operator >(const FlashDrive& flash1, const FlashDrive& flash2);

friend bool operator <(const FlashDrive& flash1, const FlashDrive& flash2);

private:

int my_StorageCapacity;

int my_StorageUsed;

bool my_IsPluggedIn;

}; //end of class declaration

} //end of namespace inclusion

#endif

==========================================================================

sample output :-

9 TDM-GCC 4.9.2 32-bi - X File Edit Search View Project Execute Tools AStyle Window Help 5. (globals) Project Classes C:\Program Files\Dev-Cpp\Project2.exe Project This should return as TRUE: 1 FlashD This should return as 5: 5 This should return as FALSE: 0 Flash main.d combined drive's filled to 6 its capacity is 30 Is it plugged in by default? 1 other(diff's filled to 1 its capacity is 20 Is it plugged in by default? 1 looks like combined is bigger than other.. looks like other is bigger than drive 2.. looks like drive1 is smaller than drive2... : endl; Process exited after 0.94223 seconds with return value o Press any key to continue

Hope it helps... please give an upvote. It's very important to me... thank you:)