C++类

类是以一个将各种类型的数据存储在一起的结构，形成属于自定义命名的类型。

一、类的基本结构

实例一（1）：大致结构

class Player //类命名"class <name> {}"
{
public: //访问修饰符
    // 以下三个定义为 成员变量
    string Name; //自定义字符串
    int Age; //自定义int
    int Score; //自定义int
};

实例一（2）：调用演示

int main()
{
    // 使用类来生成1,2这两个玩家

    // 局部变量生成
    Player player1; //定义类player1
    player1.Name = "ChooseQiu"; //将player1中的Name赋为字符串"ChooseQiu"
    player1.Age = 20; //将player1中的Age赋为int值20
    player1.Score = 100; //将player1中的Score赋为int值100

    // 分配new堆内存生成
     // player2->Name 相当于 (*player2).Name
    Player* player2 = new Player; //定义指针player2分配Player大小内存
    player2->Name = "ChooseQiu"; //将地址player2中的Name赋为字符串"ChooseQiu"
    player2->Age = 20; //将地址player2中的Age赋为int值20
    player2->Score = 100; //将地址player2中的Score赋为int值100

     // player1的Age,Score都存在栈上，但假如其中有new的内容，仍然会在堆上。
     // player2的Age,Score都存在堆上，即使 player2->Age = 9; 看上去是直接分配的值，但player2本身在堆上
     // Name作为string比较特殊，每种语言会有不同的存储方式。
}

二、访问修饰符：

C++ 提供了三个关键字：
public (公有)
private (私有)
protected (受保护)

为了方便理解，我们可以把一个类（Class）想象成家：

修饰符	类比	谁可以访问	用途
public	大门	所有人（类的内部、子类、外部代码）	对外提供的接口函数
private	客厅	你和你的室友（类的内部、子类）	仅限家族内部（继承体系）使用的数据
protected	卧室	只有你自己（仅限本类内部）	核心数据、不想被随意修改的变量

三、使用类

1.类中可以自定义很多不同的函数，其中有一些固定的格式为类的构造

实例二（1）：定义类与构造实例

class Player //定义类Player
{
public: //public修饰
    string Name; //自定义字符串 Name
    int Age; //自定义int Age
    int Score; //自定义int Score
public: //public修饰

    // 默认构造，不写编译器会自动生成
    Player() 
    {
        // 默认构造函数最好给个默认值
        Name = "defult"; //赋默认值"defult"
        Age = 0; //赋默认值0
        Score = 0; //赋默认值0
    }

    //注意以下内容中大小写区分，分别代表不同内容

    // 带参构造，像函数一样可以提供参数
     // 写了带参构造，如果不写默认构造，则无法使用默认构造
    Player(string name, int age, int score)
    {
        Name = name; //赋默认值"name"
        Age = age; //赋默认值age
        Score = score; //赋默认值score
    }

    // 拷贝构造
     // 变量时： Player player2 = player1;
     // 指针时： Player* player2 = new Player(*player1);
     // 注意 Player* player2 = player1; 是指针赋值，不是变量赋值，无法触发拷贝构造
    Player(const Player& other)
    {
         //以下内容赋值取决于拷贝源
        Name = other.Name; 
        Age = other.Age;
        Score = other.Score;
    }

    // 析构函数
     //删除占用的内存，并且防止内存泄露
     // delete player;
    ~Player()
    {
        // 一般在这里面处理未释放的成员堆内存和未清空的指针
        Name = "";
        Age = 0;
        Score = 0;
    }
};   

实例二（2）：基于上述类定义的构造使用

int main()
{
// 默认构造
Player* player2 = new Player();

// 带参构造
Player* player1 = new Player("ChooseQiu", 20, 100);
    //player1 -> {Name = "ChooseQiu",Age = 20,Score=100}

// 拷贝构造
Player* player3 = new Player(*player2);

// 析构
delete player3; //清空player3

// 存在数组中
// 错误的写法：Player* playerArray = new Player[10];
// 不是要开10个player的内存，而是开10个放置player指针的位置
Player** playerArray = new Player* [10];
playerArray[0] = player1;
playerArray[1] = player2;
}

2.类中可以自定义很多不同的函数，为成员函数

实例三（1）：成员函数

#include <iostream>

class Player
{
public:
    string Name;
    int Age;
    int Score;
public:
    void print() //成员函数 输出文字Name/Age/Score
    {
        std::cout << Name << " / " << Age << " / " << Score << std::endl;
    }

    void print(string from) //成员函数 输出文字from/Name/Age/Score
    {
        std::cout << from << " / " << Name << " / " << Age << " / " << Score << std::endl;
    }

    Player(string name, int age, int score) //带参构造
    {
        Name = name;
        Age = age;
        Score = score;
    }
};

实例三（2）：执行成员函数

int main()
{
    Player* player1 = new Player("ChooseQiu", 9, 100); //带参构造
    player1->print(); //执行void print()
    player1->print("GM"); //执行void print(string from)
}

实例三（3）：执行结果

ChooseQiu / 9 / 100
GM / ChooseQiu / 9 / 100

四、类内容扩展：使用实例List