C++ 运算符重载输入运算符 >> 以 class 之外的对象作为成员

Question

这是家庭作业——我在为 Customer.h 文件定义输入 >> 运算符重载时遇到问题，其中来自另一个 class 的对象是此 class 的成员.我将使用输入运算符从文本文件中读取数据并将其输出到二叉树。我们有一个客户 class 和一个地址 class。 Address 是 Customer 的成员（Customer 的构造函数的一部分）。我必须阅读包含以下内容的文件：顾客ID 顾客姓名街道地址地址城市地址压缩

Customer 的构造函数是 Customer(int custID, string custName, Address* address) 所以我在 Customer class 中的输入过载有问题，我必须读入地址数据作为街道、城市、州、邮编，但将其存储为客户地址。我的 class 声明也可能有问题。这是我拥有的：

Customer.h:

#pragma once
#include <string>
#include "Address.h"

using namespace std;

class Customer
{
private:
//Attributes for customers
int custID;
string custName;
Address* address;

public:
//Constructors for Customer
Customer();
Customer(int, string, Address*);
~Customer();
//Setters for Customer
void setCustID(int);
void setCustName(string);
void setCustAddress(Address*);
//Getters for Customer
int getCustID() {return custID;}
string getCustName() {return custName;}

//Operator overloads
bool operator>(Customer obj) {return custID > obj.custID;}
bool operator<(Customer obj) {return custID < obj.custID;}
bool operator==(Customer obj) {return custID == obj.custID;}

//Operator overloads for input
friend istream &operator>>(istream &input, Customer &customer) {
    input >> customer.custID >> customer.custName >> /*?????  Here's where I can't figure out what to call for the address street, city, state, zip; */ << endl;
    return input;
}

//Operator overloads for output
friend ostream &operator<<(ostream &output, Customer &customer) {
    output << "CustID: " << customer.custID << endl << "Customer Name: " << customer.custName << endl << "Customer Address: " << customer.address << endl;
    return output;
}

};

Customer.cpp:

#include "Customer.h"

//Customer no arg constructor
Customer::Customer()
{
custID = 0;
custName = "";
}

//Customer constructor
Customer::Customer(int custID, string custName, Address* address)
{
this->custID = custID;
this->custName = custName;
this->address = address;
}

//Customer destructor
Customer::~Customer()
{

}

Address.h:

#pragma once
#include <string>

using namespace std;

class Address 
{
private:
string street;
string city;
string state;
string zip;

public:
//Constructors for address
Address();
Address(string, string, string, string);
~Address();
//Setters for address
void setAddressStreet(string);
void setAddressCity(string);
void setAddressState(string);
void setAddressZip(string);
//Getters for address
string getAddressStreet() {return street;}
string getAddressCity() {return city;}
string getAddressState() {return state;}
string getAddressZip() {return zip;}

//Operator overload for input
friend istream &operator>>(istream &input, Address &address) {
    input >> address.street >> address.city >> address.state >> address.zip;
    return input;
}
//Operator overload for output
friend ostream &operator<<(ostream &output, Address &address) {
    output << "Street: " << address.street << endl << "City: " << address.city << endl << "State: " << address.state << endl << "Zip: " << address.zip << endl;
    return output;
}
};

Address.cpp:

#include "Address.h"

//Address no arg constructor
Address::Address()
{
street = "";
city = "";
state = "";
zip = "";
}

//Address constructor
Address::Address(string street, string city, string state, string zip)
{
this->street = street;
this->city = city;
this->state = state;
this->zip = zip;
}

//Address destructor
Address::~Address()
{
}

Answer 1

你应该打电话给

friend istream &operator>>(istream &input, Customer &customer) {
    input >> customer.custID >> customer.custName >> (*customer.address);
    return input;
}

这将调用您在 Address class 中定义的提取运算符。

话虽这么说，检查您是否正确读取运算符可能是个好主意。我也不确定您为什么使用原始 Address 指针。您确实应该使用引用或智能指针。同样对于 clarity/readability，我认为将变量名放在函数声明和定义中通常是一种很好的做法，即使这不是必需的。

C++ 运算符重载输入运算符 >> 以 class 之外的对象作为成员

C++ operator overloading input operator >> with object outside class as member

c++

input

operator-overloading