Hallo!
I would like to specialise only one of two template types. E.g. template <typename A, typename B> class X
should have a special implementation for a single function X<float, sometype>::someFunc()
.
Sample code:
main.h:
#include <iostream>
template <typename F, typename I>
class B
{
public:
void someFunc()
{
std::cout << "normal" << std::endl;
};
void someFuncNotSpecial()
{
std::cout << "normal" << std::endl;
};
};
template <typename I>
void B<float, I>::someFunc();
main.cpp:
#include <iostream>
#include "main.h"
using namespace std;
template <typename I>
void B<float, I>::someFunc()
{
cout << "special" << endl;
}
int main(int argc, char *argv[])
{
B<int, int> b1;
b1.someFunc();
b1.someFuncNotSpecial();
B<float, int> b2;
b2.someFunc();
b2.someFuncNotSpecial();
}
Compilation fails for class B
. Is it true, that this is not possible in C++ in this way? What would be the best workaround?
[edit]
template <float, typename I>
void B<float, I>::someFunc();
leads to
main.h:26: error: ‘float’ is not a valid type for a template constant parameter
template <typename I>
void B<float, I>::someFunc();
leads to
main.h:27: error: invalid use of incomplete type ‘class B’
And I'm using gcc.
[edit]
I don't want to specialise the whole class, as there are other functions that don't have a specialisation.
C++ Class Template with multiple parameters You can also use multiple parameters in your class template.
Explanation: The template class can support more than one data type. The only thing is to add all the data types required in a list separated by comma within template specification. 2. Which among the following is the proper syntax for the template class?
Key differences between generics and C++ templates: Generics are generic until the types are substituted for them at runtime. Templates are specialized at compile time so they are not still parameterized types at runtime. The common language runtime specifically supports generics in MSIL.
A template argument for a template template parameter is the name of a class template. When the compiler tries to find a template to match the template template argument, it only considers primary class templates. (A primary template is the template that is being specialized.)
You have to provide a partial specialization of the class template B
:
template <typename I>
class B<float, I>
{
public:
void someFunc();
};
template <typename I>
void B<float, I>::someFunc()
{
...
}
You can also just define someFunc
inside the specialization.
However, if you only want to specialize a function, and not a class do e. g.
template <typename F, typename I>
void someFunc(F f, I i) { someFuncImpl::act(f, i); }
template <typename F, typename I>
struct someFuncImpl { static void act(F f, I i) { ... } };
// Partial specialization
template <typename I>
struct someFuncImpl<float, I> { static void act(float f, I i) { ... } };
But you can't specialize a function template without this trick.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With