Question

我有两个类（ClassA和ClassB），它们都有两个方法（比较和收敛）。这些方法的工作方式完全相同，但这些类并不是多态相关的（有充分理由）。我想定义一个函数模板，这两个类都可以显式实例化为成员，但我得到错误，因为方法使用“this”，当我把它们变成模板时，编译器会抛出错误，因为它们不是成员职能。

这是不可能的，因为这个限制？或者是否有一些方法可以在未声明为模板类一部分的函数模板中使用“this”。我做了一些研究，一无所获。

Logic.h

template <class T>
T* compare(const T& t) {
//stuff involving this
}

template <class T>
T* converge(const T& t,bool b) {
//other stuff involving this
}

ClassA.cpp

#include "ClassA.h"
#include "Logic.h"
//constructors

template ClassA* ClassA::compare(const ClassA& t) const; 
template ClassA* ClassA::converge(const ClassA& t,bool b) const;
//other methods

classB类似。

感谢任何帮助！

Answer 1

我相信你可以在这里使用CRTP。下面是一个示例，您可以省略friend声明，以防您只使用公共成员进行比较：

template<class T>
class comparer
{
public:
    T* compare(const T& t)
    {
        //Use this pointer
        bool  b =  static_cast<T*>(this)->m_b  == t.m_b;
        return NULL;
    }
};

class A : public comparer<A>
{
public:
    friend class comparer<A>;
    A() : m_b(0)
    {
    }

private:
    int m_b;
};

class B : public comparer<B>
{
public:
    friend class comparer<B>;
    B() : m_b(0)
    {
    }

private:
    int m_b;
};

int main()
{
    A a1,a2;
    A* p = a1.compare(a2);

    B b1,b2;
    B* p1 = b1.compare(b2);

    return 0;
}

Answer 2

你不能在非成员函数中使用它。你可以做的是创建模板函数并将其声明为classA和classB的朋友。但是模板函数访问的classA和classB成员必须具有相同的名称。

template <typename T>
bool compare(const T& t1, const T& t2)
{
    return t1.val == t2.val;
}

class A
{
public:
    template <typename T>
    friend bool compare(const T&, const T&);

    bool compare(const A& a)
    {
        return ::compare(*this, a);
    }

private:
    int val;
};

A a1, a2;
a1.compare(a2);

Answer 3

你想要的是不可能的。必须声明成员函数并将其定义为成员。成员函数模板也是如此，可以从中实例化成员函数。

但是（为什么）这些功能必须是会员？如果这些函数不需要访问这些类中的私有东西，请将它们作为自由函数模板。整个STL（BTW，只是C ++标准库的一部分）是围绕非成员函数构建的，并且实现了比之前任何OO容器库更高级别的抽象。
与流行的相信相反，non-member functions generally increase encapsulation：

如果您正在编写可以作为成员或非朋友非成员实现的函数，则应该优先将其实现为非成员函数。该决定增加了类封装。当你考虑封装时，你应该考虑非成员函数。

C ++将函数模板实例化为类成员并使用“this”指针

3 个答案: