我应该在哪里放置班级需要的常量，以保持全局空间的自由？

Question

First: I know how to write the program, so I'm not asking for help with that. However, I am pasting a copy of the problem so you can see what the assignment entails. My question is specifically aimed at where do you place variables to keep from making everything global?

Assignment

Design a class called Date that has integer data members to store month, day, and year. The class should have a three-parameter default constructor that allows the date to be set at the time a new Date object is created. If the user creates a Date object without passing any arguments, or if any of the values passed are invalid, the default values of 1, 1, 2001 (ie, January 1, 2001) should be used. The class should have member functions to print the date in the following formats:

3/15/10
March 15, 2010
15 March 2010

Questions

1) The teacher has instructed us to avoid using magic numbers in our code, so the first question is regarding my implementation of the default constructor:

// These are outside the class.
#define DEFAULT_MONTH 1
#define DEFAULT_DAY   1
#define DEFAULT_YEAR  2001

// This is inside the class definition.
Date(int month = DEFAULT_MONTH, int day = DEFAULT_DAY, int year = DEFAULT_YEAR);

Is this correct?

2) The class needs access to an array of string objects which hold the month names so I can use them for date outputs which display the month name instead of the month number. I used an enum for the numeric month (which will be used for the switch ).

const enum MONTH_IDS { JANUARY = 1, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY,
    AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER };

const string MONTH_NAMES[NUM_MONTHS] = { "January", "February", "March",
    "April", "May", "June", "July", "August", "September", "October",
    "November", "December" };

The question for this part, is where do you place them?

Some things I can't do... I am not allowed to use static class members yet because that will be covered in the next chapter. We also have not gone over pointers, but we can use references.

Thanks for your help!

I would ask the instructor but he is out of town and the assignment is due tomorrow.

Answer 1

1) Defines are ugly. static const int members are what I would do, but you can't ... How about enums?

struct Date {
    enum Constants {
        DEFAULT_YEAR = 2001,
        DEFAULT_MONTH = 1,
        DEFAULT_DAY = 1,
    };


    Date(int month = DEFAULT_MONTH, int day = DEFAULT_DAY, int year = DEFAULT_YEAR);

};

2) A static member array is just what you need. But since you can't ... maybe static local variables:

struct Date {
    std::string MonthToString(enum MONTH_IDS m) {
        static const char *monthNames[] = {
            "January", "February", "March", "April", "May", "June",
            "July", "August", "September", "October", "November", "December" };
        if(m >= sizeof(monthNames)/sizeof(monthNames[0]))
            return std::string("Unknown");
        return std::string(monthNames[m]);
    }
};

Answer 2

If you would like to define a constant without polluting a global namespace, two of your best options are using namespaced globals or class statics. Since you say you can't use class statics, I'll show an example of namespaced globals:

// .h file
namespace mynamespace {
    extern const int foo;
};

// later, in a .cpp file
namespace mynamespace {
    const int foo = 42;
};

You can access this variable as mynamespace::foo , or by using namespace mynamespace; (which is to be avoided in header files), or as just foo in any other function in the mynamespace namespace. Since it's only accessible by something requesting (or otherwise being aware of) the mynamespace namespace, it avoids polluting the global namespace (and all the unfortunate name collisions this involves).

For numeric values, an enum is another choice:

class foo {
  enum { CONST_FOO = 42, CONST_BAR = 24 };
};

These values are compile-time constants; you cannot take the address of them (but they can be a bit faster than const variables). Note that this can only be used for integer values.

Function statics are another good option:

void myclass::somefunction() {
    static const char *monthNames[] = { "JANUARY", ... };
    //...
}

However, because the array is embedded deep into your implementation, it's not much better than a 'magic number'.

In your case, I do think either using enum s or (for non-integers) class statics would be best. If your professor has arbitrarily restricted use of class statics, put the variables at global scope (possibly in a namespace) and add a comment stating that you would have made them class statics if you were allowed to.

Answer 3

If you can't do static const members (or locals) you can just put everything in a namespace:

declaration:

namespace ephaitch {
    extern const int Date_default_month;
    extern const int Date_default_day;
    extern const int Date_default_year;
    class Date {
        Date(int month = DEFAULT_MONTH, int day = DEFAULT_DAY, int year = DEFAULT_YEAR);
    };
}

definition:

namespace ephaitch {
    const int Date_default_month = 1;
    const int Date_default_day = 1;
    const int Date_default_year = 2001; 

    enum MONTH_IDS { JANUARY = 1, FEBRUARY, MARCH, APRIL, 
                     MAY, JUNE, JULY, AUGUST, 
                     SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER 
                   };

    const string MONTH_NAMES[NUM_MONTHS] = { 
         "January", "February", "March",
         "April", "May", "June", 
         "July", "August", "September", 
         "October", "November", "December" 
        };

    Date(int month, int day, int year)
    {
    }
}

Don't use DEFINE s, they pollute all namespaces, and make debugging trickier. enum s are better, but since that's not the intended usage, it can be confusing.