C++ C++；将函数模板实例化为类成员并使用；这"；指针

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

这是否因为这个限制而不可能？或者是否有某种方法可以在未声明为模板类一部分的函数模板内部使用“this”。我做了一些研究，什么也没发现

逻辑

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
}

B类是相似的

感谢您的帮助

我相信你可以在这里使用。下面是一个示例，如果您可以仅使用公共成员进行比较，则可以省略

友元

声明：

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

模板
类比较器
{
公众：
T*比较（常数T&T）
{
//使用此指针
bool b=静态（this）->m_b==t.m_b；
返回NULL；
}
};
A类：公共比较器
{
公众：
友元类比较器；
A（）：m_b（0）
{
}
私人：
国际货币基金组织；
};
B类：公共比较器
{
公众：
友元类比较器；
B（）：m_B（0）
{
}
私人：
国际货币基金组织；
};
int main（）
{
A a1，a2；
A*p=a1。比较（a2）；
B b1，b2；
B*p1=b1。比较（b2）；
返回0；
}

您不能在非成员函数中使用此函数。您可以做的是创建模板函数并将其声明为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);

模板
布尔比较（常数T和t1，常数T和t2）
{
返回t1.val==t2.val；
}
甲级
{
公众：
模板
friend bool compare（常数T&，常数T&）；
布尔比较（常数A&A）
{
return:：compare（*this，a）；
}
私人：
int-val；
};
A a1，a2；
a1.比较（a2）；

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

但是（为什么）这些职能必须是成员？如果这些函数不需要访问这些类中的私有内容，那么让它们成为自由函数模板。整个STL（BTW，但是C++标准库的一部分）围绕非成员函数构建，并达到比以前任何OO容器库更高的抽象级别。 与人们的普遍看法相反：

如果您正在编写一个可以作为成员或非友元非成员实现的函数，那么您应该更愿意将其作为非成员函数实现。这个决定增加了类封装。当您考虑封装时，您应该考虑非成员函数

---

这是“函数模板”，而不是“模板函数”，因为这些东西不是函数，而是可以实例化函数的模板。“这些类在多态性上没有关联（这是很好的原因）。”-如果可以编写与它们兼容的成员函数，听起来它们应该有一个共同的基础。请注意，继承并不意味着多态性（例如私有继承）。为

比较器

提供一个受保护的非虚拟析构函数非常有用。

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