Question

我想做点什么：

class A {
  public:
    void f();
  private:
    void g() { };
};

class B {
  public:
    void f();
  private:
    void g() { };
};

template<typename T>
void T::f() {
    g();
}

int main() {
    A a;
    B b;
    a.f();
    b.f();
}

但是T :: f（）不能编译。

可能的解决方法可能是使f（）非成员：

template<typename T>
void f(T* t);

或使用CRTP：http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

但是上面没有C ++语法吗？

编辑：我有一个很大的函数f（），其代码由2个类A和B共享.A和B具有相同的接口，f（）使用它。但是，因为我们没有使用运行时多向性（即虚函数），所以f（）的语料库需要在编译时实例化两次，一次用于A，一次用于B.模板完全用于此目的。在我的例子中，函数f（）应该是模板函数，其模板类型是* this的类型。

Answer 1

自由功能是正确的答案。无论如何，你应该更喜欢自由函数而不是成员函数，原因如下：扩展接口而不会干扰类。

在这种情况下，带有无约束模板的自由函数有点难看，因为你只需要它来处理两种情况，而不是所有情况。你应该这样做：

namespace detail
{
    template <typename T>
    void f(T* t)
    {
        // implement stuff
    }
}

void f(A* x)
{
    detail::f(x);
}

void f(B* x)
{
    detail::f(x);
}

现在您可以通过重载来限制对该功能的访问。

Answer 2

以下是使用自由函数并保留instance.f()语法的示例。该函数需要标记为朋友才能访问私有方法：

#include <iostream>

namespace details
{
    template<class T>
    static void f_impl(T* _this)
    {
        _this->g();
    }
}

class A {
public:
    template<class T> friend void details::f_impl(T*);
    void f()
    {
        details::f_impl(this);
    }
private:
    void g()
    {
        std::cout << "A" << std::endl;
    }
};

class B {
public:
    template<class T> friend void details::f_impl(T*);
    void f()
    {
        details::f_impl(this);
    }
private:
    void g()
    {
        std::cout << "B" << std::endl;
    }
};

int main() {
    A a;
    B b;
    a.f();
    b.f();
}

非模板类T的模板成员函数（在类型T上）

2 个答案: