是否可以覆盖 C++ 中的运算符？如果答案是肯定的，范围是多少？ [关闭]

Posted 2023-02-21

【中文标题】是否可以覆盖 C++ 中的运算符？如果答案是肯定的，范围是多少？ [关闭]

【英文标题】：Is it possible to override operators in C++? If the answer is yes, what's the scope? [closed]

【发布时间】：2021-04-18 19:44:10

【问题描述】：

我尝试覆盖 - 运算符，但出现错误。如何解决这个错误，它是做什么用的？

#pragma once

class Resurse

protected:
    unsigned int _cantitate;
public:
    Resurse() 
    Resurse(unsigned int cantitate) :_cantitate(cantitate) 
    ~Resurse() 
    Resurse(Resurse&& r)
    
        _cantitate = r._cantitate;
        r._cantitate = 0;
    

    virtual Resurse* operator-(Resurse* r)
    
        Resurse* result=new Resurse(this->_cantitate - r->_cantitate);
        return result;
    

    unsigned int GetCantitate()  return _cantitate; 
;

#pragma once
#include "Resurse.h"

class Hrana:public Resurse

public:
    Hrana() 
    Hrana(unsigned int cantitate) :Resurse(cantitate) 
    ~Hrana() 
    Hrana(Hrana&& h)  _cantitate = h._cantitate; h._cantitate = 0; 

    Resurse* operator-(Resurse* r)
    
        Resurse* result = new Hrana(this->_cantitate - r->GetCantitate());
        return result;
    
;

void main()

    Resurse* hrana1 = new Hrana(20);
    Resurse* hrana2 = new Hrana(17);
    Resurse* result = hrana1 - hrana2;
    system("pause");

【问题讨论】：

哪个operator-？有两种：否定（一个参数）和减法（两个参数）。参数的数量取决于函数是否独立。

是的，减号运算符

这能回答你的问题吗？ What are the basic rules and idioms for operator overloading?

谢谢你，但我试图超越而不是超载

不，这里没有什么需要指针。这个问题被称为“指针的无用使用”，是Java背景想学习C++的人的通病。问题是 C++ 不是 Java，而且 C++ 对象以根本不同的方式工作。所示代码中的任何内容都不需要使用指针，没有指针，一切都会变得简单十倍。

【参考方案1】：

是的，可以重载（而不是覆盖）运算符。但是，问题是，您没有正确执行。

您试图在 Resurce* 指针上调用 operator-，而不是在 Resurce 对象上。您的operator- 需要将Resurce 对象按值/引用 作为输入，而不是按指针。并在输出时返回一个新的Resurce 对象按值，而不是按指针。见What are the basic rules and idioms for operator overloading?

在您的main() 中，您需要在调用operator- 之前取消引用指针。

试试这个：

Resurse operator-(const Resurse &r) const

    return Resurse(_cantitate - r._cantitate);

int main()

    Resurse* hrana1 = new Resurse(20);
    Resurse* hrana2 = new Resurse(17);
    Resurse result = *hrana1 - *hrana2;
    std::system("pause");
    delete hrana2;
    delete hrana1;

或者，完全摆脱指针，你真的不需要它们：

int main()

    Resurse hrana1(20);
    Resurse hrana2(17);
    Resurse result = hrana1 - hrana2;
    std::system("pause");

---

更新：我刚刚意识到您正在尝试实现多态 operator-。那是行不通的，主要是因为object slicing 在返回值上，还因为你不能为指针重载运算符。

我建议使用单独的虚拟方法而不是operator-，例如：

#pragma once
#include <memory>

class Resurse

protected:
    unsigned int _cantitate;
public:
    Resurse(unsigned int cantitate = 0) : _cantitate(cantitate) 
    virtual ~Resurse() 

    Resurse(const Resurse&) = default;
    Resurse(Resurse&& r)
    
        _cantitate = r._cantitate;
        r._cantitate = 0;
    

    virtual std::unique_ptr<Resurse> subtract(const Resurse &r) const
    
        return std::make_unique<Resurse>(_cantitate - r.GetCantitate());
    

    unsigned int GetCantitate() const  return _cantitate; 
;

#pragma once
#include "Resurse.h"
#include <memory>
#include <cstdlib>

class Hrana : public Resurse

public:
    Hrana(unsigned int cantitate = 0) : Resurse(cantitate) 

    Hrana(const Hrana& h) = default;
    Hrana(Hrana&& h) : Resurse(std::move(h)) 

    std::unique_ptr<Resurse> subtract(const Resurse &r) const override
    
        return std::make_unique<Hrana>(_cantitate - r.GetCantitate());
    
;

void main()

    std::unique_ptr<Resurse> hrana1 = std::make_unique<Hrana>(20);
    std::unique_ptr<Resurse> hrana2 = std::make_unique<Hrana>(17);
    auto result = hrana1->subtract(*hrana2);
    std::system("pause");

【讨论】：

非常感谢

你能告诉我这个例子的用途或范围吗？

对我来说是强制性的，但我看不到逻辑