重载操作符编程练习

Question

我在编程类，需要重载解释给我。简单的问题，希望我能很快得到答案。我的理解是，重载一个操作符允许它在一个类上使用。如果那是真的，那么我将如何超载>>与班级一起工作？我工作的一个小程序来测试这个想法，我会后在这里

#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

我想这是你想要的。

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

    private: 
     int data; 
}; 

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

Answer 2

案例1：不需要访问私人数据

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 3

This page告诉你，主要是你需要知道的关于运算符重载的一切。

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

对于你的情况，超载>>操作员可以通过以下方式来完成：

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 4

如果你想支持你的什么操作符重载是理解，认为基本上所有对象（如“+”，“++”，“==”，“！=”等）的运算符是成员函数。

挑战自己，认出Obj a, b; a = b;为Obj a; Obj b; a.operator=(b);。

重载纯粹是提供了一个非默认的实现。

这里是投给const-字符*运营商的[可怕]超载：

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