C++ _ 构造函数 (二)

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

biology* m_biology1;
biology& m_biology2;
//biology m_biology3; 这样是不行的
//证明：1，因为这样写就成了类的组合，组合类的对象要先构造
//      这里先构造m_biology3，而构造它就要调用biology的构造函数
//      biology的构造函数又会构造m_biology3，这样就陷入死循环
//      2，如果用sizeof求biology的大小，是无法求出来的
//      就像我中有你，你中有我，如此循环

2, 一个类的全局对象,是在main之前就构造好的

food g_food1;//一个类的全局对象,是在main之前就构造好的


int main()
{
    cout << "enter main..." << endl;

}

这里会先调用food的构造函数打印food()
再进入main函数打印enter main...

3, 类的对象数组

food t_arr[5] = { food("鸡蛋",3), food("鱼",2) }; //可以在定义数组时指定要调用的构造函数
//对象数组，数组中有几个元素就构造几次
//这里会构造5次
    //打印对象数组
    for (int i = 0; i < 5; i++)
    {
        t_arr[i].print();
        cout << endl;
    }
    cout << "=====================" << endl;
    food* p_arr[5]; //指针数组 指针并不是对象 所以不会调用构造函数
    for (int i = 0; i < 5; i++)
    {
        p_arr[i] = &t_arr[i];
        p_arr[i]->print();
        cout << endl;
    }

4, 类的析构函数

• 1,没有返回值
• 2,没有参数
• 3,自定义的析构函数只能有一个，不能重载
• 4,不管是否自定义析构函数，编译器都会默认生成一个析构函数
  因为用户自定义的析构函数与默认的析构函数作用不同
• 5,析构函数的调用顺序与构造函数相反
  可以认为析构函数和构造函数就是配对的关系，是对称的
  一个负责构造，一个负责销毁

~food()
{
    cout << "我的析构函数~food()" << endl;
}

5, 一个参数的构造函数的隐式转换

#include "car.h"

void getInfo(const car& t_car)
{
    t_car.print();
}

int main()
{
    car t_car1;
    car t_car2("马自达");
    car t_car3(10);
    car t_car4("奔驰", 5);

    car t_car5 = "保时捷"; //这种写法很奇怪,居然把一个字符串或者一个整数
    car t_car6 = 3;        //传给了car的对象
    //这种情况叫做 一个参数的构造函数的隐式转换
    //视情况而定,可以使用关键字 explicit 来抑制这种隐式转换

    cout << "==========================" << endl;
    t_car1.print();
    t_car2.print();
    t_car3.print();
    t_car4.print();
    t_car5.print();
    t_car6.print();

    cout << "**************************" << endl;
    getInfo(t_car1);
    getInfo("大众"); //这里也发生了一个参数的构造函数的隐式转换
                     //同样,如果不想要这种隐式转换,可以用explicit抑制
    getInfo(20);


    system("pause");
    return 0;
}

#include "car.h"



car::car()
{
    cout << "car()" << endl << endl;
    car_name = "宝马";
    car_age = 0;
}

car::car(const char* t_name)
{
    cout << "car(const char* t_name)" << endl << endl;
    car_name = t_name;
    car_age = 0;
}

car::car(int t_age)
{
    cout << "car(int t_age)" << endl << endl;
    car_name = "劳斯莱斯";
    car_age = t_age;
}

car::car(const string & t_name, int t_age)
{
    cout << "car(const string & t_name, int t_age)" << endl << endl;
    car_name = t_name;
    car_age = t_age;
}

#pragma once

#include <iostream>
#include <string>

using namespace std;

class car
{
public:
    //构造函数
    car();
    //使用 explicit 来抑制一个参数的构造函数的隐式转换
    /*explicit*/ car(const char* t_name);
    /*explicit*/ car(int t_age);
    car(const string& t_name, int t_age);

    //析构函数
    ~car()
    {
        cout << "~car()" << endl;
    }

    //内联函数
    void print() const
    {
        cout << "car name: " << car_name << endl;
        cout << "car age: " << car_age << endl;
        cout << endl;
    }

private:
    string car_name;
    int car_age;
};