结构指针的运算符重载

Question

我正在尝试使用运算符重载来比较两个动态分配的结构指针。 据我了解，运算符重载应该使用按引用传递，所以这是否意味着无法重载==运算符来实现此特定目标？

目的是打印出成功而不用编辑main（）中的代码

#include <iostream>


struct VAR
{
    int x;

VAR()
{
    x = 0;
}

VAR(int val)
{
    x = val;
}

bool operator==(VAR &lhs)
{
    std::cout << "operator called\n";
    return (x == lhs.x);
}

bool operator==(VAR *lhs)
{
    std::cout << "ptr operator called\n";
    return (x == lhs->x);
}
};

int main()
{
    VAR *v1 = new VAR(5);
    VAR *v2 = new VAR(5);

    if (v1 == v2)
        std::cout << "Success\n";
    else
        std::cout << "Fail\n";

    delete v1;
    delete v2;

    v1 = nullptr;
    v2 = nullptr;

    system("pause");
    return 0;
}

Answer 1

考虑以下代码，与您的代码几乎相同，但没有指针：

VAR v1(5);
VAR v2(5);

if (v1 == v2) { ... }

该条件实际上由编译器处理为

if (v1.operator==(v2)) { ... }

当您将v1转换为指针时，编译器不会自动取消引用该指针，即不会

v1->operator==(v2)

简单的解决方案是自己取消引用指针：

*v1 == *v2

Answer 2

为了完成其他答案，这是C ++标准的一部分，该部分明确禁止使用两个指针的操作符重载（强调我的意思）：

运算符应为非静态成员函数或具有至少一个参数的非成员函数，该参数的类型为类，对类的引用，枚举或对枚举的引用。 不能更改运算符的优先级，分组或操作数的数量。 通过定义实现这些运算符的运算符功能，可以为特定的类和枚举类型更改为每种类型预定义的运算符=，（一元）和＆和（逗号）的含义。 运算符函数的继承方式与其他基类函数相同。

[over.oper] / 6

这就解释了为什么不更改main函数中的代码就不能使用重载的operator== 。

Answer 3

==运算符的常见实现是

bool operator==(const VAR & lhs)

即使将点分配给VAR对象，也可以使用*运算符“调用” ==运算符。

VAR *v1 = new VAR(5);
VAR *v2 = new VAR(5);

if (*v1 == *v2)
    std::cout << "Success\n";
else
    std::cout << "Fail\n";

Answer 4

您的==比较两个指针。 指针是原始类型， 无论它们指向什么 ，并且当所有操作数都是原始类型时 ， 您不能重载运算符 。

换句话说：如果左操作数是VAR而不是VAR*则重载的运算符将起作用。

当然，您的代码无论如何也不能成为使用指针或动态内存分配的令人信服的观点。 只需删除所有内容：

int main()
{
    VAR v1(5);
    VAR v2(5);

    if (v1 == v2)
        std::cout << "Success\n";
    else
        std::cout << "Fail\n";
}

这样，您也不再需要第二个运算符。 为了完整起见，您可以这样调用它：

int main()
{
    VAR v1(5);
    VAR v2(5);

    if (v1 == &v2)
        std::cout << "Success\n";
    else
        std::cout << "Fail\n";
}

Answer 5

#include <iostream>


struct VAR
{
    int x;

VAR()
{
    x = 0;
}

VAR(int val)
{
    x = val;
}

bool operator==(VAR &lhs)
{
    std::cout << "operator called\n";
    return (x == lhs.x);
}

bool operator==(VAR *lhs)
{
    std::cout << "ptr operator called\n";
    return (x == lhs->x);
}
};

int main()
{
    VAR *v1 = new VAR(5);
    VAR *v2 = new VAR(5);

   if (v1->operator==(v2))
       std::cout << "Success\n";
    else
        std::cout << "Fail\n";

    delete v1;
    delete v2;

    v1 = nullptr;
    v2 = nullptr;


    return 0;
}