Template Class，C ++的默认值

Question

Is there a way to give a default value for a template class?

Eg Say I have a class TimeSeries , that is templated. And I have a function called Foo() that returns T .

template <typename T>
class TimeSeries
{
    T foo();
}

I want Foo() to do some calculation and return something of type T . But in case it can't, I want it to give a default value. If T was double , I want that to be NaN . If T was int , I want that to be 0 .

TimeSeries<double> t;
t.foo(); // returns NAN

TimeSeries<int> t;
t.foo(); // returns 0

How would I achieve that?

A bad solution is for Foo() to take in a default value.

template <typename T>
class TimeSeries
{
    T foo(T defaultValue)
    {
       T ret;
       // if OK
       ret = computeValue();
       // if not OK
       ret = defaultValue;
       return ret;
    }
}

So default value would be 0 , or NaN , depending on the user.

Or am I asking for a flawed design in the first place?

EDIT - A logical question would be to ask what happens if T is not int or double . What does a default value even mean?

The way I'm using TimeSeries , T is not exactly a general purpose type. It could only be 1 of int , double , and string . I thought about simply writing 3 separate TimeSeries classes, but that seems like a flawed approach.

I'm open to other ideas.

Answer 1

You could declare the following template, default_value<> :

template<typename>
struct default_value;

Then, provide full specializations for int and double with a member called value which provides the desired default value:

template<>
struct default_value<int> {
   static constexpr int value = 0;
};

template<>
struct default_value<double> {
   static constexpr double value = NaN;
};

Then, in your foo function template, you can simply return that value:

return default_value<T>::value;

which will depend on T .

Answer 2

since C++14 you can use a variable template :

template <class T> constexpr T default_value = {};
template <>
constexpr double default_value<double> = std::numeric_limits<double>::quiet_NaN();

template <typename T> class TimeSeries
{
    auto foo() -> T
    {
       T ret;

       if (condition)
         return ret;
       else
         return default_value<T>;
    }
};

Answer 3

Or am I asking for a flawed design in the first place?

As far as I'm concerned it's a valid requirement.

I see two ways you can address that requirment.

1. You can use the default_value approach as suggested in the other answer .

2. If you have the option of using C++17, you can use std::optional .

   If you don't have the option of using C++17, you can emulate std::optional in a less sophisticated way by changing the return value to std::pair<boo, T> with the understanding that the first of the returned value is set to false if the computation was not successful and to true if the computation was successful.

Personally, I would prefer the second solution. It does not rely on sentry values. It captures the state of whether the computation was successful in a clear and explicit manner.