2023/9/12 -- C++/QT

作业

实现一个图形类（Shape），包含受保护成员属性：周长、面积，

                公共成员函数：特殊成员函数书写

定义一个圆形类（Circle），继承自图形类，包含私有属性：半径

                公共成员函数：特殊成员函数、以及获取周长、获取面积函数

定义一个矩形类（Rect），继承自图形类，包含私有属性：长度、宽度

                公共成员函数：特殊成员函数、以及获取周长、获取面积函数

在主函数中，分别实例化圆形类对象以及矩形类对象，并测试相关的成员函数。

 03hmwk.h:

#ifndef __03HMWK_H__
#define __03HMWK_H__

#include 
#define PI 3.14
using namespace std;

class Shape{
protected:
    double circumference;
    double size;
public:
    //无参构造
    Shape();
    //有参构造
    Shape(double c,double s);
    //析构
    ~Shape();
    //拷贝构造
    Shape(const Shape &other);
    //移动构造
    Shape(Shape && other);
    //拷贝赋值
    Shape & operator=(const Shape &other);
    //移动赋值
    Shape & operator=(Shape && other);
};

class Circle:public Shape{
private:
    double radius;
public:
    //无参构造
    Circle();
    //有参构造
    Circle(double r);
    //析构
    ~Circle();
    //拷贝构造
    Circle(const Circle &other);
    //移动构造
    Circle(Circle && other);
    //拷贝赋值
    Circle & operator=(const Circle &other);
    //移动赋值
    Circle & operator=(Circle && other);
    //获取周长
    double get_C();
    //获取面积
    double get_S();
};

class Rectangle:public Shape{
private:
    double length;
    double width;
public:
    //无参构造
    Rectangle();
    //有参构造
    Rectangle(double l,double w);
    //析构
    ~Rectangle();
    //拷贝构造
    Rectangle(const Rectangle &other);
    //移动构造
    Rectangle(Rectangle && other);
    //拷贝赋值
    Rectangle & operator=(const Rectangle &other);
    //移动赋值
    Rectangle & operator=(Rectangle && other);
    //获取周长
    double get_C();
    //获取面积
    double get_S();
};

#endif // 03HMWK_H

03hmwk.cpp:

#include <03hmwk.h>
//无参构造
Shape::Shape():circumference(0),size(0){
    cout<<"Shape::无参构造"<

main.cpp:

#include <03hmwk.h>

int main()
{
    Circle c1(5);
    cout<<"c1.C = "<
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
 
  
一、静态成员（static）
 
  
程序员有时在实例化对象时，想让某个成员或某几个成员独立于类对象而存在，但是又属于类对象的属性，不占用类对象的空间，那么此时我们可以将这些成员设置成静态成员，相当于在类体内定义一个全局的成员。静态成员分为静态成员变量和静态成员函数。
 
  
1.1 静态成员变量
 
  
 
   
定义格式：在定义成员变量时，在前面加关键字static，那么该变量就是静态成员变量
 
   
静态成员变量一般声明成public权限，并且需要在类内声明，类外定义，定义时如果不初始化，默认为0,
 
   
静态成员变量，不依附于类对象而存在，不占用类对象的空间，在编译时，系统在静态区为其分配空间
 
   
静态成员变量也是每个类对象拥有的属性，一个对象对其更改，所有对象的该属性都会更改
 
   
使用方式：每个类对象都可以使用成员运算符进行调用，也可以通过类名加作用域限定符直接调用
 
   
静态成员变量，从功能上来说相当于全局变量，但是相比于全局变量更能体现类的封装性
 
  
 
  
#include 

using namespace std;
class Stu
{
private:
    int age;
public:
    static int score;            //在类内声明
    Stu() {}
};

//在类外定义一下静态成员变量
int Stu::score = 100;

int main()
{
    Stu::score = 50;                  //通过 类名直接访问类中的静态成员变量

    Stu s;
    cout<<"score = "<#include 

using namespace std;
class Stu
{
private:
    int age;
public:
    static int score;            //在类内声明
    Stu() {}
    Stu(int a):age(a) {}

    //该函数是静态成员函数
    static void show()
    {
        //cout<<"age = "<
 
  
二、继承（inherit）
 
  
2.1 继承的概念
 
  
1> 所谓继承，就是在一个类的基础上去定义另一个新类的过程叫做继承
 
  
2> 作用：
 
  
 
   
继承能够提高代码的复用性
 
   
继承是实现多态的必要条件
 
  
 
  
2.2 继承格式
 
  
class  子类名:继承方式  父类名
{
    //子类拓展的成员
}
继承方式有三种：public、protected、private

子类：也叫派生类
父类：也叫基类
 
  
2.3 继承方式对类中成员的权限的影响
 
  
父类中                    public|protected|private|不能访问                public|protected|private|不能访问          public|protected|private|不能访问         
继承方式                            public                                            protected                                   private
子类中                    public|protected|不能访问|不能访问                protected|protected|不能访问|不能访问       private|private|不能访问|不能访问
 
  
总结：
 
  
 
   
所谓继承方式，其实就是父类中的成员的访问权限在子类中的最高权限
 
   
如果继承过程中没有加访问权限，默认是私有继承
 
   
常用的继承方式是public
 
   
在所有继承方式中，都不能在子类中访问父类的私有成员以及父类不能访问的成员
 
  
 
  
2.4 子类会继承父类中的所有成员
 
  
1> 子类会继承父类中的所有成员，包括私有成员，只是私有成员不能访问而已
 
  
2> 父类和子类是不同的类
 
  
3> 为了对子类从父类中继承下来成员进行初始化工作，需要在子类的构造函数初始化列表中显性调用父类的有参构造完成，否则系统会自动调用父类的无参构造，此时，如果父类没有无参构造，则系统报错
 
  
4> 在这个过程中，虽然调用了父类的构造函数，但是，并没有实例化一个父类对象
 
  
#include 

using namespace std;

class Person
{
public:
    string name;
protected:
    int value;
private:
    double money;            //私房钱

public:
    Person() {cout<<"Person::无参构造"<
 
  
2.5 类的关系模型
 
  
1> has - a模型
 
  
包含关系，一个类中包含另一个类的成员对象
 
  
2> use - a模型
 
  
友元关系，将某个类设置成友元，那么另一个类就可以使用自己的所有权限下的成员
 
  
3> is - a模型
 
  
继承关系，并且，is-a模型是特殊的has-a模型
 
  
 
  
2.6 类的继承步骤
 
  
1> 全盘吸收父类
 
  
2> 改造父类：继承方式、通过using关键字改变
 
  
3> 拓展新成员
 
  
#include 

using namespace std;

class Person
{
public:
    string name;    
protected:
    int salary;    
private:
    int money;    
public:
    Person() {}
};

//定义学生类继承自Person
class Stu:public Person
{
protected:
    using Person::name;        //将继承的name的权限更改成受保护权限
    
public:
    using Person::salary;         //将继承的salary权限更改成公共权限
    
    //using Person::money;          //父类的私有成员不能进行改造
    
    double score;              //拓展新成员
    
public:
    Stu() {}
    
    
};

int main()
{
    Stu s;
    
    //s.name = "hello";
    //s.salary = 1000;
    
    return 0;
}