c++ - 如何在不更改类模板的情况下为模板类的模板方法添加第二种类型？

Question

我有一个模板类

template <typename S>
class Foo {

   template <typename T>
   T Bar();

}

如何更改 Bar 以便在不更改类模板类型的情况下按如下方式使用它？

Foo<int> f;
f.Bar<int,MyType>();

在这里，int 是 Foo 的类型，而 MyType 只是另一种类型，可以在其实例类型之上更改 Bar() 行为。

这没有按预期工作:

template <typename S>
template <typename T>
T Foo<S>::Bar()
{
    // logic with T t
}

但这行得通:

template <typename S>
template <typename T>
T Foo<S>::Bar(T * dummyNullPointer)
{
    // logic with T t
}

是否有一个简洁的版本而不是下面的代码？

f.Bar<int>((float *)0);

最好是

f.Bar<int,MyType>();

或

f.Bar<MyType>(); // better, but expects int for example and gives error

---

编辑:实际用法是

void SomeClass<SomeType>::SomeMethod(SomeType1<SomeType> p)
{
      Something something = p.SomeWork<Something>(); // does not work
}

Answer 1

您不能特化非特化类的成员函数。这只是语言限制。

如果你准备专门化这个类(class)，你可以这样做:

#include <iostream>
#include <tuple>

template <typename S>
struct Foo {

    template <typename T>
    T Bar();

};

template <typename S>
template <typename T>
T Foo<S>::Bar()
{
    std::cout << "usual thing" << std::endl;
    return T();
}

struct MyType {};

template<> template<>
std::tuple<int, MyType> Foo<int>::Bar<std::tuple<int, MyType>>()
{
    std::cout << "my thing" << std::endl;
    return std::tuple<int, MyType> { 1, {} };
};


int main()
{
    auto f = Foo<int>();
    auto x = f.Bar<int>();
    auto y = f.Bar<std::tuple<int, MyType>>();
}

如果不是，那么您将不得不让您的成员函数遵循可以部分特化的函数对象:

#include <iostream>
#include <tuple>


// general case
template<class S, class T, class...Ts>
struct BarOp;

template <typename S>
struct Foo {

    template <typename...Ts>
    auto Bar() -> decltype(auto)
    {
        auto op = BarOp<Foo<S>, Ts...>();
        return op(this);
    }

};

// general case of single T
template<class S, class T>
struct BarOp<S, T>
{
    auto operator()(S* p) const
    {
        std::cout << "usual thing" << std::endl;
        return T();
    }
};


struct MyType {};

// now partially specialise for T, MyTyoe
template<class S, class T>
struct BarOp<S, T, MyType>
{
    auto operator()(S* p) const
    {
        std::cout << "other thing" << std::endl;
        return T(10);
    }
};

int main()
{
    auto f = Foo<int>();
    auto x = f.Bar<int>();
    auto y = f.Bar<int, MyType>();
}

预期输出:

usual thing
other thing