ostream& operator << (ostream&os, const List&rhs);

这是一个重载运算符的函数，将一个List对象输出到流中。其中，os表示输出流对象，rhs表示要输出的List对象。

函数的返回值为一个ostream对象的引用，这是为了支持多个<<运算符的连续使用，比如 cout << a << b << c; 在这个例子中，每个<<运算符都返回一个ostream对象的引用，使得它们可以连续使用。

下面是一个示例实现：

ostream& operator << (ostream&os, const List&rhs) {
    os << "[ ";
    ListNode* curr = rhs.head_;
    while (curr) {
        os << curr->val << " ";
        curr = curr->next;
    }
    os << "]";
    return os;
}

这个实现将List对象按照链表的顺序输出到流中，每个元素之间用空格隔开，用方括号括起来。

相关问题

#include <iostream> #include <vector> #include <string> using namespace std; class CDate{ public: CDate(); CDate (int year,int month,int day); CDate& operator ++(); CDate operator ++(int); CDate operator+(long days) const; CDate operator-(long days) const; long operator -(const CDate& rhs) const; int WeekDay() const; static int IsLeapYear(int year); friend ostream& operator <<(ostream& out,const CDate& d); friend istream& operator >>(istream& in, CDate& d); int getmonthday(); bool operator>(const CDate& d) const; private: int m_year,m_month,m_day; }; /* 请在这里填写答案 */ int main(int argc, char** argv) { vector<string> w={"SUN","MON","TUE","WEN","THU","FRI","SAT"}; CDate d1; int n; cin>>d1; cout<<d1<<endl; cout<<w[d1.WeekDay()]<<endl; cin>>n; CDate d2=d1+n; cout<<w[d2.WeekDay()]<<endl; ++d2; cout<<d2<<endl; d2++; cout<<d2<<endl; cout<<d2-d1<<endl; // cout<<d2-d1<<endl; return 0; }

以下是填空部分的答案：

CDate::CDate() {
    time_t t = time(NULL);
    struct tm* now = localtime(&t);
    m_year = now->tm_year + 1900;
    m_month = now->tm_mon + 1;
    m_day = now->tm_mday;
}

CDate::CDate(int year, int month, int day) : m_year(year), m_month(month), m_day(day) {}

CDate& CDate::operator++() {
    if (m_day == getmonthday()) {
        m_day = 1;
        if (m_month == 12) {
            m_year++;
            m_month = 1;
        } else {
            m_month++;
        }
    } else {
        m_day++;
    }
    return *this;
}

CDate CDate::operator++(int) {
    CDate tmp(*this);
    operator++();
    return tmp;
}

CDate CDate::operator+(long days) const {
    CDate tmp(*this);
    if (days >= 0) {
        for (long i = 0; i < days; i++) {
            ++tmp;
        }
    } else {
        for (long i = 0; i > days; i--) {
            --tmp;
        }
    }
    return tmp;
}

CDate CDate::operator-(long days) const {
    return operator+(-days);
}

long CDate::operator-(const CDate& rhs) const {
    struct tm t1 = {0}, t2 = {0};
    t1.tm_year = m_year - 1900;
    t1.tm_mon = m_month - 1;
    t1.tm_mday = m_day;
    t2.tm_year = rhs.m_year - 1900;
    t2.tm_mon = rhs.m_month - 1;
    t2.tm_mday = rhs.m_day;
    time_t time1 = mktime(&t1);
    time_t time2 = mktime(&t2);
    return (time1 - time2) / (24 * 60 * 60);
}

int CDate::WeekDay() const {
    struct tm t = {0};
    t.tm_year = m_year - 1900;
    t.tm_mon = m_month - 1;
    t.tm_mday = m_day;
    mktime(&t);
    return t.tm_wday;
}

int CDate::IsLeapYear(int year) {
    if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
        return 1;
    } else {
        return 0;
    }
}

int CDate::getmonthday() {
    int days[] = {31, 28 + IsLeapYear(m_year), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    return days[m_month - 1];
}

bool CDate::operator>(const CDate& d) const {
    if (m_year > d.m_year) {
        return true;
    } else if (m_year < d.m_year) {
        return false;
    } else {
        if (m_month > d.m_month) {
            return true;
        } else if (m_month < d.m_month) {
            return false;
        } else {
            if (m_day > d.m_day) {
                return true;
            } else {
                return false;
            }
        }
    }
}

ostream& operator<<(ostream& out, const CDate& d) {
    out << d.m_year << "-" << d.m_month << "-" << d.m_day;
    return out;
}

istream& operator>>(istream& in, CDate& d) {
    in >> d.m_year >> d.m_month >> d.m_day;
    return in;
}

以友元函数的形式重载上述实验1中复数类Complex的加法“+”、减法“-”、乘法“*”三个运算。#include<iostream.h> class Complex{ private: double r; double i; public: Complex(double real=0.0, double image=0.0){ //定义带默认参数值的构造函数 r = real; i = image; } //在此声明+ -*三个友元函数 //******************************************* //====================================== friend ostream & operator<<(ostream &os, const Complex & c); //"<<"被重载为友元函数 }; //在此定义+ - *三个友元函数 //******************************************* //======================================

好的，以下是Complex类的定义和重载运算符的实现：

#include <iostream>

class Complex {
public:
    Complex(double real = 0.0, double imag = 0.0): r(real), i(imag) {}
    friend Complex operator+(const Complex& lhs, const Complex& rhs);
    friend Complex operator-(const Complex& lhs, const Complex& rhs);
    friend Complex operator*(const Complex& lhs, const Complex& rhs);
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
private:
    double r, i;
};

Complex operator+(const Complex& lhs, const Complex& rhs) {
    return Complex(lhs.r + rhs.r, lhs.i + rhs.i);
}

Complex operator-(const Complex& lhs, const Complex& rhs) {
    return Complex(lhs.r - rhs.r, lhs.i - rhs.i);
}

Complex operator*(const Complex& lhs, const Complex& rhs) {
    return Complex(lhs.r * rhs.r - lhs.i * rhs.i, lhs.r * rhs.i + lhs.i * rhs.r);
}

std::ostream& operator<<(std::ostream& os, const Complex& c) {
    os << c.r << (c.i >= 0.0 ? "+" : "-") << std::abs(c.i) << "i";
    return os;
}

我们定义了一个Complex类，包含一个含有默认参数值的构造函数，同时也定义了三个友元函数，重载了加法、减法、乘法三个运算符。在这里需要注意，这些运算符都是通过友元函数实现的，因此需要在函数声明和定义的前面加上 `friend` 关键字。

这个类的使用示例：

int main() {
    Complex a(1.0, 2.0), b(3.0, -4.0);
    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;
    std::cout << "a + b = " << a + b << std::endl;
    std::cout << "a - b = " << a - b << std::endl;
    std::cout << "a * b = " << a * b << std::endl;
    return 0;
}

输出结果：

a = 1+2i
b = 3-4i
a + b = 4-2i
a - b = -2+6i
a * b = 11-2i