469,927 Members | 1,888 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 469,927 developers. It's quick & easy.

Partially specialize a function template

Hi there,

I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).

template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }

Thanks !
Jun 27 '08 #1
7 1736
On May 15, 12:48 pm, mathieu <mathieu.malate...@gmail.comwrote:
Hi there,

I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).

template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }

Thanks !
Ok found a solution:

http://www.gotw.ca/publications/mill17.htm

....
// Example 4: Illustrating Moral #2
//
template<class T>
struct FImpl;

template<class T>
void f( T t ) { FImpl<T>::f( t ); } // users, don't touch this!

template<class T>
struct FImpl
{
static void f( T t ); // users, go ahead and specialize this
};
....

Sorry for the noise
-M
Jun 27 '08 #2
On May 15, 1:21 pm, mathieu <mathieu.malate...@gmail.comwrote:
On May 15, 12:48 pm, mathieu <mathieu.malate...@gmail.comwrote:
Hi there,
I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).
template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }
Thanks !

Ok found a solution:

http://www.gotw.ca/publications/mill17.htm

...
// Example 4: Illustrating Moral #2
//
template<class T>
struct FImpl;

template<class T>
void f( T t ) { FImpl<T>::f( t ); } // users, don't touch this!

template<class T>
struct FImpl
{
static void f( T t ); // users, go ahead and specialize this};

...

Sorry for the noise
-M
For reference:

template<typename TOut, typename TIn>
struct FImpl;

template<typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ FImpl<TOut,TIn>::InverseRescaleFunction(out,in,int ercept,slope,size); } //
users, don't touch this!

template<typename TOut, typename TIn>
struct FImpl
{
static void InverseRescaleFunction( TOut *out, const TIn *in,
double intercept, double slope, size_t size) // users, go ahead
and specialize this
{
....
}
};

template<typename TOut>
struct FImpl<TOut, float>
{
static void InverseRescaleFunction(TOut *out, const float *in,
double intercept, double slope, size_t size)
{
....
}
};

-M
Jun 27 '08 #3
On May 15, 3:48*am, mathieu <mathieu.malate...@gmail.comwrote:
>
* I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).

template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }
I'm wondering how you happen to know that the above pair of function
declarations is not possible in C++? Did you try using them in a C++
program? For example:

#include <iostream>

template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{
std::cout << "InverseRescaleFunction<TOut, TIn>\n";
}

template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{
std::cout << "InverseRescaleFunction<TOut>\n";
}

int main()
{
float f = 139.4;
int i;
long o;

InverseRescaleFunction(&i, &o, 2.2, 3.3, 4);
InverseRescaleFunction(&i, &f, 2.2, 3.3, 4);
}

Did your version of the above program fail to compile or did it
compile, run and produce the expected output shown below - as it did
on my machine?

Program Output:

InverseRescaleFunction<TOut, TIn>
InverseRescaleFunction<TOut>

Greg

Jun 27 '08 #4
On May 15, 1:32 pm, Greg Herlihy <gre...@mac.comwrote:
On May 15, 3:48 am, mathieu <mathieu.malate...@gmail.comwrote:
I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).
template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }

I'm wondering how you happen to know that the above pair of function
declarations is not possible in C++? Did you try using them in a C++
program? For example:

#include <iostream>

template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{
std::cout << "InverseRescaleFunction<TOut, TIn>\n";
}

template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{
std::cout << "InverseRescaleFunction<TOut>\n";
}

int main()
{
float f = 139.4;
int i;
long o;

InverseRescaleFunction(&i, &o, 2.2, 3.3, 4);
InverseRescaleFunction(&i, &f, 2.2, 3.3, 4);
}

Did your version of the above program fail to compile or did it
compile, run and produce the expected output shown below - as it did
on my machine?

Program Output:

InverseRescaleFunction<TOut, TIn>
InverseRescaleFunction<TOut>
Hi Greg

Indeed I tried your example and it actually produce the expected
results. However my full code, available at:

http://gdcm.svn.sourceforge.net/view...r.cxx?view=log

Did not work as expected. The only difference is that there was an
extra level of indirection. I'll work on your example to try to
reproduce the issue I was having with version 3163:

http://gdcm.svn.sourceforge.net/view...63&view=markup

Thanks
-Mathieu

Jun 27 '08 #5
On May 15, 7:48*am, mathieu <mathieu.malate...@gmail.comwrote:
Hi there,

* I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).

template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }

Hi Mathieu.

You're correct that partial specialization of functions is not allowed
in C++. However, in this case you have actually overloaded the
function - that's why it should work. An example of what would be a
partial specialization of your function (that is not allowed) would
look like this:

template <typename TOut>
void InverseRescaleFunction<float>(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }
--
Leandro T. C. Melo


Jun 27 '08 #6
On May 15, 9:34*am, ltcmelo <ltcm...@gmail.comwrote:
On May 15, 7:48*am, mathieu <mathieu.malate...@gmail.comwrote:
Hi there,
* I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).
template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }

Hi Mathieu.

You're correct that partial specialization of functions is not allowed
in C++. However, in this case you have actually overloaded the
function - that's why it should work. An example of what would be a
partial specialization of your function (that is not allowed) would
look like this:

template <typename TOut>
void InverseRescaleFunction<float>(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }

Just a fix... it would look like this:

template <typename TOut>
void InverseRescaleFunction<TOut, float>(TOut *out, const float *in,
double
intercept, double slope, size_t size)
{ ... }

--
Leandro T. C. Melo
Jun 27 '08 #7
On May 15, 5:22*am, mathieu <mathieu.malate...@gmail.comwrote:
On May 15, 1:32 pm, Greg Herlihy <gre...@mac.comwrote:
On May 15, 3:48 am, mathieu <mathieu.malate...@gmail.comwrote:
* I know this is not possible in c++. So my question, how should I
rewrite the following piece of code (without using a dummy class which
template parameter could be use for partial specialization).
template <typename TOut, typename TIn>
void InverseRescaleFunction(TOut *out, const TIn *in, double
intercept, double slope, size_t size)
{ ... }
template <typename TOut>
void InverseRescaleFunction(TOut *out, const float *in, double
intercept, double slope, size_t size)
{ ... }
I'm wondering how you happen to know that the above pair of function
declarations is not possible in C++? Did you try using them in a C++
program? For example:
* * #include <iostream>
* * template <typename TOut, typename TIn>
* * void InverseRescaleFunction(TOut *out, const TIn *in, double
* * intercept, double slope, size_t size)
* * {
* * * * std::cout << "InverseRescaleFunction<TOut, TIn>\n";
* * }
* * template <typename TOut>
* * void InverseRescaleFunction(TOut *out, const float *in, double
* * intercept, double slope, size_t size)
* * {
* * * * std::cout << "InverseRescaleFunction<TOut>\n";
* * }
* * int main()
* * {
* * * * float f = 139.4;
* * * * int i;
* * * * long o;
* * * * InverseRescaleFunction(&i, &o, 2.2, 3.3, 4);
* * * * InverseRescaleFunction(&i, &f, 2.2, 3.3, 4);
* * }
Did your version of the above program fail to compile or did it
compile, run and produce the expected output shown below - as it did
on my machine?
* * Program Output:
* * InverseRescaleFunction<TOut, TIn>
* * InverseRescaleFunction<TOut>

Hi Greg

* Indeed I tried your example and it actually produce the expected
results. However my full code, available at:

http://gdcm.svn.sourceforge.net/view...e/MediaStorage...

* Did not work as expected. The only difference is that there was an
extra level of indirection. I'll work on your example to try to
reproduce the issue I was having with version 3163:

http://gdcm.svn.sourceforge.net/view...e/MediaStorage...
It is true that a function template cannot be partially specialized in
C++. But there is little reason why a C++ program would ever need to.
A C++ program can always overload a function with more than one
function template (just like the two function templates in your
original example overload the "InverseRescaleFunction" function). And
whenever multiple function templates overload the same function, the C+
+ compiler applies the rules of "partial ordering" to select the best
function template to match a particular function call.

So I do not think any particularly clever techniques are needed in
this situation. Simply declare the function templates that are needed
- and let the C++ compiler pick the best one to call.

Greg

Jun 27 '08 #8

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

3 posts views Thread by PengYu.UT | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.