C++构造函数，析构函数

1、结构体和类唯一的区别，结构体默认的访问类型是public,而类的是private。

2、定义位于类声明中的函数将自动成为内联函数。通常定义比较短的函数这么做。也可以在类外部声明为内联函数。
- 内联函数的规则特殊，要求每个使用它的文件中都有对应定义。最好的方法是和类声明一起放在头文件中。

inline void Stock::set_tot()
{
    total_val=shares*share_val;
}

3、构造函数

构造函数和类同名，没有返回值，在类声明对象时候，将会自动调用构造函数。

class Student{
private :
    int m_age;
    string m_sex;
    string m_name;

public :
    Student(int age, string sex, char * name){
        m_age = age;
        m_sex = sex;
        m_name = name;
        cout << "调用构造函数 name: "<< name << endl;
    }

};

int main()
{
    Student aa(18,"man","aa");
    Student bb = Student(20,"man","bb");
    Student *cc = new Student(21,"man","cc");

    cin.get();
    return 0;
}

- 以上是3种对象的初始化方式，从实验结果看，确实自动调用了构造函数。这里有个注意点，构造函数虽然没有返回值，但是也要写成public的，不然会显示没有匹配的构造函数。
- 无法通过对象的成员调用构造函数。因为构造函数的使用是在对象生成之前的，在构造函数构造出对象前，对象是不存在的。通过使用对象.成员的方式，也会发现不会出现构造函数。

默认构造函数

Student aa(18,"man","aa");
Student bb = Student(20,"man","bb");
Student *cc = new Student(21,"man","cc");

Student dd;

• 同样的代码，当定义没有初始值的对象时，编译器报错“没有默认的构造函数”。在没有编写任何一个构造函数时候，系统会自动生成一个空的构造函数。若是编写了任何一个构造函数，编译器不会再自动生成，需要补上一个无参默认构造函数。

析构函数

• 在对象消亡的时候调用。所以，如果在构造函数中若是使用new 进行内存分配，在析构函数中应该delete以释放空间。

class Student{
private :
    int m_age;
    string m_sex;
    char * m_name;

public :
    Student(int age, string sex, char * name){
        m_age = age;
        m_sex = sex;
        m_name = name;
        cout << "调用构造函数 name: "<< name << endl;
    }
    ~Student()
    {
        cout << "析构函数 name: " << m_name << endl;
    }
};

void test()
{
    Student aa(18, "man", "aa");
    Student bb = Student(20, "man", "bb");
    Student *cc = new Student(21, "man", "cc");
}
int main()
{
    test();

    cin.get();
    return 0;
}

- 从结果中可以看出，析构函数调用的顺序和构造函数相反，后构造的函数先析构。
- 使用Student bb = Student(20, “man”, “bb”);的方式定义对象，实际上是先生成一个临时的对象，然后赋值给bb，为了验证这个想法，看下面代码。

class Student{
private :
    int m_age;
    string m_sex;
    char * m_name;

public :
    Student(int age, string sex, char * name){
        m_age = age;
        m_sex = sex;
        m_name = name;
        cout << "调用构造函数 name: "<< name <<" address : " << this <<endl;
    }
    ~Student(){
        cout << "析构函数 name: " << m_name << " address : " << this << endl;
    }
};

void test(){
    Student bb = Student(20, "man", "bb");
    cout <<"address :"<< &bb << endl;
}
int main(){
    test();
    cin.get();
    return 0;
}

- 从结果看确实是两个对象存在不同地址，临时对象赋值后就消亡。赋值过程不会调用构造函数。

而在C++ primer plus书中也有相应的说明 P361

Stock stock2=Stock("Bpffo Object ", 2,2.0);
stock1=Stock("Nifty Foods", 10,50.0);

• 第一个的初始化可能创建临时变量也可能不会。(可能取决于编译器？但是这里测试VS2013明显会创建。)
• 第二个是赋值，总会创建一个临时变量。
• 若两种都可以，则采用初始化方式效率更高。

列表初始化

用如下的方式初始化变量：C++11特性

Student s1={18,"men","dd"};
Student s2{20,"men","ee"};
Student s3{};

const成员函数

• 定义的一个const 对象调用非const 的成员函数时候，编译器报错，必须将方法定义为const类型 方可使用。

class Student{
private :
    int m_age;
    string m_sex;
    char * m_name;

public :
    Student(int age, string sex, char * name){
        m_age = age;
        m_sex = sex;
        m_name = name;
    }
    void showName(){
        cout << " name : " << m_name << endl;
    }
    void showSex() const {
        cout << " sex : " << m_sex << endl;
    }
};

int main()
{
    Student s1 = { 20, "man", "CC" };
    s1.showName();

    const Student s2 = { 21, "woman", "EE" };
    //s2.showName();
    s2.showSex();
    cin.get();
    return 0;
}

• 在类声明中确定常量

enum { Months=12;}

// 或者
static const int Months=12;

double costs[Months];