Operator Overload With Pointers

Question

As a part of our exam review package for next week, we are asked to understand pointers in overloaded operators-- something I am finding it very difficult to get and the instructor is refusing to give us any example, and asking his for independent study.

Apparently we will be having one of these problems on the final and I want to be sure I properly understand this practice exercise.

This practice concerns the issue of operator overloading. And we are asked to implement << and >>. And we are to :

Using the FlashDrive class you have been working with, upgrade the class so that operator << and operator >> work well with pointers (that is, FlashDrive *). Youll need to re-overload these operators, adding the function:

friend std::ostream& operator <<( std::ostream& outs, const FlashDrive * drive );

friend std::istream& operator >>( std::istream& ins, FlashDrive * & drive );

HINT: Be very careful to test for NULL

NOTE: These ideas will be a part on next weeks assignment!

The code I am working with is

FlashDrive.h

#ifndef FLASHDRIVE_H
#define FLASHDRIVE_H

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( );
private:
int my_StorageCapacity; 
int my_StorageUsed; 
bool my_IsPluggedIn;

}





#endif

FlashDriver.cpp --- Driver Class

#include <iostream>
#include "FlashDrive.h"
using namespace cs52;

void 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( 1 );
drive2.pullOut( );

// read in a FlashDrive... 
// the class designer for FlashDrive (that's you!)
// gets to decide which fields matter and should be read in
cs52::FlashDrive sample;
cin >> sample;

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

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

cs52::FlashDrive other = combined – drive1;
cout << "the other cup's filled to " << other.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 smaller..." << endl;
}
else {
  cout << "looks like drive1 is smaller..." << endl;
}

// let's throw some exceptions...

try {
  empty = empty – combined;
  cout << "something not right here..." << endl;
} catch( std::logic_error ) {
// an exception should get thrown... 
// so the lines of code here should
// be run, not the cout statement...
}

try {
  drive2.writeData( 10000 );
  cout << "something not right here..." << endl;
} catch( std::logic_error ) {
// an exception should get thrown... 
// so the lines of code here should
// be run, not the cout statement...
}

try {
  cs52::FlashDrive f( -1, -1, false );
  cout << "something not right here..." << endl;
} catch( std::logic_error ) {
// an exception should get thrown... 
// so the lines of code here should
// be run, not the cout statement...
}

// work with the new stuff added for Unit 16!!!

cs52::FlashDrive * drive3 = NULL;
// careful...
cout << drive3 << endl;

drive3 = &drive2;
cout << drive3 << endl;

drive3 = new FlashDrive();
cin  >> drive3;
cout << drive3 << endl;

delete( drive3 );

}

I would like to see what a working implementation class would look like so I can reverse engineer that and use that as a study source. I am finding getting some of these pointers to work very challenging

The implementation class I have already coded is below

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

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

EDIT::::::

I have updated the .h and .cpp but I am still unable to properly add the << and >> operators :-( Any ideas??

.h

 #ifndef FLASHDRIVE_H
#define FLASHDRIVE_H
namespace cs52
{
class FlashDrive {

friend FlashDrive operator+ (FlashDrive used1 , FlashDrive used2);
friend FlashDrive operator- (FlashDrive used3, FlashDrive used4 );

public:
    friend std::ostream& operator <<( std::ostream& outs, const FlashDrive * drive );
    friend std::istream& operator >>( std::istream& ins, FlashDrive * & drive );
    FlashDrive& FlashDrive::operator=(int);
    FlashDrive::FlashDrive(int);
    FlashDrive(const std::string &name): name_(name){
    }
    FlashDrive& operator = (const FlashDrive& usedtotal){
        my_StorageUsed= usedtotal.my_StorageUsed;
        return *this;
}
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( );
private:
int my_StorageCapacity; 
std::string   name_;
int my_StorageUsed; 
bool my_IsPluggedIn;

    }extern drive1,drive2;



inline FlashDrive operator+ (FlashDrive used1, FlashDrive used2 ) {

    FlashDrive plus;
    plus.my_StorageUsed = (used1.getUsed()+ used2.getUsed());
    return plus;
}

inline bool operator< (FlashDrive &lhs,FlashDrive &rhs ) {
   return ( lhs.getUsed() < rhs.getUsed() );
}

inline bool operator> (FlashDrive &lhs,FlashDrive &rhs ) {
   return ( operator <( rhs, lhs ) );
}

inline FlashDrive operator - (FlashDrive used3, FlashDrive used4 ){
    FlashDrive minus;
    minus.my_StorageUsed = (used3.getUsed()- used4.getUsed());
    return minus;

    }


#endif

.cpp

    #include <cstdlib>
#include <iostream>
#include "FlashDrive.h"
using namespace cs52;
using namespace std;

std::ostream& operator <<(std::ostream& outs, const FlashDrive * drive )
{
   outs << drive->name_;
   return outs;
}

std::istream& operator >>( std::istream& ins, FlashDrive * & drive )
{
    ins >> drive->name_;
    return ins;
}

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

@chris He gives this all the time in his lectures, so-- in some ways, yes I Guess I was... :-/ I appreciate you bringing this up, I don't want to form bad habits now... — rezivor
And your istructor is asking you to test for "NULL" in C++? — bash.d
I can't for the life of me figure out how inputting or outputting a pointer to your class is useful in any way. — chris

Xaqq Xaqq · Accepted Answer · 2013-08-05T08:31:31

I would like to see what a working implementation class would look like

Here you go:

#include <iostream>

class Llama
{
private:
  std::string   name_;

public:
  Llama(const std::string &name): name_(name)
  {}

  friend std::ostream &operator<<(std::ostream &o, const Llama *);
};

std::ostream &operator<<(std::ostream &o, const Llama *llama)
{
  o << llama->name_;
  return o; /* this is important, because it allows chaining */
}


int     main(int, char **)
{
  Llama *llama = new Llama("Meh");

  std::cout << llama << " is the name of my llama" << std::endl;
  return (0);
}

What I meant about "chaining":

std::cout << llama will be executed first. This will returns an std::ostream reference: in this case, this reference is std::cout itself.
Now, we can "replace" std::cout << llama by std::cout, because of 1.
std::cout << " is the ..." will be executed. Then std::cout << std::endl.

This is why returning the reference to the std::ostream is important.

Operator Overload With Pointers

1 Answers