C语言转向C++

C++增加项：

1.输入输出流

2.类和对象

3.运算重载

4.多态性与虚函数

5.继承与派生

此文章重点复习：类及其派生

语法介绍：

类与C语言的结构体十分相像，具有结构体的全部特性。

类在结构体之上多了：数据保护，类函数，继承。

1.数据保护

类的数据分为：public，protected，private三种。

其中public与结构体相同，能直接在对象中访问。

protected可以被继承的类调用。

private的数据或者函数为私有，不能被对象直接调用，需要使用类中定义的函数来改变相应的数据。

思考保护数据的意义：

其实保护数据没有什么特别的意义，保护还是不保护都对编译器进行编译没有影响。

唯一的意义就是大量的数据定之后能够看不见，不需要在众多数据中寻找。达到整理数据的效果。

另外一种整理数据的方法是用struct来包含数据。

2.类函数：

类函数可以直接定义在类中，就使得每个类函数为对象独有。就不需要为广义定义的函数传递对象形参了。对象作为形参不能参加一级指针及其以上的操作。

比如：

typedef struct Exp
{
    int x,y,w,h;
    Exp* next;
}Exp;

Exp* object = new Exp;

void Register(Exp* Self)
{
    Self->next = new Exp;    //错误，形参的同级别值不能被改变。
}

void Register(Exp** Self)    //重名函数，函数重载
{
    Self->next = new Exp;    //错误，无法访问对象地址**Self的成员
}

而独有函数就能实现：

class Exp
{
public:
    int x,y,w,h;
    Exp* next;
    void Register();
    void FREE();
};

Exp* object = new Exp;

void Exp::Register()
{
    this->next = new Exp;
}

void Exp::FREE()
{
    delete this->next;
    delete this;
}

上述函数变为对象独有的函数，就不会出现不能给自己的成员分配内存的情况；就不用给每个对象写单独自己的函数，重复且麻烦，因为类本身就有对象自己的函数。

类函数的意义：自动为每个对象创建独有的函数，而不需要为其单独写多余的函数。

3.继承与派生：

继承的格式：

class Attack
{
    int Power;
    int Speed;
};

//类模板

class Monster:public Attack
{
public:
    struct
    {
        int Now;
        int Total;
    }Life;
protected:
    struct
    {
        int x,y,w,h;
    }Collision;
};

//类模板

class BOSS:public Monster
{
    int BOSSAttibute;
};

类的继承需要在类名后加上： ：继承类型继承类

多个类继承需要用逗号隔开： ：继承类型继承类1，继承类型继承类2

问题：

如果继承类中有与前面类重名的成员怎么办？

using namespace std;

class Exp_1
{
public:int x,y,w,h;
};

class Exp_2 :public Exp_1
{
public:int x, y, w, h;
      int momo;
};

class Exp_3:public Exp_2,public Exp1
{
public:int x, y, w, h;
};

Exp_3* object = new Exp_3;

int main()
{
    
    object->w = 1;

    object->Exp_2::w = 2;

    object->Exp_2::Exp_1::w = 3;

    printf("%d %d %d", object->w, object->Exp_2::w, object->Exp_2::Exp_1::w);

    return 0;
}

如图所示：继承的非重名的成员能直接调用。

新类继承之前的类之后，对象申请内存只需要申请当前类型的内存。

重名的成员需要先用成员访问符（.或者->）访问继承的类名，再使用域访问符::访问被继承类的成员。

object->Exp_2::Exp_1::w = 3;

object->Exp_1::w = 3;

上述意义相同。

两个类相互包含：

//A.h

#include"B.h"
class B;

class A
{
    B* b;
    void Take(B* b);
};



//B.h

#include"A.h"
class A;

class B
{
    A* a;
    void Take(A* a);
};



//A.cpp
#include"B.h"
#include"A.h"


void A:: Take(B* b)
{
    ...;
}

//B.cpp

#include"B.h"
#include"A.h"


void B:: Take(A* a)
{
    ...;
}

1.函数放在cpp,在.h中标记

2. .h文件相互在.h文件包含，并且包含对方类的class X；