<C++> 类（1）：定义 访问修饰符 相关函数（接口 构造 析构） 链表类（简单应用）

一.引入

在C中 有数据 函数 算法 那么在C++中 把这些东西封装到一起 就有了类 即class

C是面向过程 C++则是面向对象（但其实C++也不是纯面向对象的 是介于面向过程和面向对象之间的）

类 是一种抽象的数据类型 这个类型定义的变量 就叫对象

二.类

1.定义：类是一组相同的具有相同属性和行为的对象的抽象

对象是具体的 类则是抽象的

①例如：定义一个类CPerson

class CPerson
{
    
};

在定义一个类的时候 要注意里面变量的命名规范 这里暂时还没有体现

②调用对象：

CPerson cp;

2.访问修饰符：对类中东西（变量和函数）的访问权限

①public：公共的

在任何地方都可以看到

②protected：受保护的

只有自己（本类）和子类（派生类）可以使用 也就是继承 继承这个问题在后面会详细说

③private：私有的

只有自己可以用

注意：在结构体当中 默认的访问修饰符是public 但是在类中 默认的访问修饰符是private

访问修饰符的作用范围 就是到下一个访问修饰符 或是作用域结束（遇见“}”）

三.相关函数

1.接口函数：

①接口：可以按特定要求做修改 提供了和外部交互的通道 使内外部可以进行交互的操作

②接口函数的主要作用是：如果想在类以外的地方想拿到类中protected或private的变量 就可以定义一个接口函数

③例：

#include<iostream>
#include<string>
using namespace std;

class CPerson
{
public:
    int m_nAge;
protected:
    bool m_nSex;
public:
    string m_nName;
public:
    void Show()
    {
        cout << m_nAge << endl;
        cout << m_nSex << endl;
        cout << m_nName << endl;
    }
public:
    int GetAge()
    {
        return m_nAge;
    }
    bool GetSex()
    {
        return m_nSex;
    }
    string GetName()
    {
        return m_nName;
    }
public:
    void SetAge(int nAge)
    {
        m_nAge = nAge;
    }
    void SetSex(bool nSex)
    {
        m_nSex = nSex;
    }
    void SetName(string nName)
    {
        m_nName = nName;
    }
};

int main()
{
    CPerson pc;

    pc.SetAge(0);
    pc.SetSex(1);
    pc.SetName("mby");
    
    cout << pc.GetAge() << endl;
    cout << pc.GetSex() << endl;
    cout << pc.GetName() << endl;
    pc.Show();

    return 0;
}

这段代码中 就有典型的两种接口函数 一种是拿值 一种是可以改值的

2.构造函数：

①类当中的成员变量都是不允许直接初始化的 所以用一种函数 给他们初始化 这种函数就叫构造函数

②功能：初始化成员属性

③特点：

与类同名 无返回值

如果没自己定义 那么系统有默认的无参的构造函数

一旦定义构造函数系统就不会在调用默认的构造函数

注意：构造函数会在创建对象时自动调用 创建对象一定会调用构造函数

同一个类中构造函数可以写多个 根据所传的参数列表去执行

④例：

#include<iostream>
#include<string>
using namespace std;

class CPerson
{
public:
    int m_nAge;
    bool m_nSex;
    string m_nName;
public:
    CPerson()
    {
        m_nAge = 1;
        m_nSex = 1;
        m_nName = "mby";
    }
    CPerson(string nName)
    {
        m_nAge = 1;
        m_nSex = 1;
        m_nName = nName;
    }
public:
    void Show()
    {
        cout << m_nAge << endl;
         cout << m_nSex << endl;
         cout << m_nName << endl;
    }
};

int main()
{
    CPerson pc1;
    pc1.Show();

    CPerson pc2("MBY");
    pc2.Show();

    return 0;
}

3.析构函数：

①功能：删除类内的指针成员在堆区分配的空间 自动清理内存

注意：没有堆区成员就不用写析构函数 当有new或malloc的时候写就可以了

如果在类成员中有指针 那么构造函数中需要new空间 赋值用strcpy_s

②特点：

与类同名 前面加一个“~”

无返回值 无参数

析构函数一个类只能有一个 没写也会有默认的什么都不做的析构函数

③析构函数会在：当对象的声明周期结束的时候先调用析构函数 删除指针成员指向的空间 然后回收对象

4.总结：构造函数和析构函数

①构造和析构是相反的

②共同特点：自动调用（以防出现内存泄露的问题）

5.虚析构：

①引入：

普通函数的调用是看 调用指针的类型

虚函数的调用是看 虚函数列表中装的是谁

②实例：父类析构virtual ~CFather(){ .. }

父类析构的作用：在多态中 通过父类的指针删除一个子类的对象

其实正常大部分情况下 父类的析构都应该是虚析构

四.链表类

1.整个链表是一个对象 成员包括：结点 头指针 尾指针 长度

2.成员函数功能实现：构造 析构 尾插 头删 输出链表

3.封装的好处：提高了安全性 有利于后期修改 维护

那么所有的功能既然被封装到了一个类中 就要用对象去调用

4.代码：

#include<iostream>
#include<string>
using namespace std;

class CList
{
private:
    struct Node
    {
        int nValue;
        Node* pNext;
    };
    Node* m_pHead;
    Node* m_pEnd;
    int m_nSize;
public:
    CList()
    {
        m_pHead = NULL;
        m_pEnd = NULL;
        m_nSize = NULL;
    }
    ~CList()
    {
        Node* pDel = 0;
        while(m_pHead)
        {
            pDel = m_pHead;
            m_pHead = m_pHead -> pNext;
            delete pDel;
            pDel = NULL;
        }
        m_pEnd = NULL;
        m_nSize = 0;
    }
public:
    void PushBack(int nValue)
    {
        Node* pNode = new Node;
        pNode -> nValue = nValue;
        pNode -> pNext = NULL;
        if(m_pHead == NULL)
        {
            m_pHead = pNode;
            m_pEnd = pNode;
        }
        else
        {
            m_pEnd -> pNext = pNode;
            m_pEnd = pNode;
        }
        ++ m_nSize;
    }
    void PopFront()
    {
        if(m_pHead == NULL)
        {
            return ;
        }
        if(m_pHead -> pNext == NULL)
        {
            delete m_pHead;
            m_pHead = NULL;
            m_pEnd = NULL;
            m_nSize = 0;
        }
        
        Node* pDel = m_pHead;
        m_pHead = m_pHead -> pNext;
        delete pDel;
        pDel = NULL;
        -- m_nSize;
    }
    void Show()
    {
        Node* pMark = m_pHead;
        while(pMark)
        {
            cout << pMark -> nValue << " ";
            pMark = pMark -> pNext;
        }
        cout << "size:" << m_nSize << endl;
    }
};

int main()
{

    CList a;
    a.PushBack(1);
    a.PushBack(2);
    a.PushBack(3);
    a.PushBack(4);
    a.Show();

    a.PopFront();
    a.Show();
     
    return 0;
}

5.延伸：链表管理学生管理

#include<iostream>
#include<string>
using namespace std;

class CStudent
{
private:
    int m_nAge;
    bool m_bSex;
    string m_strName;
public:
    CStudent()
    {
        m_nAge = 1;
        m_bSex = true;
        m_strName = "毛不易";
    }
public:
    void SetStudentInfo(int nAge,bool bSex,string strName)
    {
        m_nAge = nAge;
        m_bSex = bSex;
        m_strName = strName;
    }
    void ShowStudentInfo()
    {
        cout << "Age:" << m_nAge << " Sex:" << m_bSex << " Name:" << m_strName << endl;
    }
};

class CList
{
private:
    struct Node
    {
        CStudent nValue;
        Node* pNext;
    };
    Node* m_pHead;
    Node* m_pEnd;
    int m_nSize;
public:
    CList()
    {
        m_pHead = NULL;
        m_pEnd = NULL;
        m_nSize = NULL;
    }
    ~CList()
    {
        Node* pDel = 0;
        while(m_pHead)
        {
            pDel = m_pHead;
            m_pHead = m_pHead -> pNext;
            delete pDel;
            pDel = NULL;
        }
        m_pEnd = NULL;
        m_nSize = 0;
    }
public:
    void PushBack(CStudent& nValue)
    {
        Node* pNode = new Node;
        pNode -> nValue = nValue;
        pNode -> pNext = NULL;
        if(m_pHead == NULL)
        {
            m_pHead = pNode;
            m_pEnd = pNode;
        }
        else
        {
            m_pEnd -> pNext = pNode;
            m_pEnd = pNode;
        }
        ++ m_nSize;
    }
    void PopFront()
    {
        if(m_pHead == NULL)
        {
            return ;
        }
        if(m_pHead -> pNext == NULL)
        {
            delete m_pHead;
            m_pHead = NULL;
            m_pEnd = NULL;
            m_nSize = 0;
        }
        
        Node* pDel = m_pHead;
        m_pHead = m_pHead -> pNext;
        delete pDel;
        pDel = NULL;
        -- m_nSize;
    }
    void Show()
    {
        Node* pMark = m_pHead;
        while(pMark)
        {
            pMark -> nValue.ShowStudentInfo();
            pMark = pMark -> pNext;
        }
        cout << "size:" << m_nSize << endl;
    }
};

int main()
{
    CStudent st1;
    st1.SetStudentInfo(1,true,"毛不易");
    CStudent st2;
    st2.SetStudentInfo(2,true,"还是毛不易");

    CList a;
    a.PushBack(st1);
    a.PushBack(st2);
    a.Show();

    a.PopFront();
    a.Show();
     
    return 0;
}