头歌 10 - C++ 面向对象 - 运算符重载与友元函数（简洁）

目录

第1关：复数运算

第2关：学生信息转换

第3关：矩阵运算

---

第1关：复数运算

/** 设计一个复数类（ Complex ），该类有两个成员变量和两个函数（成员变量访问性为私有，函数为公有）
 * 并重载+，-，*运算符，实现复数的加、减、乘运算
 *
 *成员变量：float real，代表实部。

 *成员变量：float image，代表虚部。

 *构造函数：Complex(float r,float i)，用两个参数设置 real 和 image 成员变量的值。

 *输出复数函数：void Print()，输出格式为：实部 +/- 虚部i，比如1+1i，0−5i。
 *
 */

#include <iostream>

using namespace std;

class Complex
{
    friend Complex operator+(Complex&c1,Complex&c2);
    friend Complex operator-(Complex&c1,Complex&c2);
    friend Complex operator*(Complex&c1,Complex&c2);
public:
    //构造函数
    Complex();
    Complex(float r,float i);

    //析构函数
    ~Complex();

    //set函数
    void setReal(float r);
    void setImage(float i);

    //get函数
    float getReal();
    float getImage();

    //打印函数
    void Print();


private:
    float real;//代表实部
    float image;//代表虚部
};
   //构造函数
    Complex::Complex()
    {

    }
    Complex::Complex(float r,float i):real(r),image(i)
    {

    }

    //析构函数
    Complex::~Complex()
    {

    }

    //set函数
    void Complex::setReal(float r)
    {
        real=r;
    }
    void Complex::setImage(float i)
    {
        image=i;
    }

    //get函数
    float Complex::getReal()
    {
        return real;
    }
    float Complex::getImage()
    {
        return image;
    }

    //打印函数
    void Complex::Print()
    {
        if(getImage()>=0)
        cout << getReal() << "+" << getImage() << "i" << endl;
        else
        cout << getReal() << getImage() << "i" << endl;
    }
    Complex operator+(Complex&c1,Complex&c2)
    {
        Complex c;
        c.real=c1.real+c2.real;
        c.image=c1.image+c2.image;
        return c;
    }
    Complex operator-(Complex&c1,Complex&c2)
    {
        Complex c;
        c.real=c1.real-c2.real;
        c.image=c1.image-c2.image;
        return c;
    }
    Complex operator*(Complex&c1,Complex&c2)
    {
        Complex c;
        c.real=c1.real*c2.real-c1.image*c2.image;
        c.image=c1.real*c2.image+c2.real*c1.image;
        return c;
    }
    //(1+2i)*(2+3i)=(1*2+1*3i+2i*2+2i*3i)=(1*2-2*3)+(1*3+2*2)i
int main()
{
    float a1,b1;
    cin >> a1 >> b1;
    Complex c1(a1,b1);
    float a2,b2;
    cin >> a2 >> b2;
    Complex c2(a2,b2);
    c1.Print();
    c2.Print();
    Complex c=c1+c2;
    c.Print();
    Complex c3=c1-c2;
    c3.Print();
    Complex c4=c1*c2;
    c4.Print();
    return 0;
}

第2关：学生信息转换

/**
设计学生和教师两个类，类中成员变量都为私有，成员函数都为公有，并实现它们之间的转换
学生类（ Student ）

编号：int number

姓名：string name

性别：string sex

带参构造函数：Student(int num,string nam,string se)，用三个参数对应初始化内部的三个成员变量。

输出函数：void Print()函数，输出学生信息，格式为：学生：name，编号：number，性别：sex。

教师类（ Teacher ）

与 Student 类有三个同样的成员变量

输出函数：void Print()，输出教师信息，格式为：教师：name，编号：number，性别：sex的格式打印三个成员变量。

转换构造函数，用于从 Student 类转换到 Teacher 类，它将 Student 对象的成员变量对应复制 Teacher 对象的成员变量中。

friend <返回类型> <函数名> (<参数列表>);
但这个友元函数不属于该类的成员函数，是定义在类外的普通函数，只是在类中声明
该函数可以直接访问类中的 private 或者 protected 成员。
友元声明还有如下限制：

友元关系不能被继承。

友元关系是单向的，不具有交换性。若类 B 是类 A 的友元，类 A 不一定是类 B 的友元。

友元关系不具有传递性。若类 B 是类 A 的友元，类 C 是 B 的友元，类 C 不一定是类 A 的友元。
*/
#include <iostream>
#include <string>
using namespace std;
//先声明Teacher类
class Teacher;
class Student
{
    friend class Teacher;
public:
     //构造函数
     Student();
     Student(int num,string nam,string se);

     //析构函数
     ~Student();

     //set函数
     void setNumber(int n);
     void setName(string n);
     void setSex(string s);

     //get函数
     int getNumber();
     string getName();
     string getSex();

     //打印函数（输出学生信息，格式为：学生：name，编号：number，性别：sex。）
     void Print();

private:
    //编号：
    int number;

    //姓名：
    string name;

    //性别：
    string sex;
};
     //构造函数
     Student::Student()
     {

     }
     Student::Student(int num,string nam,string se):number(num),name(nam),sex(se)
     {

     }

     //析构函数
     Student::~Student()
     {

     }

     //set函数
     void Student::setNumber(int n)
     {
         number=n;
     }
     void Student::setName(string n)
     {
         name=n;
     }
     void Student::setSex(string s)
     {
         sex=s;
     }

     //get函数
     int Student::getNumber()
     {
         return number;
     }
     string Student::getName()
     {
         return name;
     }
     string Student::getSex()
     {
         return sex;
     }

     //打印函数（输出学生信息，格式为：学生：name，编号：number，性别：sex。）
     void Student::Print()
     {
         cout<<"学生："<<name<<"，编号："<<number<<"，性别："<<sex<<endl;
     }

class Teacher
{
public:
    //构造函数
    Teacher();
    Teacher(int num,string nam,string se);
    Teacher(const Student& s);
    //析构函数
    ~Teacher();

    //打印函数
    void Print();


private:
    //编号：
    int number;

    //姓名：
    string name;

    //性别：
    string sex;
};
   //构造函数
    Teacher::Teacher()
    {

    }
    Teacher::Teacher(int num,string nam,string se):number(num),name(nam),sex(se)
    {

    }
    Teacher::Teacher(const Student& s)
    {
        number=s.number;
        name=s.name;
        sex=s.sex;
    }
    //析构函数
    Teacher::~Teacher()
    {

    }

    //打印函数
    void Teacher::Print()
    {
        cout<<"教师："<<name<<"，编号："<<number<<"，性别："<<sex<<endl;
    }
int main()
{
    int number;
    cin >> number;
    string name;
    cin >> name;
    string sex;
    cin >> sex;
    Student s(number,name,sex);
    s.Print();
    Teacher t(s);
    t.Print();

    return 0;
}

第3关：矩阵运算

#include <iostream>

using namespace std;

class Matrix
{
    friend Matrix operator+(Matrix &m1,Matrix &m2);//重载Matrix类的加法运算符，实现矩阵的加法运算。

    friend Matrix operator-(Matrix &m1,Matrix &m2);//重载Matrix类的减法运算符，实现矩阵的减法运算。

    friend Matrix operator*(Matrix &m1,Matrix &m2);//重载Matrix类的乘法运算符，实现矩阵的乘法运算。
public:

    //构造函数
    Matrix();
    Matrix(int r,int c);

    //虚构函数
    ~Matrix();

    //set函数
    void Fill(int value);
    void Set(int r,int c,int value);

    //get函数
    int Get(int r,int c);//函数返回矩阵第 r 行 c 列的元素

    //打印函数
    void Print();


private:

    int h;
    int l;
    //int value;
    int a[10][10];
};
//构造函数
    Matrix::Matrix():h(1),l(1)
    {

    }
    Matrix::Matrix(int r,int c)
    {
        this->h=r;
        this->l=c;
    }

    //虚构函数
    Matrix::~Matrix()
    {

    }

    //set函数
    void Matrix::Fill(int value)
    {

        for(int i=0;i<h;i++)
        {
            for(int j=0;j<l;j++)
            {
                a[i][j]=value;
            }
        }
    }
    void Matrix::Set(int r,int c,int value)
    {

        a[r][c]=value;
    }

    //get函数
    int Matrix::Get(int r,int c)//函数返回矩阵第 r 行 c 列的元素
    {
        return a[r][c];
    }

    //打印函数
    void Matrix::Print()
    {
         for(int i=0;i<h;i++)
        {
            for(int j=0;j<l;j++)
            {
                cout << a[i][j] << " ";
            }
            cout << endl;
        }
    }

    Matrix operator+(Matrix &m1,Matrix &m2)//重载Matrix类的加法运算符，实现矩阵的加法运算。
    {
        Matrix b(m1.h,m2.l);
        for(int i=0;i<m1.h;i++)
        {
            for(int j=0;j<m2.l;j++)
            {
                b.a[i][j]=m1.a[i][j]+m2.a[i][j];
            }
        }
        return b;
    }

    Matrix operator-(Matrix &m1,Matrix &m2)//重载Matrix类的减法运算符，实现矩阵的减法运算。
    {
        Matrix b(m1.h,m2.l);
        for(int i=0;i<m1.h;i++)
        {
            for(int j=0;j<m2.l;j++)
            {
                b.a[i][j]=m1.a[i][j]-m2.a[i][j];
            }
        }
        return b;
    }

    Matrix operator*(Matrix &m1,Matrix &m2)//重载Matrix类的乘法运算符，实现矩阵的乘法运算。
    {
        Matrix b(m1.h,m2.l);
        
        for(int i=0;i<m1.h;i++)
        {
            for(int j=0;j<m2.l;j++)
            {
                long s=0;
                for(int k=0;k<m1.l;k++)
                {
                    s+=m1.a[i][k]*m2.a[k][j];
                }
                b.a[i][j]=s;
            }
        }
        return b;
    }