C++ Templated function specialization with template - c++

Question

I have a templated function meant to work with STL containers. However, I'd like to specialize this function for a templated class. How might I go about doing this? I'm stuck on C++11.
Edit: Updated code example. It appears to work when F is a POD like int, but is broken in the below code example where F is a class.
#include <vector>
#include <iostream>
template <class F>
class Temp {
private:
F f;
public:
Temp(F f) : f(f) {}
};
template <typename C, typename F>
struct MyClass {
MyClass (const C& c, const F& f) { }
operator C() const
{ return {}; }
};
// Base Template Function
template <typename C, typename F>
MyClass<C, F> operator| (const C & left, const F & right)
{
std::cout << "Generic version" << std::endl;
return MyClass<C, F>(left, right);
}
// Overload that I tried (ignored and used base template function instead)
template <typename C, typename F>
MyClass<C, F> operator| (const MyClass<C, F> & left, const F & right)
{
std::cout << "MyClass overload" << std::endl;
return MyClass<C, F>(C(left), right);
}
template <class F>
Temp<F> filter(F f) {
return Temp<F>(f);
}
int main ()
{
std::vector<int> v0 = { 1, 2, 3 };
auto m0 = v0
| filter([] (int i) {return i > 0;});
auto m1 = m0
| filter([] (int i) {return i < 3;});
return 0;
}
The above code example prints Generic version twice.

Answer 1

You can't partially specialize a template function.
But your overload should works.
I've modified your MyClass class to make it compile but, in the following example, the overload version is in charge.
#include <iostream>
template <typename C, typename F>
struct MyClass
{
template <typename ... Ts>
MyClass (Ts const & ...)
{ }
operator C() const
{ return {}; }
};
/* Base Template Function */
template <typename C, typename F>
MyClass<C, F> operator| (C const & left, F const & right)
{
std::cout << "Generic version" << std::endl;
return MyClass<C, F>(left, right);
}
/* Overload that I tried (ignored and used base template function instead) */
template <typename C, typename F>
MyClass<C, F> operator| (MyClass<C, F> const & left, F const & right)
{
std::cout << "MyClass overload" << std::endl;
return MyClass<C, F>(C(left), right);
}
int main ()
{
MyClass<int, int> m0;
auto x = m0 | 0;
static_assert( std::is_same_v<decltype(x), MyClass<int, int>>, "!" );
}