C++: Polymorphic class template

Question

Consider a class Calendar that stores a bunch of Date objects. The calendar is designed to hold a collection of any type of objects that inherit from Date. I thought the best way to do it is to have a class template such as

template<typename D> class Calendar{ 
    ...
}

But it struck me that D can now in fact be any class. My question is now, how can I make sure that D is a subclass of the date object?

I know how to do this is Java, but I'm still unfamiliar with the C++ syntax. The problem is very much similar to how some collections can only take a template variables that implement Comparable. The header would then look something like

public class Calendar<D extends Date>{
     ...
}

--------------------EDIT: ------------------------------------------

The template argument defines which actual day the calendar refers to. Different date types refer to the same day in different formats. For instance, if I make a Calendar<Gregorian> it will be able to take dates in another Date format, say the Julian calendar, or any other date format and present them in Gregorian format. This enables for conversion between calendars in different date formats. So, if I have a Calendar<Gregorian> I can easily convert it into a Calendar<Julian>. Then the following is possible:

Calendar<Gregorian> cal;
std::cout << "These events are entered as dates in 
    the Gregorian calendar" << std::endl;
cal.add_event("Christmas", 12, 25);
cal.add_event("Gregorian new year", 1, 1);
std::cout << cal << std::endl;
std::cout << "----" << std::endl;
std::cout << "And printed out as Julian dates" << std::endl;
Calendar<Julian>(cal);
std::cout << cal<< std::endl;

and outputs:

These events are entered as dates in the Gregorian calendar
2009-12-25 Christmas
2010-01-01 Gregorian new year
----
And printed out as Julian dates
2009-12-13 Christmas
2009-12-19 Gregorian new year

------------- New edit: ----------------------

The last edit now makes more sense. I had a slight disagreement with the formatting.

Thanks for all the answers.

I'm a Computer Science student on my third year, and I'd say I'm fairly familiar with OO and related concepts like Polymorphism etc. The purpose of this post was to find out whether or not there was a way in C++ to express a condition for a template argument the same way that it is in Java and solve the problem in a concise, elegant and intuitive way.

Answer 1

I know how to do this is Java, but I'm still unfamiliar with the C++ syntax. The problem is very much similar to how some collections can only take a template variables that implement Comparable. The header would then look something like

public class Calendar<D extends Date>{
     ...
}

True, it is the same problem, and in C++, it is usually solved by ignoring it. Why do we need to enforce that the object must implement IComparable? In Java, it's necessary because of its anemic type system. Without this constraint, we'd be unable to compare objects.

In C++, the rules are different. Containers simply try to compare the objects they store, and if the type doesn't support it, you get a compile error. No interfaces or inheritance is required.

And you'd typically do the same in your Calendar class. Simply don't enforce the "must subclass form Date constraint.

Instead, specify the members the type must expose, and what, if any, semantics should be expected from them.

For example, if your Calendar attempts to do the following operations, for date objects d0 and d1:

d0.getDay();
d0.getTime();
Time t = d0 - d1;

Then those are the operations that should be supported. Any class which supports these operations is a valid Date class, even if it doesn't subclass anything.

Answer 2

What you're looking for is concept checks for template arguments. These had been part of the draft for the next C++ standard, but had been thrown out again a few weeks/months ago.

Without concepts in the language proper, there are a few libraries that try to do this, but the reason for wanting concept checks being part of the core language is that it is more or less impossible to implement them without language support.

In your concrete example this shouldn't bee too hard, though. For example, you could put some special typedef into the base class and check for that:

class date {
  public:
    typedef int is_derived_from_date;
};

template<typename D> class Calendar{ 
    typedef typename D::is_derived_from_date blah;
    ...
};

Another way would be to pick any of the is_derived<B,D>::result template meta functions floating around on the net and implement a static check for this in your Calender class. Boost has both the is_derived meta function and a static assert.

Having said all this, however, I have to question your design. What's wrong with ordinary OO polymorphism that you want to use templates' compile-time polymorphism?

Answer 3

I think your problem is solvable without using templates. D is always a derived class of Date, then why not just have a collection of Date objects?