C++ 虚析构virtual、static关键字、const关键字

一.虚析构

1.写法 ：

在 析构函数前面加一个virtual 关键字 例如 ： 以下写法

class Base()
{
    public:
        Base(){}
        // 虚析构
        virtual ~Base(){}
}
    //--------------------------

2.什么时候用到虚析构

子类对象赋值给父类对象或者多态的时候，用父类指针指向子类对象，在delete父类指针的时候,不会调用子类的析构函数
解决方法是在父类析构函数前面添加 virtual 关键字 //--------------------------

3.例子：

 class Base//父类
    {
    public:
        Base(){cout << "Base" << endl;}
        virtual ~Base()
        {
            cout << "~Base" << endl;
            delete []Bname;
        }
    private:
        void show()
        {
            Bname = new char[100];
        }
        
    private:
        char *Bname;
    };

    class Child : public Base//子类
    {
    public:
        Child(){cout << "child" << endl;}
        virtual ~Child()
        {
            cout << "~Base" << endl;
            delete []Cname;
        }
    private:
        void show()
        {
            Cname = new char[100];
        }
        
    private:
        char *Cname;
    };

    int main()
    {
        // 只要是子类赋值给父类指针，父类的析构函数必须要加 virtual关键字，否则delete父类对象的时候
        // 不会调用子类的析构函数
        while(1)
        {
            Base *bs = new Child();
            delete bs;
        }
    }

二.c++ static关键字作用

1.static 特点 ：

1.存放在数据段.bss
2.生命周期一直到进程结束
3.数据只分配一次
4.static修饰的全局变量作用域在本文件有效(文件作用域)
5.static修饰的变量默值认为0
//--------------------------------------

2.static修饰成员属性

1.static 修饰的成员属性与类不同空间，所以不能在类内初始化，在类外初始化 初始化方式

class Base
{
    public :
        static int a;
}
// 静态成员属性类外初始化
int Base::a = 10;

2.const 与 static 一起修饰的成员属性(变量)是可以在类内初始化的

class Base
{
    public :
        const static int b = 10; // 正确的
}

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

3.static 修饰成员方法

1.实现方式 static 成员类型 成员名(参数)
例如：

static int show(int a)
{

}

2.static 修饰的成员方法不能使用类里面的非静态成员，因为他们不属于同一个空间
3.static 修饰的成员方法可以使用类里面的static修饰的成员属性，或成员方法
4.static 的主要作用其实是可以不创建对象，直接通过 类名::成员属性或者成员方法实现(用的最多)
例如:

class Mat
 {
     public:
        static void add(){}
        static void mul(){};
        static int number;
 };
 int main()
 {
     Mat::add();
     Mat::number;
 }

5.static 修饰的成员方法类外实现

class Base
{
public:
    static void show();
}; 
// static 方法类外实现，不需要加static关键字，类内声明的时候添加即可
void Base::show()
{
    cout << "static show" << endl;
}

int main()
{
    Base::show();
}
//--------------------------------------

三. c++ const关键字作用

1.const 修饰成员属性

1.将成员属性设置为const修饰以后，需要构造参数列表初始化来赋值，类里面也可以赋值(不建议)
2.修饰后的成员属性的内容不能修改

2.const 修饰的成员方法

1.const 修饰的成员方法其实是修饰this指针，所以不能修改类里面的成员

class Base
{
public:
int a; 

	void show() const 
	{
	   this->a++; // 错误的，const修饰的是this指针 
	   cout << this->a << endl; // 正确的
	};
};

2.const 修饰的方法是放在只读数据段，所以函数访问的时候，只能访问const修饰的其他函数
例如:

class Base
{
    public:
        void func()
        {

        }
        void print() const 
        {

        }
        
        void show() const 
        {
            func()// 错误的
            print() // 正确的  //专一性
        };
};
//--------------------------------

3.const修饰成员方法

访问类内其他成员属性与成员方法

1.const修饰的成员方法,const修饰show（）其实是修饰this指针,修饰的作用域只局限于show()函数
2.const修饰的成员方法，是可以访问类里面的const修饰的成员属性也可以访问类里面的非const修饰的成员属性
3.const修饰的成员方法，是可以访问类里面的const修饰的成员方法，不可以访问类里面的非const修饰的成员方法

例子：

class Base
 {
 public:
     Base(int a) : number(a){}
 public:

// const修饰的成员方法,const修饰show（）其实是修饰this指针,修饰的作用域只局限于show()函数
// const修饰的成员方法，是可以访问类里面的const修饰的成员属性也可以访问类里面的非const修饰的成员属性
// const修饰的成员方法，是可以访问类里面的const修饰的成员方法，不可以访问类里面的非const修饰的成员方法

void show(int b) const
    {
        cout << this->age++ <<endl;
        cout << number << endl;
        b++;
        print(); // 只读数据段
    }
    void print() const
    {
        age++;
    }
public:
    //const int number = 10;
    const int number; // 只读数据段
    int age;
};

const int a;  // 只读数据段

int main()
{
    Base bs(10);
    bs.show(20);
    const int a; // 栈
}
//-----------------------------

C语言const与C++const不同点

在C语言const修饰的局部变量是放在栈区，全局变量是放在只读数据段 在C++语言中const修饰的成员都放在只读数据段