学习类中的const和static类型

上代码，该说的都在代码及注释里：

#include <stdlib.h>
#include <stdio.h>
#include <string>

using namespace std;

class BaseClass
{
protected:
    // 普通变量
    int data;

    // 地址不可变，但内容可变的常量
    // 必须在初始值设定项列表中初始化
    char* const name;
private:

    // 内容不可变常量
    // 必须初始值设定项列表中初始化
    const int id;

    // 类的全部实例共享的变量
    // 在任意函数中都可以赋值，但是，这样做不符合其static的意义
    // 合理的使用方式是在类外初始化，否则没有合适的赋初值的方式
    static int count;

    // 类的全部实例共享的常量
    // 不能在初始值设定项列表中初始化，初始值设定项列表只能处理非static类型的成员
    // 不能在任何函数中赋值
    // 所以只能类外初始化
    static const int max;
public:
    // 关于“是不是所有成员函数都可以声明称虚函数的问题”
    // 下面的语句不合法！
    // error C2633: “BaseClass”:“inline”是构造函数的唯一合法存储类
    // virtual BaseClass(){}
    
    // 关于“const类型的成员变量初始化的问题”
    // 下面的语句不合法！
    // error C2758: “BaseClass::idx和BaseClass::name””: 必须在构造函数基/成员初始值设定项列表中初始化
    // BaseClass(){}

    // 合法定义
    inline BaseClass(const char* str): id(count++), name((char*)malloc(strlen(str)))
    {
        printf("基类构造函数！
");
        strcpy(name, str);
        data = 0;
    }
    inline ~BaseClass()
    {
        printf("基类析构函数！
");

        // 以下语句导致基类析构函数卡住，不知道什么原因，这句话即使放到派生类中，也会导致派生类析构卡住，停止却不报错，很奇怪的现象～
        // 无论是new还是malloc的空间，都会卡住
        // if (name)
        //        free(name);

        // 即使用delete也会卡住
        // delete name;
    }
    
    // 关于“虚函数是否能是static类型的问题”
    // 下面的语句不合法！
    // error C2216: “virtual”不能和“static”一起使用
    // virtual static int doSomething() = 0;
    
    // 合法定义，函数体为const类型
    virtual int get_id() const {return id;}
    virtual int get_max() const {return max;}

    // 合法定义，传入的参数为const类型
    virtual void set_data(const int& d){data = d;}

    // 关于“const修饰的成员函数的问题”
    // 下面的语句不合法！
    // error C3490: 由于正在通过常量对象访问“data”，因此无法对其进行修改
    // 有const修饰时，类的全部成员变量变成了const类型
    // 例如：const char* name 会变成 const char* const name; int data 变成了 const int data;
    // virtual void set_data(const int& d) const {data = d;}

    // 合法定义
    virtual void print_string() const {
        printf("My id is %d , my name is %s and my data is %d.
", id, name, data);
    }
    
};

// 下面的语句不合法！
// error C2720: “BaseClass::cnt”: 成员上的“static ”存储类说明符非法
// static int BaseClass::cnt = 0;

// 合法赋值表达式，必须有类型说明：int，否则不合法
int BaseClass::count = 1;

// 下面的语句不合法！
// error C2373: “max”: 重定义；不同的类型修饰符
// int BaseClass::max = 1024;

// 合法赋值表达式，必须同时有const和int
const int BaseClass::max = 1024;

class DerivedClass : public BaseClass
{
private:
    char* subname;
public:
    // 由于基类没有默认构造函数，子类必须定义构造函数，而且必须是对应参数及类型的构造函数，否则出现错误：
    // error C2512: “DerivedClass”: 没有合适的默认构造函数可用
    // error C2512: “BaseClass”: 没有合适的默认构造函数可用
    // DerivedClass(){};
    
    // 下面的语句没有意义，相当于创建的一个临时变量，语句结束即销毁
    // DerivedClass(const char* str){BaseClass(str);};

    // 合法定义
    DerivedClass(const char* str):BaseClass(str)
    {
        printf("派生类构造函数！
");
        subname = NULL;
    };

    ~DerivedClass()
    {
        printf("派生类析构函数！
");

        // 以下语句会导致delete操作时卡住，不知道为什么，很奇怪～
        // if (subname)
        //     free(subname);
        // subname = NULL;

        // 下面的语句同上，莫名其妙的卡住
        // delete subname;

    }

    void set_sub_name(const char* str)
    {
        if(subname)
            free(subname);
        subname = new char[strlen(str)];
        strcpy(subname, str);
    }

    void print_string() const 
    {
        // 下面的语句不合法！
        // 因为id是private类型，不能被子类访问
        // 而protected类型可以，例如name和data
        // error C2248: “BaseClass::id”: 无法访问 private 成员(在“BaseClass”类中声明)
        // printf("My id is %d , my name is %s and my data is %d.
", id, name, data);

        // 下面的语句不合法
        // 因为有const修饰的函数无法调用派生类和基类的非const类型的函数
        // error C2662: “BaseClass::set_data”: 不能将“this”指针从“const DerivedClass”转换为“BaseClass &”
        // set_data(1);

        // 合法调用
        BaseClass::print_string();
        
        // 合法调用
        // const修饰的函数只能调用派生类和基类的const函数，下面的Base::get_id()便是一个有const修饰的函数
        // 这是派生类的const函数访问基类的private函数的唯一方法，访问他们的const类型的get函数，但是显然const类型的函数无法修改private类型的变量，也无法修改其他类型的变量
        printf("I'm a DerivedClass, my subname is %s and I can see max = %d.
", subname, BaseClass::get_max());

    };
};

int main()
{

    {
        // 测试构造函数的顺序
        printf(">> 构造函数顺序依次是：
");
        DerivedClass a("Liu");
        printf("<< 测试结束！

");
        a.print_string();
        printf(">> 析构函数顺序依次是：
");
        // 测试析构函数的顺序
    }
    printf("<< 测试结束！

");
    DerivedClass* b = new DerivedClass("Wang");
    b->set_sub_name("Jone");
    b->print_string();
    // 测试free能否出发析构函数
    printf(">> 测试free能否触发析构函数：
");
    free(b);
    printf("<< 测试结束！

");
    b = NULL;

    // 测试delete能否触发析构函数
    DerivedClass* c = new DerivedClass("Zhao");
    c->set_sub_name("Mike");
    c->print_string();
    printf(">> 测试delete能否触发析构函数：
");
    delete c;
    printf("<< 测试结束！

");
    c = NULL;

    // 合法，释放堆中的空间
    int* arr1 = new int[10];
    free(arr1);

    // 语法合法，但执行非法，通过free释放栈中的空间
    // int arr2[10] = {0};
    // free(arr2);

    // 语法合法，但执行非法，通过free释放常量区的空间
    // char* arr3 = "Hello !";
    // free(arr3);

    getchar();
    return 0;
}

输出结果是：

>> 构造函数顺序依次是：
基类构造函数！
派生类构造函数！
<< 测试结束！

My id is 1 , my name is Liu and my data is 0.
I'm a DerivedClass, my subname is (null) and I can see max = 1024.
>> 析构函数顺序依次是：
派生类析构函数！
基类析构函数！
<< 测试结束！

基类构造函数！
派生类构造函数！
My id is 2 , my name is Wang and my data is 0.
I'm a DerivedClass, my subname is Jone and I can see max = 1024.
>> 测试free能否触发析构函数：
<< 测试结束！

基类构造函数！
派生类构造函数！
My id is 3 , my name is Zhao and my data is 0.
I'm a DerivedClass, my subname is Mike and I can see max = 1024.
>> 测试delete能否触发析构函数：
派生类析构函数！
基类析构函数！
<< 测试结束！