C++编程基础——构造函数、析构函数、static/const关键字

构造函数和析构函数

构造函数：Constructor，也称为构造方法或构造器，主要用于对对象的属性进行初始化。它是一个特殊的方法，其特点如下：

1. 没有返回值，并且方法名必须和类名同名；
2. 和普通方法一样，也支持重载；
3. 每个对象在创建时（给对象分配完内存空间）必定会自动调用某一个匹配的构造函数，所以我们可以在构造函数中对对象进行初始化。我们通常不会去显式调用构造函数；

注意：如果我们在类中没有定义任何构造函数，C++编译器会自动提供一个默认的无参构造函数，这个构造函数啥事没干。反之，只要我们自己定义了任何形式的构造函数，C++编译器就不会做这个事情。

构造函数参数初始化列表

析构函数：Destructor，也称为析构方法和析构器，主要用于做一些清理善后工作。，比如释放堆区内存空间、关闭文件、断开连接等。它是一个特殊的方法，其特点如下：

1. 没有返回值，无参，并且方法名必须为 “~类名” 形式。
2. 不支持重载。
3. 每个对象在销毁时（准备释放对象所占内存空间之前）必定会自动调用一次析构函数，析构函数一旦执行结束，对象所占内存空间就会被立即释放，对象也就不复存在了，所以我们在析构函数中执行一些清理善后工作。当然，我们也可以去显式调用析构函数，但这并不会导致对象被销毁，和调用一个普通方法没有区别。

在一个代码块中定义多个普通局部对象，构造函数的执行顺序与对象定义顺序一样，析构函数的执行顺序相反。

static 关键字

static 关键字可以用来修饰属性和方法，即静态属性和静态方法。

静态属性和静态方法属于类所有，所有对象共享，所以我们也将它们称为类类属性和类方法，与对象无关。

静态成员通过类名可以直接访问（更推荐的方式），当然也可以通过对象访问，通过对象所在的类访问静态成员与静态方法。

静态属性在内存中只有一份，即使一个对象都没有定义它也存在，所以静态属性所占内存空间不计算在每个对象头上，不占对象的空间大小。

静态方法内部不能使用 this 指针，也就是说在静态方法内部不能访问非静态成员，只能访问静态成员。在非静态方法中可以访问静态成员和非静态成员。

注：无论静态属性是哪种访问权限，它必须在类外进行初始化，否则无法使用

const 关键字

const 关键字可以用来修饰属性和方法，即常属性和常方法。

const关键字可以用来修饰对象、对象引用、对象指针，即常对象、常对象引用、常对象指针。

常属性是只读的，必须通过构造函数参数初始化列表进行初始化。

在方法声明和定义的最右边写上 const 关键字就表示该方法为常方法。在常方法中不能修改任何属性的值，即所有属性都是只读的。在常方法中不能调用非常方法，只能调用常方法，非常方法可以调用常方法和非常方法。

在设计类中方法时，如果该方法无需修改任何属性的值，强烈建议其定义为常方法，能避免许多问题。

常方法和非常方法可以构成重载

开发规范

类的声明和实现分离，即将类的声明代码写在头文件中，类的实现代码写在源文件中，并且文件名建议就是类名。

实例一：构造函数和析构函数

#include <iostream>
#include <cstring>
using namespace std;


class Student{
private:
    int sno;
    char name[21];
    string phone;
    char* addr;
public:
    //若没有定义构造函数，C++编译器会自动添加一个构造函数，但是此构造函数没有语句，会执行。
    Student()       //每一个（对象）构造函数会自动执行一次,定义完立马执行
    {
        cout << "Student()" << endl;
        this -> addr = new char[50];
    }
    
    Student(int sno,const char* name,string phone):sno(sno),phone(phone) //构造函数参数初始化列表
    {
        // this -> sno = sno;
         strcpy(this ->name,name);
        // this -> phone = phone;
        addr = new char[50];
    }
    ~Student()//析构函数
    {
        cout << this->name << "马上就要死了" << endl; 
        delete[] addr; 
    }
    void show()
    {
        cout << sno << " " << name << " " << phone << endl;
    }
};

Student gs1(1009, "马云","17333558827");      //定义在全局，构造函数调用在 main（）函数之前

int main(){
    //cout << "start..." << endl;
    Student s1(1003,"s1","52445522");                     //调用无参的构造函数
    //cout << "111" << endl;
    Student* s2 = new Student;
    //构造函数执行两次

    Student s3(1001,"张三","557767222222");        //调用有参的构造函数
    Student* s4 = new Student(1002,"李四","122222222");
    s3.show();
    
    delete s2;
    delete s4;
    return 0;
}

实例二：static关键字使用

#include <iostream>
using namespace std;

class Student{
private:
    int sno;
    char name[21];

public:
    static int cnt;    // 静态属性
    // 静态方法
    static int getCount(){
        return cnt;
    }

    // 静态方法
    static void setCount(int cnt){
        Student::cnt = cnt;
    }
};

//**静态属性必须在类外进行初始化**//
int Student::cnt = 0;

int main(){
    Student s;
    Student::cnt = 9;
    cout << s.cnt << endl;
    s.setCount(6);
    cout << Student::cnt << endl;


    return 0;
}

实例三：const关键字使用

#include <iostream>
#include <cstring>

using namespace std;

class Student
{
private:
    //常属性    可在此不初始化，若初始化，当构造函数没有赋值则为当前初始化值，当构造函数参数列表有值则为构造函数给的值。
    //const int sno = 199;
    const int sno;
    string name;

public:
    Student():sno(100)
    {
        //sno = 100;        //常量不能为左值
        name = "匿名";
    }
    Student(int sno,string name):sno(sno),name(name)
    {
    }

    int getSno(void) const;
};

int Student::getSno(void) const
{
    return sno;
}

int main()
{
    Student s1;
    Student s2(200,"张三");

    cout << s1.getSno() << endl;
    cout << s2.getSno() << endl;
}