类与对象（上-1）

1、面向过程和面向对象的初步认识

 //C语言是面向过程的，关注的是过程（分析出求解问题的步骤，通过函数调用逐步解决问题）
    //C++是基于面向对象的，关注的是对象（将一件事情拆分成不同的对象，靠对象之间的交互完成）
      //注：C++不是纯面向对象，可以面向对象和面向过程混编，其兼容C语言。

   //举例解释：面向过程和面向对象
   //面向过程：
   //关注：点餐、接单、送餐过程，关注流程函数的实现。

   //面向对象：
   //关注：用户、商家、骑手。关注对象之间的关系。

2、类的引入

2.1 C++兼容C struct的语法

struct Stack
{
    int* a;
    int top;
    int capacity;
};

void StackInit(struct Stack* ps);
void StackPush(struct Stack* ps,int x);
void StackPop(struct Stack* ps);

int main()
{

    return 0;
}

2.2 C++还将struct 升级成了类

//与结构体不同的是，类这种结构体包括了：成员函数（方法）和成员变量


struct Stack
{
 //成员函数
    void Init()
    {
        a = nullptr;
        top = capacity = 0;
    }
    void Push(int x)
    {
        //........
    }
    void Pop()
    {
        //.........
    }

 //成员变量
    int* a;
    int top;
    int capacity;
};

int main()
{
    struct Stack* st1;
    Stack st2; //(两种定义栈的方法都可以)

    st2.Init(); //访问成员函数
    st2.Push(1);
    st2.Push(2);
    st2.Push(3);

    return 0;
}

3、类的定义

// C++中定义 类 更喜欢用class

//类的两种定义方式：
//第一种：声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成 内联函数 处理（相当于给类内定义的函数加了inline,符合inline的条件，即编译指令比较少）。
//第二种：声明放在 .h 文件中，类的定义放在 .cpp 文件中。

3.1 第一种：声明、定义都放在类里

class Stack
{
public:
 //成员函数
    void Init()
    {
        a = nullptr;
        top = capacity = 0;
    }
    void Push(int x)
    {
        //........
    }
    void Pop()
    {
        //.........
    }
private:
 //成员变量
    int* a;
    int top;
    int capacity;
};

int main()
{ 
    Stack st2; 
    st2.Init(); //访问成员函数
    st2.Push(1);
    st2.Push(2);
    st2.Push(3);

    //st2.top = 3;

    return 0;
}

3.2 第二种：声明放在 .h 文件中，类的定义放在 .cpp 文件中

Test.cpp

#include "f.h"
int main()
{
    Stack st1;
    st1.Init();
    st1.Push(1);
    st1.Push(2);
    st1.Push(3);

    return 0;
}

f.h

#include <iostream>
using namespace std;

class Stack
{
public:
    //成员函数
    void Init();
    void Push(int x);
    void Pop();
private:
    //成员变量
    int* a;
    int top;
    int capacity;
};

f.cpp

#include "f.h"

void Stack::Init()
{
    a = nullptr;
    top = capacity = 0;
}
void Stack::Push(int x)
{
    //........
}
void Stack::Pop()
{
    //.........
}

最后，类的定义总结

//类的定义总结：
//（1）对于类中的小函数，想成为inline,就直接在类里面定义即可。
//（2）对于类中的大函数，应该将函数的声明与定义分离（这样便于看函数的概况）

4、类的访问限定符及封装

4.1 类的访问限定符 (限定的是类外面对类成员的使用)

//                public(公有)    {类里（√），类外（√）}
//  访问限定符：  protected(保护) {类里（√），类外（×）}
//                private(私有)   {类里（√），类外（×）}  注：此处protected 和 private 是类似的，到继承以后才有区别 

// 说明：
// 1、class的默认访问权限为:private, struct的默认访问权限为:public(因为struct要兼容C的语法)
// 2、访问权限作用域指的是：从该访问限定符出现的位置开始，到下一个访问限定符出现为止。

4.2 类的封装

//将类的成员都封装起来，用private或protected限制成员变量，无法在类外直接访问。而是通过用public公开的成员函数来访问数据，使得访问数据
//的过程更加规范、准确。

//C语言 -> 没办法封装，既可以规范使用函数访问数据，也可以直接访问数据——不规范
// C++  -> 封装了，  必须规范使用函数访问数据，不能直接访问数据——规范

//例：
#include <iostream>
using namespace std;

class Stack
{
public:
    //成员函数
    void Init()
    {
        a = nullptr;
        top = capacity = 0;
    }
    void Push(int x)
    {
        //........
    }
    void Top()
    {
        //........
    }

private:
    //成员变量
    int* a;
    int top;
    int capacity;
};

int main()
{
    Stack st2;
    st2.Init(); //访问成员函数
    st2.Push(1);

    //cout << st2.Top() <<endl;      //成员函数public，可以通过成员函数访问数据
    //cout << st2.a[st2.top] <<endl; //成员变量private,不可以直接访问数据
    return 0;
}

5、类的作用域

// 类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员，需要使用 :: 作用域解析符指定成员所属的类域。
//例如：
void Stack::Init()
{
    a = nullptr;
    top = capacity = 0;
}