C++之类与构造函数

笔记总结:

1.C/C++中struct结构体的区别：

C中struct只能声明成员变量，而C++中的struct关键字还可以声明定义成员函数；

2.C/C++中用于声明类的关键字是Class,其实Struct也是可以声明类的，在C++中Class与Struct区别是，Class默认是私有的，Struct默认是共有的；

3.类的三个区间：public/protected/private；在类中声明的变量叫类的成员变量，在类中声明的函数叫类的成员函数；

4.类的作用域：类定义的部分和类的成员函数定义的部分；类内和类外指：类的作用域内和外；

5.类的所有区间的成员函数都可以访问该类所有区间的成员变量和成员函数；

在类外，类对象，指针，引用只能访问该类公有区的成员（成员变量和成员函数）；

6.this指针存放类的对象的首地址，this指针是隐藏在成员函数中的第一个形参；

7.在类外，通过类的对象，引用，指针都可以调用类的共有区的成员（成员变量和成员函数）；

8.类中的内联函数，函数重载；

构造函数：声明类的对象时，该类的构造函数会自动被调用

作用：构造函数是用于初始化类的成员变量；

如果一个类没有自定义的构造函数，则C++编译器会自动生成一个默认的， 共有的，无参的构造函数；

一旦自定义一个构造函数，则C++编译器就不会再生成默认的构造函数了；

无参的构造函数，有参的构造函数；

有参的构造函数一般是用于传参，将类的成员变量初始化一步到位；

类的初始化列表：作用也是为了初始化类的成员，它是在类的构造函数调用之前就将类的相关成员变量初始化好了；

类的一般成员变量，都可以用类的构造函数初始化；而引用，常量成员变量只能用类的初始化列表来初始化；

Class Biology

{

Public:

    //类的构造函数名与类名一样，没有函数返回值，可以有参数；

Biology()

{

    m_name = “tiger”;

    m_weight = 20;

}

     //类的初始化列表如下面所示，类成员变量初始化的顺序以成员变量在类中声明的顺序为准，与在初始化列表中的顺序无关

Biology(const string &t_name,int t_weight)

    :m_name(t_name),m_weight(t_weight)

{

}

Private:

String m_name;

Int m_weight;

};

类的常量成员初始化的方式如下例：

Class Biology

{

Public:

//在类的初始化列表中初始化常量成员

Biology()

    :m_number(50)

{

    m_name = “tiger”;

    m_weight = 20;

    //m_number = 50;  错误；不能在类的构造函数里面初始化常量

}

Biology(const string &t_name,int t_weight)

    :m_name(t_name),m_weight(t_weight),m_number(50)

{

}

Private:

String m_name;

Int m_weight;

Const int m_number = 100;//c++2011标准支持,以前的C++标准不支持

};

类的引用成员

初始化类的引用成员一般有两种情况：

1.用类中其它的成员变量来初始化它；

2.用类外的变量来初始化它；

具体用哪种情况，根据实际的软件需求而定；

情况一：

Class Biology

{

Public:

    //用m_count1来初始化m_count2

Biology()

    :m_number(50),m_count1(0),m_count2(m_count1)

{

    m_name = “tiger”;

    m_weight = 20;

}

Biology(const string &t_name,int t_weight)

    :m_name(t_name),m_weight(t_weight),m_number(50),m_count1(0),m_count2(m_count1)

{

}

Private:

String m_name;

Int m_weight;

Const int m_number;

int m_count1;

int &m_count2;  //引用成员

};

情况二

Class Biology

{

Public:

//用外面的变量与类的引用成员绑定，注意这里行参为什么需要是引用

//如果不是引用，则类的引用成员会绑空，因为形参是临时变量，退出函数时就会被销毁，这时引用成员的值就是个随机值了；

Biology(int &t_height,const int &t_age=10)

    :m_number(50),m_count1(0),m_count2(m_count1),m_height(t_height),m_age(t_age)

{

    m_name = “tiger”;

    m_weight = 20;

}

Biology(const string &t_name,int t_weight,const int &t_age)

    :m_name(t_name),m_weight(t_weight),m_number(50),m_count1(0),m_count2(m_count1) ,m_height(t_height),m_age(t_age)

{

}

Private:

String m_name;

Int m_weight;

Const int m_number;

int m_count1;

int &m_count2;  //引用成员

int &m_height;  //引用成员

const int &m_age; //const引用成员，可以保证不能通过该引用变量去修改它绑定的变量（类外的变量）

};

有时需要对类的留一个后门，用类外的变量绑定类中的const引用成员，这样就可以通过外面的变量修改类的成员的值，而不能通过类的const引用成员去修改类外的这个变量；当然具体情况具体对待，用法是很灵活的；

类的成员变量可以有该类的指针，引用，但不能有该类的对象；

Class Biology

{

Public:

Biology()

    :m_number(50),m_count1(0),m_count2(m_count1),m_biology1(0),m_biology2(*this)

{

    m_name = “tiger”;

    m_weight = 20;

}

Biology(const string &t_name,int t_weight)

    :m_name(t_name),m_weight(t_weight),m_number(50),m_count1(0),m_count2(m_count1), m_biology1(0),m_biology2(*this)

{

}

Private:

String m_name;

Int m_weight;

Const int m_number;

int m_count1;

int &m_count2;

Biology *m_biology1;         //该类的指针    正确

Biology &m_biology2;         //该类的引用    正确

Biology m_biology3;          //该类的对象    错误

};

类的成员变量不能有该类的对象,会造成死循环,因为该类会不断的构造这个成员变量，一直构造下去，就死循环了；

类的联合：一个类的对象是另外一个类的成员变量；

如下：

Class food

{

public:

food()

{

    m_name = “food”;

    m_validTime = 1;

}

food(const string &t_name,int t_validTime)

    :m_name(t_name),m_validTime(t_validTime)

{

}

private:

string m_name;

int m_validTime;

};

Class Biology

{

Public:

Biology()

    :m_number(50),m_count1(0),m_count2(m_count1),m_biology1(0),m_biology2(*this)

{

    m_name = “tiger”;

    m_weight = 20;

}

Biology(const string &t_name,int t_weight)

    :m_name(t_name),m_weight(t_weight),m_number(50),m_count1(0),m_count2(m_count1), m_biology1(0),m_biology2(*this)

{

}

Private:

String m_name;

Int m_weight;

Const int m_number;

int m_count1;

int &m_count2;

food m_food;              //其它类的对象

game m_game;              //其它类的对象

};

声明一个Biology对象，构造函数调用的顺序是，food(),game(),biology();

原因是先必须构造好该类的成员，而该类的成员中有2个成员变量是其它类的对象，因此先调用其它类的构造函数将这2个类的成员构造好，然后在调用自己构造函数构造自己的部分；这2个对象构造的顺序以它们在类中声明的顺序为准；

通过初始化列表可以显示的指明用这2个类的有参的构造函数构造它们，或者在biology的构造函数中显示的调用这2个类的有参的构造函数，达到传参的目的；

如下：

Class Biology

{

Public:

Biology()

    :m_number(50)

{

    m_name = “tiger”;

    m_weight = 20;

}

Biology(const string &t_name,int t_weight,const string &t_foodName,int t_foodTime)

    :m_name(t_name),m_weight(t_weight),m_number(50),m_food(t_foodName,t_foodTime)   //方法一

{

     m_food = food(t_foodName,t_foodTime);  //方法二

}

Private:

String m_name;

Int m_weight;

Const int m_number;

food m_food;              //其它类的对象

};

这两种方法都能达到目的，建议用方法一，高效些（通过构造函数调用的次数可以说明，方法一高效些）

全局的类对象在main函数之前构造好，顺序以声明的顺序为准；

声明一个对象的数组，如food t_array1[5];  会调用food构造函数5次

显示的调用类的构造函数，会创建一个该类的无名的对象；一般用于函数传参，生存周期较短；

---

类的析构函数:

析构函数：在类对象被销毁时，自动调用；调用顺序与构造函数相反；

作用：做善后清理工作；

不管是否自定义一个析构函数，C++编译器都会生成一个默认的析构函数；

形式如下：

Class Biology

{

Public:

Biology()

    :m_number(50)

{

    m_name = “tiger”;

    m_weight = 20;

}

Biology(const string &t_name,int t_weight,const string &t_foodName,int t_foodTime)

    :m_name(t_name),m_weight(t_weight),m_number(50)

{

 }

//有且只有一个析构函数，无返回值和参数

~Biology()

{

}

Private:

String m_name;

Int m_weight;

Const int m_number;

};

自定义的析构函数用于该类的清理，善后工作.

C++编译器生成的析构函数用于处理系统对该类的内存，堆栈的清理善后工作；