0

我想做类似的事情：

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 的类型。

4

2 回答 2

2

自由函数是正确答案。无论如何，你应该更喜欢自由函数而不是成员函数，因为这个确切的原因：你扩展接口而不侵入类。

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

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);
}

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

于 2012-08-23T02:20:27.170 回答
1

这是一个使用自由函数并保留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();
}
于 2012-08-23T02:49:33.703 回答