Question

我在编程课程中需要重载向我解释。简单的问题，希望我会很快得到答案。我的理解是重载操作符允许它在类上使用。如果这是真的，那么我将如何重载＆gt;＆gt;和班级一起工作？我正在制作一个小程序来测试这个想法，我会在这里发布

#include <iostream>
#include <cstdlib>
#include "data.h"

using namespace std;

int main() 
{
    data obj;

    cout << "What is the Number?" << endl;
    cin >> obj;
    system("pause");
    return 0;
}

class data
{
    public:
    data operator >> (int);

    private:

};

Answer 1

case1：无需访问私人数据

data.h.

class data {
  public:
    int i;
};

std::ostream& operator>> (std::istream&, data&); // better make operator >>
                                                 // a nonmember function 
                                                 // if it doesn't need access
                                                 // to private data

data.cpp

#include "data.h"

std::istream& operator>> (std::istream& is, data& d) {
  is>>d.i;    // here we do some logic, we do what it means to do >> on
  return is;  // an instance of your data class and return reference to istream
}

案例2：需要访问私人数据

data.h.

class data {
  private:
    int i;
  friend std::ostream& operator>> (std::istream&, data&);
};

data.cpp

#include "data.h"

std::istream& operator>> (std::istream& is, data& d) {
  is>>d.i;    // here we do some logic, we do what it means to do >> on
  return is;  // an instance of your data class and return reference to istream
}

Answer 2

This page告诉您关于运算符重载的大部分内容。

简而言之，几乎C ++中的每个运算符都可以为用户定义的类型重载。一些运算符，例如+， - 或＆gt;＆gt;必须在类之外定义，因为它们是独立的，而其他像复制赋值（=），必须在其中定义。

对于您的情况，重载＆gt;＆gt;运算符可以通过以下方式完成：

istream& operator>>(istream& in, data& d){
    // Code here
    return in;
}

如果显示“此处为代码”，请将您需要阅读的代码放入数据对象中。

例如，让我们假装我们正在读入具有x坐标和y坐标的Point对象。它在流中的格式如下：“（x，y）”。运算符重载可能如下所示：

istream& operator>>(istream& in, Point& p){
    char c;
    in >> c;
    if(c != '('){
        in.clear(ios_base::failbit);
        return in;
    }
    in >> p.x >> c >> p.y >> c;
    return in;
}

这只是一个最小格式检查的例子，但希望它足以让你开始。

请注意，如果您的类中的成员是私有的，那么您应该在类定义中使用istream运算符：

class data{
    ...
public:
    friend istream& operator>>(istream&, data&);
}

Answer 3

如果你想加强对运算符重载的理解，请考虑基本上对象上的所有运算符（例如“+”，“+”，“==”，“！=”等）都是成员函数

挑战自己，将Obj a, b; a = b;识别为Obj a; Obj b; a.operator=(b);。

重载纯粹是提供非默认实现。

这是cast-to-const-char *运算符的[可怕]重载：

class BadWolf {
    const char* m_text;
public:
    BadWolf(const char* text) : m_text(text) {}

    // if you really want the original text and ask for it with this function...
    const char* tardisTranslation() const { return m_text; }

    // but if you try to use me as a const char*...
    operator const char* () const { return "bad wolf"; }
};

int main(int argc, const char* argv[]) {
    BadWolf message("hello, sweetie");

    std::cout << "Message reads: " << (const char*)message << std::endl;
    std::cout << "Tardis translation: " << message.tardisTranslaction() << std::endl;

    return 0;
}

Answer 4

我认为这就是你想要的。

class data
{
    friend istream& operator>>( istream&, data& );

    private:
        int data;
};

istream& operator>>( istream& in, data& d )
{
    return in >> d.data;
}

重载运算符以进行编程练习

4 个答案: