Repeating template parameter

[mathieu]

Hi there,

I guess this is a pretty vague question but I stumble on it a couple
of times and never really knew what was a nice solution to it. I am
trying to avoid passing twice a template parameter when it could be
either deduced or simple reused. For instance I have a calculator
class that take a simple helper function that perform an operation on
the same type as my calculator,.
I would write something like this:

template <typename T>
struct Helper1
{
inline double operator() (T t) { return t; }
};
template <typename T>
struct Helper2
{
inline double operator() (T t) { return -t; }
};

template <typename T, typename THelper>
struct Calculator
{
static double compute(double t) {
THelper th;
return th(t);
}
};

int main()
{
Calculator<double, Helper1<double c;
return 0;
}

Notice how I write twice 'double' in

Calculator<double, Helper1<double c;

Thanks for suggestion,
-Mathieu

[Ondra Holub]

On 10 Pro, 15:32, mathieu <[e-mail]:

Hi there,

I guess this is a pretty vague question but I stumble on it a couple
of times and never really knew what was a nice solution to it. I am
trying to avoid passing twice a template parameter when it could be
either deduced or simple reused. For instance I have a calculator
class that take a simple helper function that perform an operation on
the same type as my calculator,.
I would write something like this:

template <typename T>
struct Helper1
{
inline double operator() (T t) { return t; }};

template <typename T>
struct Helper2
{
inline double operator() (T t) { return -t; }

};

template <typename T, typename THelper>
struct Calculator
{
static double compute(double t) {
THelper th;
return th(t);
}

};

int main()
{
Calculator<double, Helper1<double c;
return 0;

}

Notice how I write twice 'double' in

Calculator<double, Helper1<double c;

Thanks for suggestion,
-Mathieu

Try this:

template<
typename T,
template<typename Tclass THelper

>

struct Calculator

[Daniel Lidstrom]

On 10 Dec, 15:32, mathieu <[e-mail]:

template <typename T, typename THelper>
struct Calculator
{
static double compute(double t) {
THelper th;
return th(t);
}

};

int main()
{
Calculator<double, Helper1<double c;
return 0;

}

Notice how I write twice 'double' in

Calculator<double, Helper1<double c;

If you're using a modern C++ compiler (VC7.1 or newer, gcc 3.4, etc)
you can use template template parameters. Here's what it will look
like:

template <typename T, template<typenameclass THelper>
struct Calculator
{
static double compute(double t) {
THelper<Tth;
return th(t);
}

};

int main()
{
Calculator<double, Helper1c;
double t = c.compute(5);
return 0;
}
Hope this helps!

--
Daniel

[Abhishek Padmanabh]

On Dec 10, 7:32 pm, mathieu <[e-mail]:

Hi there,

I guess this is a pretty vague question but I stumble on it a couple
of times and never really knew what was a nice solution to it. I am
trying to avoid passing twice a template parameter when it could be
either deduced or simple reused. For instance I have a calculator
class that take a simple helper function that perform an operation on
the same type as my calculator,.
I would write something like this:

template <typename T>
struct Helper1
{
inline double operator() (T t) { return t; }};

template <typename T>
struct Helper2
{
inline double operator() (T t) { return -t; }

};

template <typename T, typename THelper>
struct Calculator
{
static double compute(double t) {
THelper th;
return th(t);
}

};

int main()
{
Calculator<double, Helper1<double c;
return 0;

}

Notice how I write twice 'double' in

Calculator<double, Helper1<double c;

You can make THelper as a template template parameter to the
calculator template as below:

template <typename T, template<typenameclass THelper>
struct Calculator
{
static double compute(double t) {
THelper<Tth;
return th(t);
}
};

[mathieu]

On Dec 10, 4:58 pm, Abhishek Padmanabh <[e-mail]>
wrote:

On Dec 10, 7:32 pm, mathieu <[e-mail]:

Hi there,

I guess this is a pretty vague question but I stumble on it a couple
of times and never really knew what was a nice solution to it. I am
trying to avoid passing twice a template parameter when it could be
either deduced or simple reused. For instance I have a calculator
class that take a simple helper function that perform an operation on
the same type as my calculator,.
I would write something like this:

template <typename T>
struct Helper1
{
inline double operator() (T t) { return t; }};

template <typename T>
struct Helper2
{
inline double operator() (T t) { return -t; }

};

template <typename T, typename THelper>
struct Calculator
{
static double compute(double t) {
THelper th;
return th(t);
}

};

int main()
{
Calculator<double, Helper1<double c;
return 0;

}

Notice how I write twice 'double' in

Calculator<double, Helper1<double c;

You can make THelper as a template template parameter to the
calculator template as below:

template <typename T, template<typenameclass THelper>
struct Calculator
{
static double compute(double t) {
THelper<Tth;
return th(t);
}

};

Thanks ! I never used template template parameter before :)

pretty cool indeed !

-Mathieu