C艹的类（极简版）

class S {
    S(){//是的这就是构造器

    }
    ~S(){
        printf("析构函数；对象被销毁时会执行");
    }
    virtual void print() = 0;//是的这就是接口。。。。
};

class SS : public S {
public:
    static SS &Get() {
        static SS ii;
        return ii;
    }

    void H() {}

    virtual void print() {};//virtual是让这个方法可以被重写
};

class SSS : public SS {
    void print() override {//override是确定这个方法重写了上面的一个方法
        printf("hhh");
    }
};

与Java不同，在c++中new出来的实例需要使用delete来自行删除这个对象

而直接建立的实例会随着离开作用域而销毁

同时拷贝一个现有对象时需要注意，直接进行=来将其赋值是一个地址（浅层拷贝）

同时，防止多态数组的内存泄露

虚析构函数处理多态数组的内存泄露

通过将基类的析构函数声明为虚函数，可以确保在删除基类（父类）指针时，派生类的析构函数也会被正确调用

virtual ~XXX(){};

会增加额外的性能消耗，但是安全

要实现深层拷贝需要重载构造函数

注意点

strlen函数取得字符串的长度需要include "string.h"

memcpy函数将内容复制过去

深层拷贝的关键构造函数，按照这个类的参数成员分别写出拷贝

利用折构函数每当删除一个对象时一起将对应的char*占用空间释放

#include <iostream>
#include "string.h"
class Copy {
private:
    char* name;
    unsigned int name_math;//unsigned无负int
public:
    Copy(char* name2){//是的这就是构造器
        name_math=strlen(name2);//strlen函数取得字符串的长度需要include "string.h"
        name=new char[name_math+1];//加一多一个空位来存放终止0
        memcpy(name,name2,name_math);//memcpy函数将内容复制过去
        name[name_math]=0;
    }
    Copy(Copy& other):name_math(other.name_math){//深层拷贝的关键构造函数，要按照这个类的参数成员分别写出拷贝
        name=new char[name_math+1];//建了个新的
        memcpy(name,other.name,name_math);//同上
        name[name_math]=0;
    }
    ~Copy(){
        printf("\ndelete name");
        delete name;//每当删除一个对象时一起将对应的char*占用空间释放
    }
    void getName(){
        std::cout <<"\n"<<name;
    }
};

int main(){
    Copy prin("0ranfey0");
    prin.getName();
    Copy pppp=prin;
    pppp.getName();
    prin.getName();
}