Cascading C++ Templates Usage

Question

I have two classes:

1. ValueRange
2. MenuItem

A third class Menu uses the MenuItem class to define several menu items, each having a range of values (ints, floats, boolean).

What I did is:

template <class T>
class ValueRange{
    private:
        T minValue;
        T maxValue;         
    public:
        void setMinValue(T minValue){this->minValue=minValue;};
        void setMaxValue(T maxValue){this->maxValue=maxValue;};
        ValueRange(){};
        ~ValueRange(){};
};

and

#include <string>
#include "ValueRange.hh"
class MenuItem{
    private:
      std::string name;
      /*
       * does not compile...
       * error: invalid use of template-name 'ValueRange' 
       * without an argument list
       * error: 'ValueRange' is not a type
       */
      ValueRange value;
    public:
      /*
       * does not compile...
       * error: 'class MenuItem' has no member named 'value' 
       */
      void setValueRange(ValueRange value){this->value=value;}
      MenuItem(){};
      ~MenuItem(){};
};

How may I implement the class MenuItem that its attribute value is generic, so that I could have menuItems having value ranges of ints, floats, booleans, etc.?

Answer 1

Just parametrize MenuItem the same as ValueRange:

template<class T>
class MenuItem
{
   ...
   ValueRange<T> value;
   ...
   void setValueRange(ValueRange<T> value) { ... }
   ...
};

Answer 2

Class templates in C++ require an instantiation. For example:

ValueRange<int>

is a valid type.

ValueRange

without a type is not.

To implement a generic MenuItem, you can for example make MenuItem a templated class as well, or you can make your ValueRange extend a non-templated base class, for example:

class ValueRangeBase { /* some virtual members here... */ };

template <class T>
class ValueRange : public ValueRangeBase { /* same as before */ };

Then you can use the ValueRangeBase (not by value though) as a generic ValueRange. This is useful some times, but maybe not exactly what you want.