C语言面向过程，c++面向对象，对类和对象的使用

一、面向过程

1.知识点

C语言编程就是一个面向过程的编程。遵循一个“从上往下”的程序设计

2.解决问题

1.提出问题，分析问题的处理流程，将大问题分解为多个小问题，如果小问题比较复杂，那就继续分解为更小的问题，然后解决这些一个一个的小问题来解决大问题，最后解决所有问题。

这个从问题出发，从上往下的解决过程，一步一步的解决问题，这种开发思路就被称为面向过程的设计思想，因为它主要是解决问题中的一个个的过程，比较符合我们解决问题的思路(做好这一步，再做下一步，直到做完所有步骤)

3.示例

效果一个飞机由玩家控制，可以发射子弹，从屏幕的上方可以随机掉落10架敌机，玩家控制的飞机可以发射子弹，击毁掉落的敌机。

飞机怎么实现：

在图形库窗口上面贴一个飞机的图片就是飞机了

飞机移动：

改变飞机的x，y坐标的值就可以，通过电脑上的按键操作

飞机发射子弹：

按键操作，生成子弹，子弹用一个坐标表示，然后贴一个子弹的图片表示子弹，贴在飞机的前面一点

敌机怎么掉落：

和飞机移动差不多，也是改变飞机的坐标(y坐标)

子弹碰撞飞机：

判断两张图片是否相交(数学问题)

实现图形库窗口
    飞机(结构体），子弹(结构体数组），敌机的坐标(结构体数组)
贴飞机
    按键操作(判断是移动飞机还是发射子弹)
移动敌机下落
    看有没有子弹发射出来，需要判断子弹是否和敌机相撞((如果相撞）两个一起消失，在对应的位置里面把两个坐标删掉)

4.优缺点

1.优点

1.程序结构简单，仅有三种基本的结构组成，顺序，选择，循环这三种基本结构，就能就可以解决任何问题，所以对于面向过程要专注于逻辑的学习，而不需要学习记忆很多的语法

2.把大问题分解为小问题解决，会使问题简单化

3.自上而下，一步一步的完善，也就是先从整体角度看待问题，然后列出解决问题需要的步骤，再逐步去完善，这样会让我们全面的考虑问题，使得我们对整个程序的逻辑结构清楚明了。

2.缺点

1.在面向过程的时候，数据和操作往往都是分离的，这样就会导致如果数据的结构发生改变，那么操作数据的函数就不得不重写，这个代价比较大

int fun(int& a , int& b)
{
    return a+b;
}
int mian()
{
    float a=1.3f,b=3.4f;
    fun(a,b)//不能通过，必须要修改fun函数，将int改为float
}

2.数据一般都是不具有封装性的，很多变量都是暴露出来的，容易被篡改

3.当多人协作开发的时候，那么问题就更多了，比如一些标识符重名，每个人之间的项目逻辑不清楚

4.在写一些小项目，一些逻辑的时候，用面向过程的方式来通常都能做到很好，但是涉及多人协作开发的时候，面向过程就显得力不从心了，所以面向对象就孕育而生了

二、面向对象

1.知识点

1.面向对象的程序设计是面向过程的继承和发展，程序对现实世界的抽象描述。现实中的基本单元的物体在程序中对应的基本单元就是对象

2.面向对象可以理解为：现实世界是由对象组成的，无论大小，万物皆对象

3.对象在程序中抽象为两个部分：

a.描述对象的状态或者属性的数据(变量)

b.描述对象的行为或者功能的方法(函数)

2.三大特征

封装：将客观事物封装成抽象的类，而类可以把自己的数据和方法暴露给可信的类或者对象，对不可信的类或对象则进行信息隐藏

继承：可以使用现有类的所有功能，并且无需重新编写原来的类即可对功能进行拓展；

多态：一个类实例的相同方法在不同情形下有不同的表现形式，使不同内部结构的对象可以共享相同的外部接口。

3.解决问题

1.实现一个类，这个类里面封装好了需要解决这个问题的数据和方法，通过类实例化一个对象，然后调用对象的功能，来完成这个问题

2.换句话来说就是找对象来解决这个问题，如果没有合适的对象，那么就自己写一个

4.面向对象的特点

1.面向对象将数据和行为结合在一起，共同表达一个数据

2.在面向过程的时候，数据和行为是分开的，当问题比较复杂或涉及多人开发，那么会导致拓展和维护很困难。而面向对象能解决这个问题，问题会被分解为一个个的对象，每一个对象有独立的数据和行为，修改或拓展某一个对象是并不会影响到其他对象

3.面向对象的封装性、继承及多态

封装：封装就是将属性(数据)私有化，提供公有的方法(行为)访问私有属性。通过封装可以对对象属性进行存取限制，提高了程序的维护性。

继承：继承可以在原来的对象基础上很快地产生新的对象，新的对象是一个全新的个体，但又有原来对象的特性。如同现实生活中的父子继承，儿子是一个全新的个体，但又继承了父亲这个个体的特点，比如：外貌，性格....

多态：多态是面向对象思想的核心。做到同一个窗口，使用不同的实例就能去执行不同的操作。方便了程序的设计

4.面向对象编程可以使代码维护方便，可扩展性好，支持代码重用技术

5.高内聚低耦合

1.利用面向对象思想的封装，继承和多态，可以设计出“高内聚，低耦合”的程序结构，可以让程序更加灵活，更容易扩展，从而轻松应对软件的扩展需求，降低维护成本。

2.高内聚，低耦合。这是软件工程中的一个概念，通常用来判断一个软件设计的好坏。

高内聚：一个软件模块是由相关性很强的代码组成，只负责单一任务，也就是常说的“单一责任原则”。

低耦合：在一个完整的程序中，模块与程序之间，尽可能保持相互独立，即每个模块尽可能独立完成特定的子功能，模块与模块之间的接口，尽可能的少而简单

三、类

1.知识点

1.类是什么

类是一种用户自定义数据类型，可以看做是C语言中结构体的升级版。类是由数据+功能构成的，也就是变量和函数，把变量和函数绑定在一起

2.对象是什么

通过类这种类型定义出来的变量称之为对象

2.类的定义

class 类名
{
    成员
}；
示例：//类：一个种类，具有什么属性和行为
class CStudent
{
    //私有属性
    int age;
    char name[20];
    float score;
   public:
    
    void initStudent(int x, float y, const char* s)
    {
        age = x;
        score = y;
        strcpy(name, s);
    }
    void showStudent()
    {
        cout << age << "\t" << score << "\t" << name << endl;
    }
    
    void setAge(int x)//给age赋值
    {
        age = x;
    }
    int getAge()
    {
        return age;
    }
    void speak()
    {
        cout<<"我爱交流"<
    }
}；
int main()
{
    CStudent stu;
    stu.study();
    CStudent stu;
    stu.setAge(18);
    cout << stu.getAge() << endl;
    
    CStudent* pstu = new CStudent;
    pstu->initStudent(18, 99.8f, "fly");
    pstu->showStudent();
    delete pstu;
    pstu = NULL;
​
​
}

1.类的大小计算和结构体一样，但是不算类中的函数，只算变量所占内存大小

2.类中可以不写成员，但还是要占1字节大小的内存

3.对象的定义

类名 对象名；
CStudent stu;
  

4.对象成员的访问

1.通过“ . "

stu.fun();

2.通过“ ->"访问2

CStudent* pstu=new CStudent;

pstu->fun();

不论是类中的变量或者是函数都可以用以上两种方式访问

5。类成员的访问属性

类中是有访问属性的，也就是类中的成员，不是你定义一个对象，就能随便访问的

1.public ——公有属性：

类外和类中都可以被直接访问，类外通过对象访问

2.protected——保护属性：

类中及派生类中可以被直接访问，类外需要通过对象调用公有属性的接口访问

3.private——私有属性：

只有类中可以访问，类外需要通过对象调用公用属性的接口访问

注意：

1.类中如果没有声明访问属性，那么默认是私有的

2.类中的变量，建议全部定义为私有属性，为了数据的安全性

3.访问属性的修饰范围：从当前声明开始，直到下一个声明结束，或者到类的末尾结束

4.访问私有属性下面的数据，那么在公有属性下面提供接口(访问类中的数据的函数)

6.结构体与类的区别

在.cpp文件中：结构体的默认属性是公有的，类的默认属性是私有的，其他地方，类中可以写的，结构体中也可以写

在.c文件中，结构体里面不能写函数，而且结构体定义变量需要带上关键字，在.cpp中不需要，而且.c中不能使用类

四、建模

两种方式：组合和聚合

1.组合

class CPU
{
public:
    CPU(const char* brand = "intel", const char *version = "i5")
    {
        this->brand = brand;
        this->version = version;
    }
private:
    string brand;//品牌
    string version;//型号
};
​
class computer
{
public:
    computer(const char* cpuBrand, const char* cpuVersion, int hardDisk, int memory):
        cpu(cpuBrand,cpuVersion)
    {
        this->hardDisk = hardDisk;
        this->memory = memory;
    }
private:
    CPU cpu;//computer和cpu是组合关系
    int hardDisk;//硬盘，单位G
    int memory;//内存，单位G
​
};
​
//一般对象成员使用初始化列表初始化，但是是类指针就不能这样初始化，必须在构造函数new出来一个对象。一定要记得在析构函数里释放new出来的成员

被拥有的对象（芯片）的生命周期与其拥有者（计算机）的生命周期是一致的。

计算机被创建时，芯片也随之创建。

计算机被销毁时，芯片也随之销毁。

拥有者需要对被拥有者负责，是一种比较强的关系，是整体与部分的关系。

具体组合方式：

1）被组合的对象直接使用成员对象。（常用）

2）使用指针表示被组合的对象，在构造函数中，创建被组合的对象；在析构函数中，释放被组合的对象。

就是说组合的形式是，可以使用对象，也可以是使用指针，但是使用指针必须在构造函数函数new出对象，在析构函数释放指针。这才叫做组合方式。

2.聚合

class voiceBox
{
​
};
​
class computer
{
public:
    computer() {};
    computer(const char* cpuBrand, const char* cpuVersion, int hardDisk, int memory):
        cpu(cpuBrand,cpuVersion)
    {
        this->hardDisk = hardDisk;
        this->memory = memory;
    }
​
    void addVoiceBox(voiceBox* box)
    {
        this->box = box;
    }
private:
    CPU cpu;//computer和cpu是组合关系
    int hardDisk;//硬盘，单位G
    int memory;//内存，单位G
​
    voiceBox *box;
​
};
​

​

聚合不是组成关系，被包含的对象，也可能被其他对象包含。

拥有者，不需要对被拥有的对象的生命周期负责。

//使用
voiceBox box;
computer c;
c.addVoiceBox(&box);
​
/*
就是对象c包含了对象box，可以暂时使用box，但是使用完之后，对象c死亡，而box并不会死亡，box可以被其他对象去使用，自己决定什么时候释放。
*/

​

五、查看类内存分布

vs 项目的命令行配置中添加： /d1 reportSingleClassLayoutclassName

项目-》属性-》c/c++-》命令行-》其它选项-》添加：

/d1 reportSingleClassLayoutclassName

className-就是你想查看类的类名