05_类与对象、Class Struct Union、类中的函数指针

【目录】

一、 C++结构体 2
１、 结构体里面的成员及方法默认是公有的； 2
２、 结构体里面的成员可以默认初始化；（c不可以） 2
３、 匿名结构体不可以默认初始化，这样是为了只创建一个对象； 2
４、 结构体的数据相互独立，占用一片连续的内存空间； 2
５、 结构体内部不能定义自己；（可以定义指针，形成链表） 2
６、 C与c++同种类型的结构体可以整体赋值； 2
二、 类与对象 2
１、 C++类的继承实现代码重用，C重用函数； 2
２、 类的封装实现权限，封装，数据与代码合为一体；C封装主要是函数； 2
３、 封装可以锁定代码的权限，锁定的数据的权限，避免被随意修改； 2
４、 类的多态，一个接口根据实际需求完成很多不同的功能； 2
５、 封装可以实现代码权限，不可以随便调用； 2
６、 封装解决的问题： 2
三、 Class Struct Union 4
１、 Class 4
２、 Struct 4
３、 Union 4
四、 const mutable explicit 5
五、 拷贝构造 5
１、 delete可以禁用默认生成的函数，禁用构造函数可以实现类无法实例化； 5
２、 定义类时，在拷贝构造后加=delete，表示禁用拷贝构造，可以实现禁止别人拷贝你的类对象； 5
３、 定义类时，在构造函数后边加=default表示默认存在。 5
４、 类默认是浅拷贝，深拷贝必须自己实现。 5
六、 类中引用& 5
七、 类中的函数 6
１、 类中的常规函数void (my::*p1)() = &my::run ; 6
２、 类中的静态函数void (*p2)() = &my::go ; 6

一、C++结构体

  １、结构体里面的成员及方法默认是公有的（类是默认私有的）；
  ２、结构体里面的成员可以默认初始化；（c不可以）
  ３、匿名结构体不可以默认初始化，这样是为了只创建一个对象；
  ４、结构体的数据相互独立，占用一片连续的内存空间；
  ５、结构体内部不能定义自己；（可以定义指针，形成链表）
  ６、C与c++同种类型的结构体可以整体赋值；

二、类与对象

  １、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);    }};void main(){    cmduse cmduse1;    cmduse1.setuser("yincheng");    std::cout << cmduse1.getuser() << std::endl;    cmduse1.open("calc",1);    cmduse1.open("notepad",0);    Sleep(2000);    cmduse1.all();    cmduse1.closebyname("calc.exe");    int pid;    std::cin >> pid;    cmduse1.closebypid(pid);//根据编号关闭    std::cin.get();    std::cin.get();}

三、Class Struct Union

  １、Class
      ①．成员和方法默认情况下是私有的；
  ２、Struct
      ①．成员和方法默认情况下是公有的；
  ３、Union
      ①．成员和方法默认是公有的，且不可以改变，共享同一块内存空间，拥有的起始地址都是一样的；
      ②．本质也是一个类，可以内部有函数；
      ③．内部数据是共享，不同对象之间是独立的，代码是共享；
      ④．也具备结构体所有功能；
      ⑤．某些节约内存的类需要用到共用体；
      ⑥．内部数据是共享内存，不可以继承；
      ⑦．时时刻刻共用体仅有一个变量存在

#include<iostream>//union  本质也是一个类，可以内部有函数，//union,内部数据是共享，不同对象之间是独立的，代码是共享//union,也具备结构体所有功能//某些节约内存的类需要用到共用体union MyUnion{    int num;    double db;    void go()   {    }};//内部数据是共享内存，不可以继承union MyUnionA {    int num;    double db;    void go()   {    }};void main(){    std::cout << sizeof(MyUnion) << std::endl;    MyUnion union1;//  union1.db = 10;    union1.num = 20;    std::cout << union1.num << std::endl;    union1.db = 10.9;//时时刻刻共用体仅有一个变量存在    std::cout << union1.num << std::endl;    std::cin.get();}

四、const mutable explicit

五、拷贝构造

  １、delete可以禁用默认生成的函数，禁用构造函数可以实现类无法实例化；
  ２、定义类时，在拷贝构造后加=delete，表示禁用拷贝构造，可以实现禁止别人拷贝你的类对象；
  ３、定义类时，在构造函数后边加=default表示默认存在。
  ４、类默认是浅拷贝，深拷贝必须自己实现。

六、类中引用&

#include<iostream>class my {    public:        int &age ;    public:        my( int a ):age(a){        }        ~my(){        }};int main( int argc , char** argv ) {    int num = 5 ;    my m1( num ) ;    std::cout<<m1.age<<std::endl;    /*                        这里输出是地址，如果换成    std::cout<<m1.age；输出是内容，    差别就在于最后的std::endl;    */    std::cout<<std::endl;    system("pause") ;    return 0 ;}

（己注：endl有刷新缓存的作用，所以刷新缓存后内容就不存在了。这里涉及到成员变量的生命周期，当num的变量传入my类的构造函数时会创建一个副本，内容跟num一样，但是地址不一样，这个副本num的生命周期就跟构造函数同生共死，所以如果不调用endl的话，在缓存中有这个副本 的内容，age就可以打印出来，否则不行）

七、类中的函数指针：

  １、类中的常规函数void (my::*p1)() = &my::run ;

#include<iostream>class my {    public:        int &age ;    public:        my( int a ):age(a){        }        ~my(){        }        void run() {            std::cout<<"run"<<std::endl ;        }        static void go() {            std::cout<<"go"<<std::endl ;        }};int main( int argc , char** argv ) {    int num = 5 ;    my m1( num ) ;    void (my::*p1)() = &my::run ;    void (*p2)() = &my::go ;(m1.*p1)() ;    system("pause") ;    return 0 ;}

  ２、类中的静态函数void (*p2)() = &my::go ;

#include<iostream>class my {    public:        int &age ;    public:        my( int a ):age(a){        }        ~my(){        }        void run() {            std::cout<<"run"<<std::endl ;        }        static void go() {            std::cout<<"go"<<std::endl ;        }};int main( int argc , char** argv ) {    int num = 5 ;    my m1( num ) ;    void (my::*p1)() = &my::run ;    void (*p2)() = &my::go ;(m1.*p1)() ;P2() ;    system("pause") ;    return 0 ;}