CPP面向对象笔记

基本

属性

即在类中包含的一系列变量

方法

即在类中定义的一系列函数

Public, Private and Protected

在没有继承的情况下，private 与 protected 效果相同

即都无法在类外直接访问调用

实在想要访问，加个函数就行

public 则可以随意访问调用

static

仅与类的整体全局有关

不受具体哪个对象的影响

const

放在函数参数后面，函数体之前

即宣称不进行修改

构造与析构

构造函数

在 c++ class 中，不能直接为属性赋初始值

于是，我们可以使用构造函数进行初始化

构造函数可以分为无参和有参的两种

如果在创建时不传入参数，那么就会默认进行前者

class Student{
    string name;
    int age;
    Student(){age=0;name="Shitman";}
    Student(string uname,int uage){age=uage;name=uname;}//重载
};
int main(){
    Student stu;
    Student stu(name,age);
    Student *p=new Student(name,age);//支持析构
}

析构函数

算法竞赛中，没b用

但是实际的项目中，内存不是能随便挥霍的

所以及时销毁也是有必要的

class Student{
    string name;
    int age;
    Student(){age=0;name="Shitman";}
    Student(string uname,int uage){age=uage;name=uname;}//重载
    ~Student(){}
};
int main(){
    Student stu;
    Student stu(name,age);
    Student *p=new Student(name,age);//支持析构
    delete p;//自动调用析构函数
}

继承

基类&派生类

派生类可以具有基类中公开的属性与方法

基类可以有多个派生类

继承方式

继承的方式有三种：

• 公有继承，即基类中的 public 部分在派生类中也是 public ，protected 部分也是 protected ，private 的部分不能继承
• 保护继承，即基类中的 public 部分在派生类中变成 protected ，protected 部分也是 protected ，private 的部分不能继承
• 私有继承，即基类中的 public 部分在派生类中变成 private ，protected 部分变成 private ，private 的部分不能继承

class Student{
public:
    int age;
    int score;
    string name;
    Student(){
        name="Unknown";
        score=0;
        age=0;
    }
    Student(int uage,int uscore,string uname){
        name=uname;
        score=score;
        age=uage;
    }
    bool operator <(const Student &stu){
        return age==stu.age?score<stu.score:age<stu.age;
    }
    void print(int uage,int uscore,string uname,string uplan,string utype){
        cout<<uname<<" is a "<<uage<<"-yeasr-old "<<utype<<", his "<<uplan<<" score is "<<uscore<<endl;
    }
    int getAge() const{return age;}
    int getScore() const{return score;}
    string getName()  const{return name;}
    virtual void _Read() =0;
};
class Undergraduate : public Student{
public:
    string plan;
    Undergraduate(){
        plan="CPP Programing";
    }
    Undergraduate(int uage,int uscore,string uname,string uplan):Student(uage,uscore,uname){
        plan=uplan;
    }
    virtual void _Read(){
        print(getAge(),getScore(),getName(),plan,"Undergraduate");
    }
};
class Postgraduate : public Student{
public:
    string plan;
    Postgraduate(){
        plan="Deep Learning";
    }
    Postgraduate(int uage,int uscore,string uname,string uplan):Student(uage,uscore,uname){
        plan=uplan;
    }
    virtual void _Read(){
        print(getAge(),getScore(),getName(),plan,"Postgraduate");
    }
};
class Juniors : public Student{
public:
    string plan;
    Juniors(){
        plan="Office 365";
    }
    Juniors(int uage,int uscore,string uname,string uplan):Student(uage,uscore,uname){
        plan=uplan;
    }
    virtual void _Read(){
        print(getAge(),getScore(),getName(),plan,"Juniors");
    }
};

派生类的构造函数

创建派生类，如果派生类没有自己的构造函数，那就会调用基类的

如果有自己的，也会先调用基类的构造函数（无参数）

那么如何既调用派生类有参数的构造函数又调用有参数的基类构造函数呢？

见上述代码

重载，多态（虚函数）

重载

重载可以重载函数，重载运算符

本质上，重载是发生在编译器中的

即，编译器不认为你的参数不同的同名函数是一个函数

它当成两个函数处理的

例子见上述代码

虚函数

基类和派生类中的同名函数

要加上 virtual

这就是多态

当你调用一个虚函数，系统会在虚函数表中找到你要调用的，这是发生在运行中

抽象类

即基类不能用来创建对象

对象只能由派生类创建

通过纯虚函数产生抽象类

类的指针

对于抽象类，可以通过基类的指针，指向派生类的对象

对于一般类，访问公开的基类的属性并不会报错，但是如果访问派生类的则会报错，这很好理解

与一般类不同的是，通过虚函数实现多态的类，可以由该指针直接调用各自的虚函数

隐藏

似乎是没啥用的

对于派生类和基类中的同名函数

如果对于派生类直接调用，那么基类中的就相当于被隐藏