HI, In my code, when I do this Counter c2, Counter c3. c3=c2++ it works fine and does what its supposed to do, but when i do ModCounter c5, ModCounter c6, c6=c5++ it doesnt do it. The same stand for pre and post increment and decrement....how do i solve this?? At the end I have added the the code in a zip file
main.cpp
Code:
#include "Counter.h"
#include "ModCounter.h"
#include <iostream>
using namespace std;
void print(const Counter& ctr)
{
cout << ctr.getCounterValue() << endl;
}
void playWithCounter(Counter& ctr)
{
ctr++;
print (ctr);
ctr++;
print (ctr);
ctr++;
print (ctr);
ctr++;
print (ctr);
ctr--;
print (ctr);
ctr--;
print (ctr);
ctr--;
print (ctr);
ctr.reset();
print (ctr);
ctr--;
print (ctr);
}
void main()
{
cout << "Working with Counter" << endl;
Counter ctr;
playWithCounter (ctr);
cout << "Working with ModCounter" << endl;
ModCounter mctr2(2);
playWithCounter (mctr2);
cout << "Working with ModCounter" << endl;
ModCounter mctr3(3);
playWithCounter (mctr3);
try
{
Counter ctr2;
if (ctr == ctr2)
cout << "Same" << endl;
else
cout << "Different" << endl;
ModCounter mc2a(2);
ModCounter mc2b(2);
if (mc2a == mc2b)
cout << "Same" << endl;
else
cout << "Different" << endl;
if (mctr3 == mc2a)
cout << "Same" << endl;
else
cout << "Different" << endl;
}
catch(Invalid)
{
cout << "Exception thrown" << endl;
}
}
Counter.h
Code:
#ifndef COUNTER_H
#define COUNTER_H
// DO NOT MODIFY THIS FILE
// DO NOT MODIFY THIS FILE
// DO NOT MODIFY THIS FILE
// This class models a Counter that holds a value and allows you
// to increment, decrement and reset.
// An exception class
class Invalid
{
};
class Counter
{
public:
Counter();
// Purpose: To initialize the Counter object
// Requirements: -
// Promises: Couter's value is 0.
// Exception: -
virtual ~Counter();
// Purpose: To properly cleanup the object
// Requirements: -
// Promises: -
// Exception: -
Counter(const Counter& other);
// Purpose: To initialize the Counter object
// Requirements: -
// Promises: Counter's value == other's value
// Exception: -
virtual const Counter& operator=(const Counter& other);
// Purpose: To copy the value from one counter to another.
// Requirements: -
// Promises: this object's value == other's value
// Exception: May throw an Invalid exception (for future use).
virtual bool operator==(const Counter& other) const;
// Purpose: Checks if two counter objects are equal (by value).
// Requirements: -
// Promises: Returns a true if value of this object == other's value.
// Exception: May throw an Invalid exception (for future use).
int getCounterValue() const;
// Purpose: To query the value of the counter object.
// Requirements: -
// Promises: Returns the current value of the counter.
// Exception: -
virtual Counter operator++();
// Purpose: To increment the value of the counter.
// Requirements: -
// Promises: Note the value may actually be more or less depending on implementation.
// Exception: -
virtual Counter operator++(int);
// Purpose: To increment the value of the counter.
// Requirements: -
// Promises: Note the value may actually be more or less depending on implementation.
// Exception: -
virtual Counter operator--();
// Purpose: To decrement the value of the counter.
// Requirements: -
// Promises: Note the value may actually be more or less depending on implementation.
// Exception: -
virtual Counter operator--(int);
// Purpose: To increment the value of the counter.
// Requirements: -
// Promises: Note the value may actually be more or less depending on implementation.
// Exception: -
virtual void reset();
// Purpose: To set the value of the counter to 0.
// Requirements: -
// Promises: Counter's value is 0.
// Exception: -
private:
int value;
};
#endif COUNTER_H
Counter.cpp
Code:
// DO NOT MODIFY THIS FILE
// DO NOT MODIFY THIS FILE
// DO NOT MODIFY THIS FILE
#include "Counter.h"
Counter::Counter()
{
value = 0;
}
Counter::~Counter()
{
}
Counter::Counter(const Counter& other)
{
value = other.value;
}
const Counter& Counter::operator=(const Counter& other)
{
if (this != &other)
{
value = other.value;
}
return *this;
}
bool Counter::operator==(const Counter& other) const
{
return value == other.value;
}
int Counter::getCounterValue() const
{
return value;
}
Counter Counter::operator++()
{
value++;
return *this;
}
Counter Counter::operator++(int)
{
Counter temp = *this;
value++;
return temp;
}
Counter Counter::operator--()
{
value--;
return *this;
}
Counter Counter::operator--(int)
{
Counter temp = *this;
value--;
return temp;
}
void Counter::reset()
{
value = 0;
}
ModCounter.h
Code:
#include "Counter.h"
#ifndef MODCOUNTER_H
#define MODCOUNTER_H
class ModCounter:public Counter
{
public:
ModCounter();
// Purpose: to initialize a ModCounter
// Requirements: no input is required
// Promises: limit will be 1
// Exception:
ModCounter(const int);
//Purpose: to initialize a ModCounter
//Requirements: it takes an integer
//Promises: to set the limit to the value of the parameter
//Exception:
ModCounter(const Counter& other);
// Purpose: to assign other to the current object, and determines
// type of object with dynamic_cast.
// Requirements: it takes a Counter object
// Promises: value will be set to the value of object other
// limit will be copied
// Exception:
virtual const Counter& operator=(const ModCounter& other);
// Purpose: to assign object other to the current object, and determines other type
// via dynamic_cast
// Requirements: it takes a Counter object
// Promises: value and limit will be set to those of ModCounter
// object other
// Exception:
virtual bool operator==( const Counter& other) const;
// Purpose: to test whether object other and the current hold
// same value and limit, uses dynamic_cast to determine &other type
// Requirements: it takes a Counter object
// Promises: when limits of ModCounter object other and the
// current are not equivalent, throw exception; return
// true when limits and values of both object are equal
// else otherwise
// Exception: if the limits of the two objects are unequal its throws
// invalid exception
virtual Counter operator++();
// Purpose: to increment the value of current object by 1
// Requirements:
// Promises: increment when value doesn't exceed limit - 1, else
// reset the value to zero
// Exception:
virtual Counter operator++(int);
// Purpose: to increment the value of current object by 1
// Requirements: takes an int as an argument
// Promises: increment when value doesn't exceed limit - 1, else
// reset the value to zero
// Exception:
virtual Counter operator--();
// Purpose: to decrement the value of current object by 1
// Requirements:
// Promises: set the value to limit - 1 when value is zero, else
// decrement the current value by 1
// Exception:
virtual Counter operator--(int);
// Purpose: to decrement the value of current object by 1
// Requirements: it still doesn't need any parameter; "int" is
// just a flag
// Promises: set the value to limit - 1 when value is zero, else
// decrement the current value by 1
// Exception:
virtual ~ModCounter();
// Purpose: to destroy a Modcounter
// Requirements:
// Promises:
// Exception:
private:
int limit;
};
#endif MODCOUNTER_H
ModCounter.cpp
Code:
#include "ModCounter.h"
#include "Counter.h"
ModCounter::ModCounter()
:limit(1)
{
}
ModCounter::ModCounter(const int newLimit)
:limit(newLimit)
{
}
ModCounter::~ModCounter()
{
}
ModCounter::ModCounter(const Counter& other)
{
int i=0;
const ModCounter *ptrMod2= dynamic_cast<const ModCounter*>(&other);
if(ptrMod2!=0)
{
for(i=0;i<ptrMod2->getCounterValue()-1;i++)Counter::operator ++();
limit=ptrMod2->limit;
}
}
Counter ModCounter::operator ++()
{
if(getCounterValue()<limit-1)Counter::operator ++();
else reset();
return *this;
}
Counter ModCounter::operator ++(int)
{
Counter temp=*this;
if(getCounterValue() < limit - 1)Counter::operator++();
else reset();
return temp;
}
Counter ModCounter::operator --()
{
int i=0;
if(getCounterValue()==0)
{
for(i=0;i<limit-1;i++)Counter::operator ++();
}
else Counter::operator --();
return *this;
}
Counter ModCounter::operator --(int)
{
Counter temp1=*this;
int i=0;
if(getCounterValue() == 0 )
{
for (i = 0; i < limit - 1; i++)Counter::operator++();
}
else Counter::operator--();
return temp1;
}
bool ModCounter::operator ==(const Counter& other) const
{
const ModCounter *ptrMod= dynamic_cast<const ModCounter*>(&other);
if(ptrMod!=0)
{
if(limit!=ptrMod->limit)throw Invalid();
}
return (limit==ptrMod->limit && getCounterValue()==ptrMod->getCounterValue());
}
const Counter& ModCounter::operator =(const ModCounter& other)
{
const ModCounter *ptrMod1= dynamic_cast<const ModCounter*>(&other);
if(ptrMod1!=0)
{
Counter::operator=(other);
limit = ptrMod1->limit;
}
return *ptrMod1;
}