【C++】第二天认识C++的基本语法知识

知识思维导图

 

练习题： 自己封装一个矩形类(Rect)，拥有私有属性:宽度(width)、高度(height),定义公有成员函数:
初始化函数:void init(int w,int h)更改宽度的函数:set_w(int w)
更改高度的函数:set h(int h)
输出该矩形的周长和面积函数:void show()

#include <iostream>

using namespace std;

class Rect
{
private:
    double width;//宽度
    double height;//高度
public:
    void init(int w, int h);//初始化函数声明
    void set_w(int w);//更改宽度的函数声明
    void set_h(int h);//更改高度的函数声明
    void show();//输出该矩形的周长和面积函数声明
};

//Rect类的初始化函数定义
void Rect::init(int w, int h)
{
    this->width = w;
    this->height = h;
}

//Rect类的更改宽度的函数定义
void Rect::set_w(int w)
{
    this->width = w;
}

//Rect类的更改高度的函数定义
void Rect::set_h(int h)
{
    this->height = h;
}

//Rect类的输出该矩形的周长和面积函数定义
void Rect::show()
{
     cout << "周长 = " << this->height*2+this->width*2 << ", ";
     cout << "面积 = " << this->height*this->width << endl;
}

int main()
{
    Rect rect1;//定义一个Rect类的对象
    rect1.init(10,99);//调用内置的函数初始化
    rect1.show();//调用内置的函数输出该矩形的周长和面积

    rect1.set_h(20);//调用内置的函数更改宽度
    rect1.set_w(3);//调用内置的函数更改高度
    rect1.show();//调用内置的函数输出该矩形的周长和面积

    return 0;
}

运行结果：

练习题：搭建一个货币的场景，创建一个名为 RMB 的类，该类具有整型私有成员变量yuan(元)、jiao(角)和 fen(分)，并且具有以下功能:
(1)重载算术运算符+和-，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果(2)重载关系运算符>，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。
(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1
(4)重载后置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1
(5)另外，RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1;每当销毁一个 RMB 对象时，count 应该自减1。要求，需要在main 函数中测试上述RMB 类的功能

#include <iostream>

using namespace std;

class RMB
{
private:
    int yuan;   //元
    int jiao;   //角
    int fen;    //分
    static int count;   //静态成员变量count，记录当前已创建RMB对象的数量
public:
    //无参构造函数
    RMB()
    {
        this->yuan = 0;
        this->jiao = 0;
        this->fen = 0;
        count ++;   //创建一个对象自增1
        cout << this << ":RMB::无参构造" << endl;
    }
    //有参构造函数
    RMB(int yuan, int jiao, int fen):yuan(yuan), jiao(jiao), fen(fen)
    {
        this->yuan = ((this->fen/10 + this->jiao)/10 + this->yuan);
        this->jiao = (this->fen/10 + this->jiao)%10;
        this->fen = this->fen%10;
        count ++;   //创建一个对象自增1
        cout << this << ":RMB::有参构造" << endl;
    }
//    //拷贝构造函数
//    RMB(const RMB &other):yuan(other.yuan), jiao(other.jiao), fen(other.fen)
//    {
//        this->yuan = ((this->fen/10 + this->jiao)/10 + this->yuan);
//        this->jiao = (this->fen/10 + this->jiao)%10;
//        this->fen = this->fen%10;
//        count ++;   //创建一个对象自增1
//        cout << this << ":RMB::拷贝构造" << endl;
//    }
    //析构函数
    ~RMB()
    {
        count --;   //销毁一个对象自减1
        cout << this << ":RMB::析构" << endl;
    }
    //静态成员函数版本的展示函数
    static void show(const RMB &r)
    {
        cout << &r << ":"
             << r.yuan << "元"
             << r.jiao << "角"
             << r.fen << "分" <<endl;
    }
//    //拷贝赋值函数=
//    RMB operator=(const RMB &R)
//    {
//        yuan = R.yuan;
//        jiao = R.jiao;
//        fen = R.fen;
//        return *this;
//    }
    //重载算术运算符+
    RMB operator+(const RMB &R) const
    {
        cout << this << ":RMB::重载算术运算符+" << endl;
        RMB temp;
        temp.yuan = yuan + R.yuan + (jiao + R.jiao + (fen + R.fen)/10)/10;
        temp.jiao = (jiao + R.jiao + (fen + R.fen)/10)%10;
        temp.fen = (fen + R.fen)%10;
        return temp;
    }
    //重载算术运算符-
    RMB operator-(const RMB &R) const
    {
        cout << this << ":RMB::重载算术运算符-" << endl;
        RMB temp;
        if(fen < R.fen)
        {
            temp.jiao = jiao -1;
            temp.fen = 10 + fen -R.fen;
        }else
        {
            temp.fen = fen - R.fen;
        }
        if(jiao < R.jiao)
        {
            temp.yuan = yuan - 1;
            temp.jiao = 10 + jiao -R.jiao;
        }else
        {
            temp.jiao = jiao - R.jiao;
        }
        temp.yuan = yuan - R.yuan;
        return temp;
    }
    //重载关系运算符>
    bool operator>(const RMB &R) const
    {
        return  ((yuan*100+jiao*10+fen) > (R.yuan*100+R.jiao*10+R.fen));
    }
    //重载前置减减运算符
    RMB &operator--()
    {
        yuan--;
        jiao--;
        fen--;
        return *this;
    }
    //重载后置减减运算符
    const RMB operator--(int)
    {
        const RMB r=*this;
        yuan--;
        jiao--;
        fen--;
        return r;
    }
};

int RMB::count = 0;

int main()
{
    RMB r1(100, 20, 11);
    RMB::show(r1);
    RMB r2(100, 5, 3);
    RMB::show(r2);
    RMB r3;
    RMB::show(r3);
    cout << "=====================" << endl;
    r3 = r1 + r2;
    RMB::show(r3);
    cout << "=====================" << endl;
    r3 = r2 - r1;
    RMB::show(r3);
    cout << "=====================" << endl;
    -- -- --r3;
    RMB::show(r3);
    cout << "=====================" << endl;
    r3 --;
    RMB::show(r3);
    r2 = r3 --;
    RMB::show(r2);
    RMB::show(r3);
    cout << "=====================" << endl;

    return 0;
}

运行结果：
 

练习题：以下是一个简单的比喻，将多态概念与生活中的实际情况相联系:
比喻:动物园的讲解员和动物表演
想象一下你去了一家动物园，看到了许多不同种类的动物，如狮子、大象、猴子等。现在，动物园里有一位讲解员，他会为每种动物表演做简单的介绍。
在这个场景中，我们可以将动物比作是不同的类，而每种动物表演则是类中的函数。而讲解员则是一个基类，他可以根据每种动物的特点和表演，进行相应的介绍。
具体过程如下:
定义一个基类 Animal，其中有一个虚函数perform()，用于在子类中实现不同的表演行为。

#include <iostream>

using namespace std;

//定义 动物 类   -->公共基类
class Animal
{
private:
    string name;
public:
    Animal() {}
    Animal(string name):name(name)
    {}
    void speakname()
    {
        cout << name;
    }
    //纯虚函数
    virtual void perform()=0;
};

//定义 狮子 类 公有继承动物类   -->中间子类
class Lion:virtual public Animal
{
private:
    double weight;
    string sex;
public:
    Lion() {}
    Lion(string name,double weight,string sex):Animal(name),weight(weight),sex(sex) {}
    void perform()
    {
        cout << weight << "重的" << sex << "狮子";
        speakname();
        cout << "在跳火圈" << endl;
    }
};

//定义 大象 类 公有继承动物类   -->中间子类
class Elephet:virtual public Animal
{
private:
    double weight;
    string color;
public:
    Elephet() {}
    Elephet(string name,double weight,string color):Animal(name),weight(weight),color(color) {}
    void perform()
    {
        cout << weight << "重的" << color << "大象";
        speakname();
        cout << "在玩皮球" << endl;
    }
};

//定义 猴子 类 公有继承动物类   -->中间子类
class Monkey:virtual public Animal
{
private:
    int age;
    string color;
public:
    Monkey() {}
    Monkey(string name,int age,string color):Animal(name),age(age),color(color) {}
    void perform()
    {
        cout << age << "岁的" << color << "颜色的猴子";
        speakname();
        cout << "在走钢丝" << endl;
    }
};

//不需要用汇聚子类

int main()
{
    //定义 动物园讲解员 指针
    Animal *perple;
    //狮子表演
    Lion lion("豆豆",150,"母");
    perple=&lion;
    perple->perform();
    //大象表演
    Elephet ele("啦啦",300,"灰");
    perple=&ele;
    perple->perform();
    //猴子表演
    Monkey mo("吉吉",3,"金色");
    perple=&mo;
    perple->perform();

    return 0;
}

运行结果：