4.1类及其实例化

类（class）是面向对象程序设计（OOP）实现信息封装的基础。

类是用户定义类型，也称为类类型。

每个类包含数据说明和一些操作数据或传递消息的函数。类的实例称为对象。

C++的类有C的结构类型演变而来。本章首先介绍结构类型，然后讨论C++的类和对象。

5.1结构

结构由数目固定的成员构成。

各成员可以具有不同的数据类型。

一个结构变量在内存占有一片连续的存储空间。

5.1.1定义结构和访问结构

1.定义结构

可以用不同方法定义一个结构变量

（1）声明类型之后声明变量

（2）声明类型的同时声明变量

（3）直接声明结构类型变量

//C++的结构的数据成员可以默认有默认的值

//匿名结构体，限量版

#include <iostream>

struct MyStruct
{
    int num;
    double db = 10.8;//C++的结构的数据成员可以默认有默认的值
};

struct
{
    int num;
    double db = 10.8;//C++的结构的数据成员可以默认有默认的值
}sx, sy;//匿名结构体，限量版

void main()
{
    MyStruct s1;

    std::cout << s1.db << std::endl;//10.8
    
    system("pause");
}

一个结构类型的成员可以是另一个已定义的结构类型

struct MyStruct
{
    int num;
    double db = 10.8;
    void boss()//函数
    {

    }
};

struct
{
    int num;
    double db = 10.8;
    MyStruct boss1;//一个结构类型的成员可以是另一个已定义的结构类型
}sx, sy;

错误：不能实现的无穷递归结构

//error C2460: “MyStruct::sx”: 使用正在定义的“MyStruct”

struct MyStruct
{
    int num;
    double db = 10.8;
    MyStruct sx;//error C2460: “MyStruct::sx”: 使用正在定义的“MyStruct”
};

5.2类与对象

面向对象编程的程序基本单位是类。

类是数据和操作数据的函数的封装。

类的对象使用自己的方法完成对数据的操作。

类可以隐藏数据和操作细节，对象通过类接口与外部通信。

C面向过程管理进程

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <windows.h>

void open(const char *path, const int mode)//输入名称和打开模式，打开一个程序
{
    ShellExecuteA(0, "open", path, 0, 0, mode);
}

void all()//显示所有进程
{
    system("tasklist");
}

void closebyname(const char *name)//通过进程名，关闭进程
{
    char cmdstr[100] = { 0 };
    sprintf(cmdstr, "taskkill /f /im %s", name);
    system(cmdstr);
}

void closebypid(const int num)//通过PID，关闭进程
{
    char cmdstr[100] = { 0 };
    sprintf(cmdstr, "taskkill /pid %d", num);
    system(cmdstr);
}

void main()
{
    all();//显示所有进程

    open("notepad", 1);//输入名称和打开模式，打开一个程序

    all();//显示所有进程

    Sleep(2000);//暂停

    //closebyname("notepad.exe");

    int num;

    scanf("%d", &num);

    closebypid(num);//通过PID，关闭进程
        
    system("pause");
}

//C++类的继承实现代码重用，C的代码重用主要依赖函数

//类的封装实现权限，封装，数据与代码合为一体，C的封装主要是函数

//封装可以锁定代码的权限，锁定的数据的权限，避免被随意调用

//类的多态，一个接口根据实际需求完成很多不同的功能

C++面向对象管理进程

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <windows.h>

//C++类的继承实现代码重用，C的代码重用主要依赖函数
//类的封装实现权限，封装，数据与代码合为一体，C的封装主要是函数
//封装可以锁定代码的权限，锁定的数据的权限，避免被随意调用
//类的多态，一个接口根据实际需求完成很多不同的功能

class cmduse
{
private:
    char cmduser[100];//存储用户名
    char cmd[100];//存储命令
public:
    void setuser(const char *name)//设置用户名
    {
        strcpy(cmduser, name);
    }
    char *getuser()//返回用户名
    {
        return this->cmduser;
    }
    void open(const char *path, const int mode)//输入名称和打开模式，打开一个程序
    {
        ShellExecuteA(0, "open", path, 0, 0, mode);
    }
    void all()//显示所有进程
    {
        system("tasklist");
    }
    void closebyname(const char *name)//通过进程名，关闭进程
    {
        memset(this->cmd, 0, sizeof(this->cmd));
        sprintf(this->cmd, "taskkill /f /im %s", name);
        system(this->cmd);
    }
    void closebypid(const int num)//通过PID，关闭进程
    {
        memset(this->cmd, 0, sizeof(this->cmd));
        sprintf(this->cmd, "taskkill /pid %d", num);
        system(this->cmd);
    }
};

void main()
{
    cmduse cmduse1;

    cmduse1.setuser("hello");//设置用户名

    std::cout << cmduse1.getuser() << std::endl;//返回用户名

    cmduse1.open("calc", 1);//输入名称和打开模式，打开一个程序
    cmduse1.open("notepad", 1);//输入名称和打开模式，打开一个程序

    Sleep(2000);//暂停

    cmduse1.all();//显示所有进程

    cmduse1.closebyname("calc.exe");//通过进程名，关闭进程

    int pid = 0;
    
    std::cin >> pid;

    cmduse1.closebypid(pid);//通过PID，关闭进程

    system("pause");
}

//union本质也是一个类，可以内部有函数

//union同一对象内部数据是共享的，不同对象之间是独立的，代码是共享的

//union具备结构体所有功能

//时时刻刻共用体只有一个变量存在

//某些节约内存的类，需要用到共用体

#include <iostream>

//union本质也是一个类，可以内部有函数
//union同一对象内部数据是共享的，不同对象之间是独立的，代码是共享的
//union具备结构体所有功能
//时时刻刻共用体只有一个变量存在
//某些节约内存的类，需要用到共用体

union MyUnion
{
    int a;
    int num;
    double db;
    void go()
    {

    }
};

void main()
{
    std::cout << sizeof(MyUnion) << std::endl;//8

    MyUnion union1;//创建一个联合的对象

    union1.num = 20;//赋值

    std::cout << union1.num << std::endl;//20

    union1.db = 10.9;//赋值

    std::cout << union1.num << std::endl;//乱码

    system("pause");
}

//内部数据是共享的，不可以继承

//error C2570: “MyUnionA”: 联合不能有基类

union MyUnion
{
    int a;
private:
    int num;
    double db;
    void go()
    {

    }
};

//内部数据是共享的，不可以继承

union MyUnionA :public MyUnion//error C2570: “MyUnionA”: 联合不能有基类
{

};

//空类占一个字节，表明类的存在

//代码不计入sizeof

不能取类的地址，可以取类的对象的地址

//error C2275: “kong”: 将此类型用作表达式非法

#include <iostream>

class kong
{

};

//空类占一个字节，表明类的存在
//代码不计入sizeof

void main()
{
    std::cout << sizeof(kong) << std::endl;//1
    
    //std::cout << &kong << std::endl;//error C2275: “kong”: 将此类型用作表达式非法
    
    kong kong1;

    std::cout << &kong1 << std::endl;
    
    system("pause");
}