面向过程与面向对象的编程模式

C管理进程:

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.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)
{
    char cmdstr[100] = { 0 };
    sprintf(cmdstr, "taskkill /pid %d", num);
    system(cmdstr);
}


void main1()
{
    all();
    open("notepad", 1);
    all();
    Sleep(2000);
    int  num;
    scanf("%d", &num);
    closebypid(num);
    //closebyname("notepad.exe");
    system("pause");

}


struct fu
{
    int a;
    int b;

};

//a+ bi,
struct fu  add(struct fu  fu1, struct fu  fu2)
{
    struct fu  fu3;
    fu3.a = fu1.a + fu2.a;
    fu3.b = fu1.b + fu2.b;
    return fu3;
}

void   main3()
{
    // 数据可以随便被别人访问，可以随便被修改
    struct fu  fu1 = { 3, 4 };
    struct fu  fu2 = { 13, 4 };
    fu1.a += 3;
    struct fu  fu3 = add(fu1, fu2);
    printf("%d+%di", fu3.a, fu3.b);
    getchar();
}

Cpp面向对象管理进程:

 

/* Cpp面向对象管理进程 */

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

#include<iostream>
#include<string>
#include<windows.h>

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,100);// 清空字符串

        sprintf(this->cmd,"taskkill /f /im %s",name);
        
        system(this->cmd);
    }

    void closebypid(const int num)
    {        
        memset(this->cmd,0,100);// 清空字符串

        sprintf(this->cmd,"taskkill /pid %d",num);

        system(this->cmd);
    }


};

int main()
{
    cmduse cmduse1;

    cmduse1.setuser("wuxl");

    std::cout << cmduse1.getuser() << std::endl;

    cmduse1.open("calc",1);

    cmduse1.open("notepad",0);

    Sleep(2000);

    cmduse1.all();

    cmduse1.closebyname("calc");

    int pid;
    cin >> pid;

    cmduse1.closebypid(pid);// 根据编号关闭

    //closebyid(100);

    std::cin.get();
    std::cin.get();
    return 0;
}

// 封装可以实现代码的权限  不可以随便调用

// -------------------------------------------------------


struct fu
{
    int a;
    int b;
};

struct fu add(struct fu fu1,struct fu fu2)
{
    struct fu fu3;
    fu3.a = fu1.a+fu2.a;
    fu3.b = fu1.b+fu2.b;
    return fu3;

}

void main()
{
    //int a;
    //int b;
    //a = b = 0;// a+bi

    // 数据可以随便被别人访问 和修改
    struct fu fu1 = {3,4}

    struct fu fu2 = {13,4}

    //struct fu fu3

    fu1.a += 3;
    struct fu fu3 = add(fu1,fu2);
    printf("%d+%di",fu3.a+fu3.b);
    

    getchar();
}
//-----------------------------------------------------

class 
{
public:
    
    void seta(int a)
    {
        // 接口
        this->a = a;
    }

    int geta()
    {
        return this->a;
    }

    void setb(int b)
    {
        // 接口
        this->b = b;
    }

    int getb()
    {
        return this->b;
    }
private:
    int a;
    int b;
    char password[32];
}myab;

void  main()
{
//    myab.geta = 3;

    myab.seta(10);
    // 封装可以解决：
        // 类，代码与数据 一体化
        // 代码的封装，限定代码谁可以执行谁不可以执行的权限
        // 数据的封装，防止数据被意外修改

}