运算符重载（60分） class Product { string name; //产品名称 int price; //产品单价 int quantity； //剩余产品数量 public: Product(string n,int p int q); Product operator = (const Product &p); friend bool operator >(const Product &p1, const Product &p2); friend ostream& operator<<(ostream &out, Product &t ); };

这段代码定义了一个名为Product的类，包含了三个私有成员变量：name、price和quantity。同时，它还提供了一个构造函数和一个赋值运算符重载函数。

在这个类中，还定义了两个全局函数：一个是大于号运算符重载函数，用于比较两个Product对象的价格；另一个是插入运算符重载函数，用于将Product对象输出到流中。

需要注意的是，这里的大于号运算符重载函数和插入运算符重载函数都是定义为友元函数，因为它们需要访问Product类的私有成员变量。

相关问题

2、运算符重载（60分） class Product { string name; //产品名称 int price; //产品单价 int quantity； //剩余产品数量 public: Product(string n,int p int q); Product operator = (const Product &p); friend bool operator >(const Product &p1, const Product &p2); friend ostream& operator<<(ostream &out, Product &t ); }; 类Product说明如上所示，完成四个函数的定义，并在main函数中进行测试。

以下是类 `Product` 的完整定义及四个函数的实现：

#include <iostream>
#include <string>

using namespace std;

class Product {
    string name;      // 产品名称
    int price;        // 产品单价
    int quantity;     // 剩余产品数量

public:
    Product(string n, int p, int q);
    Product operator=(const Product& p);
    friend bool operator>(const Product& p1, const Product& p2);
    friend ostream& operator<<(ostream& out, Product& t);
};

Product::Product(string n, int p, int q) {
    name = n;
    price = p;
    quantity = q;
}

Product Product::operator=(const Product& p) {
    name = p.name;
    price = p.price;
    quantity = p.quantity;
    return *this;
}

bool operator>(const Product& p1, const Product& p2) {
    if (p1.price > p2.price) {
        return true;
    } else {
        return false;
    }
}

ostream& operator<<(ostream& out, Product& t) {
    out << "Product Name: " << t.name << endl;
    out << "Price: " << t.price << endl;
    out << "Quantity: " << t.quantity << endl;
    return out;
}

int main() {
    Product p1("Product1", 10, 50);
    Product p2("Product2", 20, 30);

    cout << "p1: " << endl;
    cout << p1 << endl;

    cout << "p2: " << endl;
    cout << p2 << endl;

    if (p1 > p2) {
        cout << "p1 is more expensive than p2." << endl;
    } else {
        cout << "p2 is more expensive than p1." << endl;
    }

    p2 = p1;
    cout << "p2 after assignment: " << endl;
    cout << p2 << endl;

    return 0;
}

输出结果为：

p1:
Product Name: Product1
Price: 10
Quantity: 50

p2:
Product Name: Product2
Price: 20
Quantity: 30

p2 is more expensive than p1.
p2 after assignment:
Product Name: Product1
Price: 10
Quantity: 50

其中，运算符重载函数 `operator>` 用于比较两个产品的单价大小，运算符重载函数 `operator<<` 用于输出产品的信息，运算符重载函数 `operator=` 用于实现产品对象之间的赋值操作。在主函数中，我们创建了两个产品对象 `p1` 和 `p2`，并对它们进行了比较和赋值操作。

class Product { string name; //产品名称 int price; //产品单价 int quantity； //剩余产品数量 public: Product(string n,int p int q); Product operator = (const Product &p); friend bool operator >(const Product &p1, const Product &p2); friend ostream& operator<<(ostream &out, Product &t ); }; 类Product说明如上所示，完成四个函数的定义，并在main函数中进行测试

以下是类Product的四个函数的定义：

class Product {
    string name;        // 产品名称
    int price;          // 产品单价
    int quantity;       // 剩余产品数量

public:
    Product(string n, int p, int q) : name(n), price(p), quantity(q) {}
    // 构造函数，初始化名称，单价和数量

    Product operator=(const Product &p) {
        name = p.name;
        price = p.price;
        quantity = p.quantity;
        return *this;
    }
    // 赋值运算符重载，将一个Product对象的值赋给另一个Product对象

    friend bool operator>(const Product &p1, const Product &p2) {
        return p1.price > p2.price;
    }
    // 大于运算符重载，比较两个Product对象的单价大小

    friend ostream& operator<<(ostream &out, Product &t) {
        out << t.name << " 单价：" << t.price << " 剩余数量：" << t.quantity;
        return out;
    }
    // 输出流运算符重载，将Product对象的信息输出到流中
};

在main函数中进行测试：

int main() {
    Product p1("商品1", 10, 100);
    Product p2("商品2", 20, 200);
    Product p3("商品3", 30, 300);

    cout << "p1: " << p1 << endl;
    cout << "p2: " << p2 << endl;
    cout << "p3: " << p3 << endl;

    p1 = p2;
    cout << "执行 p1 = p2 后：" << endl;
    cout << "p1: " << p1 << endl;
    cout << "p2: " << p2 << endl;

    if (p2 > p3) {
        cout << "p2 单价高于 p3" << endl;
    } else {
        cout << "p2 单价不高于 p3" << endl;
    }

    return 0;
}

输出结果如下：

p1: 商品1 单价：10 剩余数量：100
p2: 商品2 单价：20 剩余数量：200
p3: 商品3 单价：30 剩余数量：300
执行 p1 = p2 后：
p1: 商品2 单价：20 剩余数量：200
p2: 商品2 单价：20 剩余数量：200
p2 单价不高于 p3