Template instantiation help needed

[Jim West]

I have a template class (for numerical processing) that was originally
written for real data that I need to extend to complex data, and I am
running into a problem. The current version (greatly simplified) has
something like

template <class T>
class FOO {
T A;
T B;
};

which works fine with T as any floating point type (float, double, etc.).
With complex data however, I would want A to be type complex<T> and B to
be type T. As the operations are identical for both real and complex
data (B represents the absolute value/magnitude of type of A) and the
actual template is quite large, I want to use the same template for both.
The obvious solution is to rewrite it as

template <class DATA, class ABS_TYPE>
class FOO {
DATA A;
ABS_TYPE B;
}

which can be instantiated with FOO<float, float>,
FOO<complex<dou ble>, double>, etc., but that would break existing code
and add a possibility for error (FOO<complex<do uble>, float> would be
a disasterous loss of precision). Is there a way to get a template
to recognize automatically that B should be type T when A is instantiated
as either T or complex<T>?

[Rob Williscroft]

Jim West wrote in
news:sl******** *************** ***@jwest.ecen. okstate.edu:

[snip]

template <class T>
class FOO {
T A;
T B;
};

which works fine with T as any floating point type (float, double,
etc.). With complex data however, I would want A to be type complex<T>
and B to be type T. As the operations are identical for both real and
complex data (B represents the absolute value/magnitude of type of A)
and the actual template is quite large, I want to use the same
template for both. The obvious solution is to rewrite it as

template <class DATA, class ABS_TYPE>
class FOO {
DATA A;
ABS_TYPE B;
}

which can be instantiated with FOO<float, float>,
FOO<complex<dou ble>, double>, etc., but that would break existing code
and add a possibility for error (FOO<complex<do uble>, float> would be
a disasterous loss of precision). Is there a way to get a template to
recognize automatically that B should be type T when A is instantiated
as either T or complex<T>?

template < typename T >
struct extract_real
{
typedef T type;
};

template < typename T >
struct extract_real< std::complex< T > >
{
typedef T type;
};

template < typename T >
class FOO
{
T A;
typename extract_real< T >::type B;
};

HTH

Rob. -- http://www.victim-prime.dsl.pipex.com/

[Jim West]

In article <Xn************ *************** *******@195.129 .110.131>, Rob Williscroft wrote:

<solution to my problem snipped>

Worked perfectly, of course. I never, ever would have come up with that.
Thank you for the help!