Description

Create a C++ class called upDate. It should have the following operations:

• upDate( ) – default constructor. This will set the date to May 11, 1959 (A very important date!!!)
• upDate(int M, int D, int Y) – overloaded constructor. This will set the date to the values passed in through the parameter list represented by Month, Day and Year. If any one of the parameters is out of range, the date is set to the default date.
• upDate( int J) – overloaded constructor – create a date using the Julian date
• ~upDate( ) – destructor. Be sure to de-allocate any memory that was allocated in the constructor.
• void setDate(int M, int D, int Y) – works just like the constructor
• int getMonth( ) – return the month in integer form
• int getDay( ) – return the day of the month
• int getYear( ) – return the year
• string getMonthName( ) – return the name of the month

Add the necessary class methods (functions) to support the following:

• upDate D1(10,27,2010); // overloaded constructor
• upDate D2(D1);               // copy constructor
• upDate D3 = D2;             // also copy constructor – initialize D3 to be copy of D2
• D1 = D2;                           // assignment operator
• D1 += 5;                            // add 5 days to D1, result is stored in D1
• D1 -= 7;                             // subtract 7 days from D1, result is stored in D1
• D3 = D2 + 5;                     // add 5 days to D2, assign result to D3
• D3 = 5 + D2;                     // add 5 days to D2, assign result to D3
• D3 = D2 – 4;                     // subtract 4 days from D2, assign result to D3
• int x = D5 – D4;                // days between D5 and D4. Can be negative or positive
• cout << upDate::GetDateCount(); // a static method that returns the number of upDate objects that currently exist
• cout << D1;                       // will print “10/27/2010”
• D1++;                                // increment D1 by one day – postfix style
• ++D1;                                // also increment D1 by one day – prefix style
• D1–;                                  // decrement D1 by one day – postfix style
• –D1;                                  // decrement D1 by one day – prefix style
• cout << D1.julian();        // print the Julian integer represented by D1
• Comparison Operators
  • if (D1 == D2)
  • if (D1 < D2)
  • if (D1 > D2)

Additional requirements:

You MUST create a pointer in the private data members that points to an integer array. When you create an upDate object (using any constructor) you must dynamically allocate an array of three integers – the Month, Day and Year. Similar details must happen during the assignment operator.

Write a driver program that tests each operation. I will provide a test program to you before the due date.

Prog #4 Learning Objectives

• Operator Overloading
• Friend functions
• Deep vs shallow copy – we require deep on this assignment because of dynamic memory in constructors
• Big 3 – if a class defines any of these, it should define them all
  • Copy constructor
  • Assignment operator
  • destructor
• Static data members to keep track of how many instances currently exist
• Static class member functions

The Julian date (JD) is a continuous count of days from 1 January 4713 BC (= -4712 January 1), Greenwich mean noon (= 12h UT). For example, AD 1978 January 1, 0h UT is JD 2443509.5 and AD 1978 July 21, 15h UT, is JD 2443711.125.

Conversion of Gregorian calendar date to Julian date for years AD 1801-2099 can be carried out with the following formula:

where K is the year (1801 <= K <= 2099), M is the month (1 <= M <= 12), I is the day of the month (1 <= I <= 31), and UT is the universal time in hours (“<=” means “less than or equal to”). The last two terms in the formula add up to zero for all dates after 1900 February 28, so these two terms can be omitted for subsequent dates. This formula makes use of the sign and truncation functions described below:

The sign function serves to extract the algebraic sign from a number.
Examples: sign(247) = 1; sign(-6.28) = -1.

The truncation function < > extracts the integral part of a number.
Examples: <17.835> = 17; <-3.14> = -3.

Example: Compute the JD corresponding to 1877 August 11, 7h30m UT.
Substituting K = 1877, M = 8, I = 11 and UT = 7.5,
JD = 688859 – 3286 + 244 + 11 + 1721013.5 + 0.3125 + 0.5 + 0.5
= 2406842.8125

The formula given above was taken from the U.S. Naval Observatory’s no-longer- published Almanac for Computers for year 1990.

Also see our Julian date converter data service.

Fliegel and van Flandern (1968) published compact computer algorithms for converting between Julian dates and Gregorian calendar dates. Their algorithms were presented in the Fortran programming language, and take advantage of the truncation feature of integer arithmetic. The following Fortran code modules are based on these algorithms. In this code, YEAR is the full representation of the year, such as 1970, 2000, etc. (not a two-digit abbreviation); MONTH is the month, a number from 1 to 12; DAY is the day of the month, a number in the range 1-31; and JD is the the Julian date at Greenwich noon on the specified YEAR, MONTH, and DAY.

Conversion from a Gregorian calendar date to a Julian date. Valid for any Gregorian calendar date producing a Julian date greater than zero:

Conversion from a Julian date to a Gregorian calendar date.

Example: YEAR = 1970, MONTH = 1, DAY = 1, JD = 2440588.

Reference: Fliegel, H. F. and van Flandern, T. C. (1968). Communications of the ACM, Vol. 11, No. 10 (October, 1968).