Question

首先，我已经阅读了许多其他问题，但无法找到解决方案。因此，在将其标记为重复之前，请确保重复回答问题。

我试图将F::operator()专门用于课程C2;但是，C2有一个模板参数，我希望F::operator()对所有C2的行为都相同。

编译错误：

error: invalid use of incomplete type ‘struct F<C2<T> >’ void F<C2<T>>::operator()()

此外，我尝试Handle& h而不是Handle* h，并收到了同样的错误。

#include<iostream>

struct C1
{
        void foo()
        {
                std::cout << "C1 called" << std::endl;
        }
};

template<typename T>
struct C2
{
        void bar();
};

template<>
void C2<int>::bar()
{
        std::cout << "C2<int> called" << std::endl;
}

template<typename Handle>
struct F
{
        F(Handle& h_) : h(h_) {}

        void operator()();

        Handle& h;
};

template<>
void F<C1>::operator()()
{
        h.foo();
}

template<typename T>
void F<C2<T>>::operator()()
{
        h.bar();
}

int main()
{
        C1 c1; 
        F<C1> f_c1 (c1);
        f_c1();

        C2<int> c2; 
        F<C2<int>> f_c2 (c2);
        f_c2();
}

Answer 1

没有像成员函数的部分特化那样的东西。您需要首先对整个班级进行部分专业化：

template <typename T>
struct F<C2<T>>
{
    void operator()();
};

template <typename T>
void F<C2<T>>::operator()() {}

由于这是一个重量级的解决方案，或者您可以利用标签分派：

template <typename T> struct tag {};

template <typename Handle>
struct F
{
    F(Handle& h_) : h(h_) {}

    void operator()()
    {
        call(tag<Handle>{});
    }

private:    
    void call(tag<C1>)
    {
        h.foo();
    }

    template <typename T>
    void call(tag<C2<T>>)
    {
        h.bar();
    }

    Handle& h;
};

DEMO

无效类型的使用无效（类方法专门化）

1 个答案: