c++ - 不同c++类之间运算符的简单实现

Question

是否有一种简单/智能的方法来实现缺少的运算符:‘operator+’ (operand types are ‘myclassRef<int>’ and ‘myclass<int>’)与这两个类？我知道我可以定义一个将这两种类型作为参数的函数。但是因为我正在实现几个应该同时使用 myclass 的函数和 myclassRef类型作为参数我想以一种简单的方式进行。

我一直在研究 myclassRef作为 myclass 的内部类并使用隐式转换，但是这种方法(据我所知)要求所有使用这两种类型作为参数的函数都是成员函数。

#include <iostream>
using namespace std;

template <class T>
struct myclass;

template <class T>
struct myclassRef
{
    T* i;

    myclassRef(myclass<T>* A)
    {
        i = &A->i;
    }

    operator myclass<T>()
    {
        return myclass<T>(*i);
    }

    T& get()
    {
        return *i;
    }
};

template <class T>
struct myclass
{
    T i;

    myclass() = default;
    myclass(const myclass&) = default;
    myclass(T _i) : i(_i) {}

    myclassRef<T> ref()
    {
        return myclassRef<T>(this);
    }

    T& get()
    {
        return i;
    }

    T get() const
    {
        return i;
    }
};

template <class T>
myclass<T>& operator+=(myclass<T>& lhs, const myclass<T>& rhs)
{
    lhs.get() += rhs.get();
    return lhs;
}

template <class T>
myclass<T> operator+(const myclass<T>& lhs, const myclass<T>& rhs)
{
    myclass<T> res(lhs);
    res += rhs;
    return res;
}

int main() {
    myclass<int> A(5);
    myclass<int> B(2);

    auto C = A + B;

    std::cout << C.i << std::endl;

    auto D = C.ref();

    A = D + B;

    return 0;
}

Answer 1

不需要使用内部类。相反，您应该构建两个 global 运算符，它们存在于两个类之外，如下所示:

T operator+(const myclassRef<int>&, const myclass<int>&)

和重载

T operator+(const myclass<int>&, const myclassRef<int>&)

T 是您决定的返回类型。如果这些函数中的任何一个都需要类中的私有(private)数据，则通过将这些声明放在类声明中，使这些函数成为您的两个类的 friend:

friend T operator+(const myclassRef<int>&, const myclass<int>&);
friend T operator+(const myclass<int>&, const myclassRef<int>&);

继续，您可能希望在 myclassRef 类型上创建这些函数模板，尽管只有更现代的编译器支持将模板函数设为友元。