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.



Answers

If you only want to interact with Date objects, why not just use plain polymorphism and simply deal with Date*-s?

If you plan to have a collection of Dates in Calendar, which can contain instances of different Date subclasses, then I doubt templates are going to work and you have nothing but polymorphism to help you out in the first place.

As to templates, if a given type has a suitable interface, why shouldn't it work with the Calendar? (Well, concepts were planned for C++0x, but dropped, but their main motivation seemed to be to allow clearer template-related error messages.)

By : UncleBens


Templates usually don't require inheritance/polymorphism restrictions. A template is designed to work with any type that satisfies the given requirements regardless of base types.

template <typename T>
T clone(const T& cloneable) {
    return cloneable.create_clone();
} 

This code will work for any type that has supports a create_clone() operation, no ICloneable-interface is used!

In your case, this code will allow any type that behaves like a date to be used.

If you want base class polymorphism, just leave the templates out and use Date*.

Note that if you really want to do your template test, you can try to cast a dummy object pointer to Date* which will fail at compile time if it is no derivative of Date. But this is normally not the way template code is used.

By : Dario


In C++ speak, this is called concept checking. In C++, a commonly stated best practice is that inheritance is used for inheriting interfaces and not implementation. So you're not actually so much interested about whether D inherits from Date, but whether D has the interface elements of Date that you need, namely it has the requisite member functions etc. The advantage then of this is that you don't need to have future D classes needing to inherit from Date, they just need to implement certain functions.

Concept checking was removed in C++0x, but you can find it in Boost.ConceptCheck (Boost main site is here).

If you really want to enforce that D inherits from Date though, you can use Boost.StaticAssert in combination with Boost.TypeTraits to check if D inherits from Date.

By : blwy10


This video can help you solving your question :)
By: admin