[ Viewing Hints ] [ Revision History ] [ Book Home Page ] [ Free Newsletter ]
[ Seminars ] [ Seminars on CD ROM ] [ Consulting ]

Thinking in C++, 2nd edition, Volume 2
Revision 4.0

by Bruce Eckel & Chuck Allison
©2001 MindView, Inc.

[ Previous Chapter ] [ Short TOC ] [ Table of Contents ] [ Index ] [ Next Chapter ]

1. I understand the requirements.
2. My code meets those requirements.

• A date can be initialized with a string (YYYY-MM-DD), three integers (Y, M, D), or nothing (today's date).
• A date object can yield its year, month, and day or a string of the form "YYYY-MM-DD".
• All relational comparisons are available, as well as computing the duration between two dates (in years, months, and days), and adding or subtracting a duration.
• Dates need to span an arbitrary number of centuries (e.g., 1600-2200).

//: C02:Date.h
#ifndef DATE_H
#define DATE_H
#include <string>

struct Duration {
  int years;
  int months;
  int days;
  Duration(int y, int m, int d)
    : years(y), months(m), days(d) {}
};

class Date {
public:
  Date();
  Date(int year, int month, int day);
  Date(const std::string&);
  int getYear() const;
  int getMonth() const;
  int getDay() const;
  std::string toString() const;
  friend Duration 
  duration(const Date&, const Date&);
  friend bool 
  operator<(const Date&, const Date&);
  friend bool 
  operator<=(const Date&, const Date&);
  friend bool 
  operator>(const Date&, const Date&);
  friend bool 
  operator>=(const Date&, const Date&);
  friend bool 
  operator==(const Date&, const Date&);
  friend bool 
  operator!=(const Date&, const Date&);
private:
  int year;
  int month;
  int day;
  int compare(const Date&) const;
  static int daysInPrevMonth(int year,int mon);
};
#endif ///:~

//: C02:Date.cpp {O}
#include "Date.h"
#include <string>
#include <algorithm> // for swap()
#include <ctime>
#include <cassert>
#include <sstream>
#include <iomanip>
using namespace std;

namespace {
  const int daysInMonth[][13] = {
    {0,31,28,31,30,31,30,31,31,30,31,30,31},
    {0,31,29,31,30,31,30,31,31,30,31,30,31}};
  inline bool isleap(int y) {
    return y%4 == 0 && y%100 != 0 || y%400 == 0;
  }
}

Date::Date() {
  // Get current date
  time_t tval = time(0);
  struct tm *now = localtime(&tval);
  year = now->tm_year + 1900;
  month = now->tm_mon + 1;
  day = now->tm_mday;
}

Date::Date(int yr, int mon, int dy) {
  assert(1 <= mon && mon <= 12);
  assert(1 <= dy && 
    dy <= daysInMonth[isleap(year)][mon]);
  year = yr;
  month = mon;
  day = dy;
}

Date::Date(const std::string& s) {
  // Assume YYYYMMDD format
  istringstream is(s);
  is >> setw(4) >> year;
  is >> setw(2) >> month;
  is >> setw(2) >> day;
}

int Date::getYear() const {
  return year;
}

int Date::getMonth() const {
  return month;
}

int Date::getDay() const {
  return day;
}

string Date::toString() const {
  ostringstream os;
  os << setw(4) << year
   << setw(2) << month
   << setw(2) << day;
  return os.str();
}

int Date::compare(const Date& d2) const {
  int result = year - d2.year;
  if (result == 0) {
    result = month - d2.month;
    if (result == 0)
      result = day - d2.day;
  }
  return result;   
}

int Date::daysInPrevMonth(int year, int month) {
  if (month == 1) {
    --year;
    month = 12;
  }
  else
    --month;
  return daysInMonth[isleap(year)][month];
}

bool operator<(const Date& d1, const Date& d2) {
  return d1.compare(d2) < 0;
}
bool operator<=(const Date& d1, const Date& d2) {
  return d1.compare(d2) <= 0;
}
bool operator>(const Date& d1, const Date& d2) {
  return d1.compare(d2) >= 0;
}
bool operator>=(const Date& d1, const Date& d2) {
  return d1.compare(d2) >= 0;
}
bool operator==(const Date& d1, const Date& d2) {
  return d1.compare(d2) == 0;
}
bool operator!=(const Date& d1, const Date& d2) {
  return d1.compare(d2) != 0;
}

Duration 
duration(const Date& date1, const Date& date2) {
  int y1 = date1.year;
  int y2 = date2.year;
  int m1 = date1.month;
  int m2 = date2.month;
  int d1 = date1.day;
  int d2 = date2.day;

  // Compute the compare
  int order = date1.compare(date2);
  if (order == 0)
    return Duration(0,0,0);
  else if (order > 0) {
    // Make date1 precede date2 locally
    using std::swap;
    swap(y1, y2);
    swap(m1, m2);
    swap(d1, d2);
  }

  int years = y2 - y1;
  int months = m2 - m1;
  int days = d2 - d1;
  assert(years > 0 ||
     years == 0 && months > 0 ||
     years == 0 && months == 0 && days > 0);

  // Do the obvious corrections (must adjust days
  // before months!) - This is a loop in case the
  // previous month is February, and days < -28.
  int lastMonth = m2;
  int lastYear = y2;
  while (days < 0) {
    // Borrow from month
    assert(months > 0);
    days += Date::daysInPrevMonth(
      lastYear, lastMonth--);
    --months;
  }

  if (months < 0) {
    // Borrow from year
    assert(years > 0);
    months += 12;
    --years;
  }
  return Duration(years, months, days);
} ///:~

//: C02:SimpleDateTest.cpp
//{L} Date
#include "Date.h"
#include <iostream>
using namespace std;

int nPass = 0, nFail = 0;
void test(bool t) {
  if(t) nPass++; else nFail++;
}

int main() {
  Date mybday(1951, 10, 1);
  test(mybday.getYear() == 1951);
  test(mybday.getMonth() == 10);
  test(mybday.getDay() == 1);
  cout << "Passed: " << nPass << ", Failed: "
       << nFail << endl;
}
/* Output:
Passed: 3, Failed: 0
*/ ///:~

//: C02:DateTest.h
#include "../TestSuite/Test.h"
#include "Date.h"

class DateTest : public Test {
  Date mybday;
  Date today;
public:
  DateTest()
    : mybday(1951, 10,1) {}
  void run() {
    testOps();
    testDuration();
  }
  void testOps() {
    test_(mybday < today);
    test_(mybday <= today);
    test_(mybday != today);
    test_(mybday == mybday);
  }
  void testDuration() {
    Date d2(2001, 7, 4);
    Duration dur = duration(mybday, d2);
    test_(dur.years == 49);
    test_(dur.months == 9);
    test_(dur.days == 3);
  }
}; ///:~

//: C02:DateTest.cpp
// Automated Testing (with a Framework)
//{L} Date ../TestSuite/Test
#include <iostream>
#include "DateTest.h"
using namespace std;

int main() {
  DateTest test;
  test.run();
  test.report();
  return test.getNumFailed();
}
/* Output:
Passed: 7, Failed: 0
*/ ///:~

//: C02:Stack.h
#include <cassert>
#include <cstddef>
#include <stdexcept>
#include <string>
#include <new>

using std::logic_error;
using std::string;
using std::bad_alloc;

// MS std namespace work-around
#ifndef _MSC_VER
using std::size_t;
#endif

class StackError : public logic_error {
public:
  StackError(const string& s) : logic_error(s) {}
};

template<typename T>
class Stack {
public:
  Stack(size_t) throw(StackError, bad_alloc);
  ~Stack();
  void push(const T&) throw(StackError);
  T pop() throw(StackError);
  T top() const throw(StackError);
  size_t size() const;
private:
  T* data;
  size_t max;
  size_t ptr;
};

template<typename T>
inline Stack<T>::~Stack() {
  delete [] data;
  max = ptr = 0;
}

template<typename T>
inline size_t Stack<T>::size() const {
  return ptr;
}

template<typename T>
Stack<T>::Stack(size_t siz) 
  throw(StackError, bad_alloc) {
  if (siz == 0)
    throw StackError("bad size in Stack(size_t)");
  data = new T[siz];
  max = siz;
  ptr = 0;
}

template<typename T>
void Stack<T>::push(const T& x) 
  throw(StackError) {
  if (ptr == max)
    throw StackError("stack overflow");

  assert(ptr < max);
  data[ptr++] = x;
}

template<typename T>
T Stack<T>::pop() throw(StackError) {
  if (ptr == 0)
    throw StackError("stack underflow");
  return data[--ptr];
}

template<typename T>
T Stack<T>::top() const throw(StackError) {
  if (ptr == 0)
    throw StackError("stack underflow");
  return data[ptr - 1];
} ///:~

//: C02:StackTest.h
#ifndef STACKTEST_H
#define STACKTEST_H
#include "Stack.h"
#include "../TestSuite/Test.h"
#include <iostream>
using namespace std;

class StackTest : public Test {
  enum {SIZE = 5};
  Stack<int> stk;
public:
  StackTest() : stk(SIZE){}
  void run(){
    testUnderflow();
    testPopulate();
    testOverflow();
    testPop();
    testBadSize();
  }
  void testBadSize(){
    try {
      Stack<int> s(0);
      fail_("Bad Size");
    }
    catch (StackError&) {
      succeed_();
    }
  }
  void testUnderflow(){
    test_(stk.size() == 0);
    try {
      stk.top();
      fail_("Underflow");
    }
    catch (StackError&) {
      succeed_();
    }
    try {
      stk.pop();
      fail_("Underflow");
    }
    catch (StackError&) {
      succeed_();
    }
  }
  void testPopulate(){
    try {
      for (int i = 0; i < SIZE; ++i)
        stk.push(i);
      succeed_();
    }
    catch (StackError&) {
      fail_("Populate");
    }
    test_(stk.size() == SIZE);
    test_(stk.top() == SIZE-1);
  }
  void testOverflow(){
    try {
      stk.push(SIZE);
      fail_("Overflow");
    }
    catch (StackError&) {
      succeed_();
    }
  }
  void testPop(){
    for (int i = 0; i < SIZE; ++i)
      test_(stk.pop() == SIZE-i-1);
    test_(stk.size() == 0);
  }
}; 
#endif // STACKTEST_H ///:~

//: C02:StackTest.cpp
//{L} ../TestSuite/Test
#include <iostream>
#include "StackTest.h"
using namespace std;

int main() {
  StackTest t;
  t.run();
  t.report();
  return t.getNumFailed();
} ///:~

//: C02:SuiteExample.cpp
//{L} ../TestSuite/Test ../TestSuite/Suite Date
#include <iostream>
#include "../TestSuite/Suite.h"
#include "DateTest.h"
#include "StackTest.h"
using namespace std;

int main() {
  Suite s("Date and Stack Tests");
  s.addTest(new DateTest);
  s.addTest(new StackTest);
  s.run();
  long nFail = s.report();
  s.free();
  cout << "\nTotal failures: " << nFail << endl;
  return nFail;
}

/* Output:
Suite "Date and Stack Tests"
============================
Test "DateTest":
	Passed: 7	Failed: 0
Test "StackTest":
	Passed: 14	Failed: 0
============================

Total failures: 0
*/ ///:~

//: TestSuite:Test.h
#ifndef TEST_H
#define TEST_H
#include <string>
#include <iostream>
#include <cassert>
using std::string;
using std::ostream;
using std::cout;

// The following have underscores because they 
// are macros (and it's impolite to usurp other 
// users' functions!). For consistency, 
// succeed_() also has an underscore.

#define test_(cond) \
  do_test(cond, #cond, __FILE__, __LINE__)
#define fail_(str) \
  do_fail(str, __FILE__, __LINE__)

class Test {
public:
  Test(ostream* osptr = &cout);
  virtual ~Test(){}
  virtual void run() = 0;
  long getNumPassed() const;
  long getNumFailed() const;
  const ostream* getStream() const;
  void setStream(ostream* osptr);
  void succeed_();
  long report() const;
  virtual void reset();
protected:
  void do_test(bool cond, const string& lbl,
               const char* fname, long lineno);
  void do_fail(const string& lbl,
               const char* fname, long lineno);
private:
  ostream* osptr;
  long nPass;
  long nFail;
  // Disallowed:
  Test(const Test&);
  Test& operator=(const Test&);
};

inline Test::Test(ostream* osptr) {
  this->osptr = osptr;
  assert(osptr);
  nPass = nFail = 0;
}

inline long Test::getNumPassed() const {
  return nPass;
}

inline long Test::getNumFailed() const {
  return nFail;
}

inline const ostream* Test::getStream() const {
  return osptr;
}

inline void Test::setStream(ostream* osptr) {
  this->osptr = osptr;
}

inline void Test::succeed_() {
  ++nPass;
}

inline void Test::reset() {
  nPass = nFail = 0;
}
#endif // TEST_H ///:~

//: TestSuite:Test.cpp {O}
#include "Test.h"
#include <iostream>
#include <typeinfo> // Visual C++ requires /GR""
using namespace std;

void Test::do_test(bool cond, 
                   const std::string& lbl,
                   const char* fname, 
                   long lineno){
  if (!cond)
    do_fail(lbl, fname, lineno);
  else
    succeed_();
}

void Test::do_fail(const std::string& lbl,
                   const char* fname, 
                   long lineno){
  ++nFail;
  if (osptr){
    *osptr << typeid(*this).name()
             << "failure: (" << lbl << ") , "
             << fname
             << " (line " << lineno << ")\n";
  }
}

long Test::report() const {
  if (osptr){
    *osptr << "Test \"" << typeid(*this).name()
             << "\":\n\tPassed: " << nPass
             << "\tFailed: " << nFail
             << endl;
  }
  return nFail;
} ///:~

//: TestSuite:Suite.h
#ifndef SUITE_H
#define SUITE_H
#include "../TestSuite/Test.h"
#include <vector>
#include <stdexcept>
using std::vector;
using std::logic_error;

class TestSuiteError : public logic_error {
public:
  TestSuiteError(const string& s = "")
    : logic_error(s) {}
};

class Suite {
public:
  Suite(const string& name, ostream* osptr = &cout);
  string getName() const;
  long getNumPassed() const;
  long getNumFailed() const;
  const ostream* getStream() const;
  void setStream(ostream* osptr);
  void addTest(Test* t) throw (TestSuiteError);
  void addSuite(const Suite&) 
    throw(TestSuiteError);
  void run();  // Calls Test::run() repeatedly
  long report() const;
  void free(); // Deletes tests
private:
  string name;
  ostream* osptr;
  vector<Test*> tests;
  void reset();
  // Disallowed ops:
  Suite(const Suite&);
  Suite& operator=(const Suite&);
};

inline
Suite::Suite(const string& name, ostream* osptr)
   : name(name) {
  this->osptr = osptr;
}

inline string Suite::getName() const {
  return name;
}

inline const ostream* Suite::getStream() const {
  return osptr;
}

inline void Suite::setStream(ostream* osptr) {
  this->osptr = osptr;
}
#endif // SUITE_H ///:~

//: TestSuite:Suite.cpp {O}
#include "Suite.h"
#include <iostream>
#include <cassert>
using namespace std;

void Suite::addTest(Test* t) 
  throw(TestSuiteError) {
  // Make sure test has a stream:
  if (t == 0)
    throw TestSuiteError(
      "Null test in Suite::addTest");
  else if (osptr != 0 && t->getStream() == 0)
    t->setStream(osptr);
  tests.push_back(t);
  t->reset();
}

void Suite::addSuite(const Suite& s) 
  throw(TestSuiteError) {
  for (size_t i = 0; i < s.tests.size(); ++i)
    addTest(s.tests[i]);
}

void Suite::free() {
  // This is not a destructor because tests
  // don't have to be on the heap.
  for (size_t i = 0; i < tests.size(); ++i) {
    delete tests[i];
    tests[i] = 0;
  }
}

void Suite::run() {
  reset();
  for (size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    tests[i]->run();
  }
}

long Suite::report() const {
  if (osptr) {
    long totFail = 0;
    *osptr << "Suite \"" << name 
             << "\"\n=======";
    size_t i;
    for (i = 0; i < name.size(); ++i)
      *osptr << '=';
    *osptr << "=\n";
    for (i = 0; i < tests.size(); ++i) {
      assert(tests[i]);
      totFail += tests[i]->report();
    }
    *osptr << "=======";
    for (i = 0; i < name.size(); ++i)
      *osptr << '=';
    *osptr << "=\n";
    return totFail;
  }
  else
    return getNumFailed();
}

long Suite::getNumPassed() const {
  long totPass = 0;
  for (size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    totPass += tests[i]->getNumPassed();
  }
  return totPass;
}

long Suite::getNumFailed() const {
  long totFail = 0;
  for (size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    totFail += tests[i]->getNumFailed();
  }
  return totFail;
}

void Suite::reset() {
  for (size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    tests[i]->reset();
  }
} ///:~

1. Exercise 1
2. Exercise 2
3. Exercise 3
4. Etc.