2021-11-06

2021-11-06 C++虚析构、static、const

文章目录

• C++虚析构、static、const
• 一.虚析构
• • 1.写法 ：
  • 2.什么时候用到虚析构
• 二.c++ static
• • 1.static 特点 ：
  • 2.static修饰成员属性
  • 3.static 修饰成员方法
• 三. c++ const
• • 1.const 修饰成员属性
  • 2.const 修饰的成员方法
  • 3.const修饰成员方法，访问类内其他成员属性与成员方法
• C语言const与C++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.存放在数据段 
    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++ < 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修饰的成员都放在只读数据段