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 ! 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
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
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
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
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
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
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 This discussion thread is closed Replies have been disabled for this discussion. Similar topics
4 posts
views
Thread by Old Wolf 
last post: by

1 post
views
Thread by mrstephengross 
last post: by

1 post
views
Thread by sebastian 
last post: by

3 posts
views
Thread by PengYu.UT 
last post: by

3 posts
views
Thread by toton 
last post: by

16 posts
views
Thread by PengYu.UT 
last post: by

8 posts
views
Thread by Rahul 
last post: by

5 posts
views
Thread by huili80 
last post: by
          