类的const（成员数据，成员函数）static（成员数据，成员函数），const成员函数可以修改mutable 声明的类型

#include <iostream>
#include <string>
#include <Windows.h>

using namespace std;

#define NAME_SIZE 64

class student {
    private:
        char* name;
        int age;
        static int count;
        //const int count_2 = 0;   //c++11支持这种操作  传统的操作要使用参数表进行初始值
        const int count_2;  //一般 c++11用   enum{count_2 = 2}; 来代替const  数据 成员
        mutable int count_3;        //const 成员函数可以修改  mutable 类型的值

    public:
        static int count_1;
        student(const int a = 2); //默认构造函数
        student(const char* _name, const int _age, const int a);//重载的构造函数  
        student(const student &st);//拷贝构造函数
        void change_name();//改变值 来验证深度拷贝和浅拷贝的区别
        friend ostream& operator << (ostream& out, student& stu);
        student & operator = (const student & st);//赋值重载   来进行深度赋值
        void print();
        static void print_static();
        void print_s();
        void printff() const;   
        ~student();
};

int student::count = 0;

int student::count_1 = 0;

student::student(const int a):count_2(a) {
    cout << "初始化函数_1" << endl;
    age = 0;
    count_3 = 4;
    name = new char[NAME_SIZE];
    strcpy_s(name, NAME_SIZE, "哈哈哈");
    count++;
}

student::student(const char* _name, const int _age, const int a):count_2(a) {
    cout << "初始化函数_2" << endl;
    age = _age;
    count_3 = 4;
    name = new char[NAME_SIZE];
    strcpy_s(name, NAME_SIZE, _name);    //这里不能用  sizeof(name) 因为  name是动态数组  sizeof(name)表示这个 指针的大小  也就是四个字节
    count++;
}                                         //切记

void student::change_name() {
    
    strcpy_s(name, NAME_SIZE, "李俊珂");
}

void student::print() {
    cout << "姓名：" << name << endl;
    cout << "年龄：" << age << endl;
}

student::student(const student& st):count_2(st.count_2){//拷贝构造函数   一般 用于  对象的初始化 //这里是深度复制
    cout << "深度复制" << endl;
    age = st.age;
    count_3 = st.count_3;
    name = new char[NAME_SIZE];
    strcpy_s(name, NAME_SIZE, st.name);
    count++;
    
}

student& student::operator = (const student& st) {//赋值构造函数
    
    if (this == &st) {//用指针进行比较  因为没有重载 “==”运算符
        return *this;
    }
    count_3 = st.count_3;
    age = st.age;
    strcpy_s(name, NAME_SIZE, st.name);    
    return *this;
}

ostream& operator << (ostream& out, student& stu) {
    out << "姓名：" << stu.name << endl;
    out << "年龄：" << stu.age << endl;
    out << "常数据成员count_2:" << stu.count_2 << endl;
    out << "常数据成员count_3:" << stu.count_3 << endl;
    return out;
}

void student::print_static() {
    cout << count << endl;
    return;
}

void student::printff()const{
    cout << "姓名：" << name << endl;
    cout << "年龄：" << age << endl;
    cout << "常数据成员count_2:" << count_2 << endl;
    count_3 = 7;
    cout << "常数据成员count_3:" << count_3 << endl;
    return ;
}

void student::print_s() {
    cout << count << endl;
    return;
}

student::~student() {
    cout << "调用析构函数" << endl;
    delete [] name;
}

int main(void) {

    student stu("张云翔", 21, 5);  //自定义得的 构造函数
    student stu_1 = stu;            //拷贝构造函数
    
    cout << stu << endl;
    cout << stu_1 << endl;
    cout << "---------------------------" << endl;
    stu.change_name();          //这里是浅复制，动态   两个对象的指针部分  指向同一个 内存 就和 常量的指针一样  一个变另一个就跟着变
    cout << stu << endl;        //这里是易错点
    cout << stu_1 << endl;        //深度复制就不会出现这种情况的
    
    student stu_2;
    stu_2 = stu_1;                //赋值构造函数  深度赋值
    cout << "---------------------------" << endl;
    stu_1.change_name();
    cout << stu_1 << endl;
    cout << stu_2 << endl;

    stu_1.print_s();                   //一般成员可以调用  static成员数据
    stu_1.print_static();               //static成员函数可以调用  static成员数据  一般对象可以调用static成员函数;

    cout << stu_1.count_1 << endl;       //对象可以直接调用  公有 的static 成员数据    私有不可以
    cout << student::count_1 << endl;  //类名也可以 调用  公有的static数据成员   私有不可以
    
    student::print_static();           //类名可以调用   static成员函数   //强烈推荐使用
                                       //因为 static属于类  所以没有 this 指针
    
    stu_1.printff();
    const auto stu_3 = stu_1;

    stu_3.printff();            //const 对象可以调用 const成员函数       
    stu_3.print_static();            //const 对象可以调用 static    成员函数        
    cout << stu_3.count_1 << endl;        //const 对象可以调用 共有的static    成员数据
    
    //const 函数  不会改变数据的值  对于一般数据非常安全  强烈建议 在只访问  不修改的情况下 强烈建议用const

    system("pause");
    return 0;
}