C++类

一直就想写博客，但感觉学的又少，什么都不会再写错，最后一拖再拖。莫不如学点写点

打了两年比赛，天天用C/C++，可是连类-继承-重载-多态-虚函数等等都不清楚

首先是 定义类，构造函数以及析构函数

内部函数定义方式和普通函数一样   类型+函数名（参数...）

构造函数：创建类时会自动调用，可以有参数，无返回值。      一个类可以有多个            名字是   类名

构造函数：删除类时会自动调用，不可以有参数，无返回值。  一个类只能有一个            名字是 ~类名

#include<stdio.h>
class person
{
public :
    person()///构造函数
    {
        printf("出生了！！！
");
    }
    add(int x,int y)
    {
    return x+y;
    }
    ~person()///析构函数
    {
        printf("去世了...
");
    }
};

int main()
{
     person *man=new person();
     printf("-------------------------------
");
     printf("计算3+4=%d
",man->add(3,4));
     printf("打代码，打ACM.....
");
     printf("-------------------------------
");
     delete man;
}

继承

一个类可以继承其他类，被继承的叫父类，基类，当然也可以多继承

修饰继承的方法public,protected,private

#include<stdio.h>
class father
{
public :
    father()
    {
        printf("父亲在此
");
    }
};
class mother
{
public :
    mother()
    {
        printf("母亲在此
");
    }
};
class person:public father,public mother///多继承
{
public :
    person()///构造函数
    {
        printf("出生了！！！
");
    }
    ~person()///析构函数
    {
        printf("去世了...
");
    }
};

int main()
{
     person *man=new person();
     printf("-------------------------------
");
     printf("打代码，打ACM.....
");
     printf("-------------------------------
");
     delete man;
}

重载函数

感觉就是定义多个名相同，但参数个数，类型不同的函数

重载运算符

例如  重载+号 （有些符号不可重载）

#include<stdio.h>
class person
{
private :
    int treasure;
public :
    person()///构造函数
    {
        treasure=0;
        printf("出生了！！！财富%d元
",treasure);
    }
    person(int x)
    {
        treasure=x;
        printf("出生了！！！财富%d元
",treasure);
    }
    add(int x,int y)
    {
       return x+y;
    }
    person operator+(const person &man)
    {
        return person(treasure+man.treasure);
    }
    ~person()///析构函数
    {
        printf("去世了...
");
    }
};

int main()
{
     person a(10000000),b(1);
     person c=a+b;
}

C++多态

虚函数

定义：用virtual修饰的函数

本质：由虚指针和虚表控制，虚指针指向了某个函数入口实现了多态

作用：虚函数可以被子类重写，当用父指针指向一个子类对象时，虚表指明了实际指向的对象

#include<stdio.h>
#include<string.h>
class person
{

public :
    person()///构造函数
    {
        printf("出生了！！！
");
    }
    void myname()
    {
        printf("我是小明
");
    }
    virtual void doing()
    {
        printf("玩手机...玩电脑....
");
    }
    ~person()///析构函数
    {
        printf("去世了...
");
    }
};
class math:public person
{
public :

    void myname()
    {
        printf("我是15号
");
    }
    void doing()
    {
        printf("学高数...
");
    }
};
int main()
{
    ///分别定义父类和子类的对象，各自使用了各自的函数
     person a;
     a.myname();
     a.doing();
     math b;
     b.myname();
     b.doing();
    printf("--------------------------
");
    ///当我们用父类指针来指向的时候，只有virtual定义的函数，子类才会调用
     person* p;
     p=&a;
     p->myname();
     p->doing();
     p=&b;
     p->myname();
     p->doing();
}

纯虚函数

纯虚函数只声明，不定义。  包含纯虚函数的类叫做抽象类，不能new，只有声明了函数的子类，才可以new出对象，是对子类的约束

例如 virtual void solve()=0;