<C++ - 构造和析构>

/*
    回顾上节的内容：
            1.实现中的事情 物 ->类  
                    <属性 -> 成员变量>   
                    <行为 -> 成员函数>
            2.访问权限 public private (protected:受保护的)
                函数 公有  成员  私有  公有可以在类外访问  私有 只能类内访问
            3.struct 和class区别: 结构体就是公有的类
                                  类就是私有的结构体

         -->this 指针  指向对象本身 在成员函数中  可以在成员函数中访问成员变量或者是调用其他成员函数(在类外不能使用)


    新知识点:
        1.构造  析构函数
            1.1 构造函数
                成员变量  私有  只能用类里面的函数赋值 
                构造函数  定义一个对象的时候 同时给他初始化

                构造函数有时候也叫做: 构造器  函数名和类名相同  没有返回值  
                                        也不需要要调用(对象定义的时候自动调用 并且只调用一次)
                                        构造函数  可以重载  可以缺省(注意二义性)
                                        构造自己调用
                                        定义对象  对象后面没有()  -->无参构造
                                                 对象后面有()   调用有参构造
                                       
                                        定义对象的时候同时会调用构造函数
                                        不写构造函数的时候  定义对象的时候会不会调用构造函数  (会调用)
                                        没写  编译器会给一个默认构造(没有参数 没有执行任何功能)不做任何事情
                                        如果说你写了一个构造函数  编译器就不会给这个构造
        2.new  delete
        3.命令行参数
*/
#include <iostream>
using namespace std;

//====================================类函数========================================
class sunmer
{
private:         // 私有成员不能在类外访问
    int x;       // 只是说明类中有哪些成员  不赋值
    double y;
public:
    // 无参数构造
    sunmer()   // 可以有参数  也可以没有参数  可以重载
    {
        cout << "调用的是无参构造函数" << endl;
        x = 0;
        y = 0; 
    }
    sunmer(int x, double y)     // 有参数构造
    {
        cout << "调用的是有参构造函数2" << endl;
        this->x = x;
        this->y = y;
    }
    sunmer(double y, int x = 0)   // 缺省的构造函数
    {
        cout << "调用的是缺省函数" << endl;
        this->x = x;
        this->y = y;
    }

    void play()
    {
        cout << "play well" << endl;
    }
    void setSummer()
    {
        //cin >> x >> y;
        cin >> this->x >> this->y;
    }
    void setSummer(sunmer&temp)   // 这个传递一个参数  (2)
    {
        temp.x = 2;
        this->x = 3;
    }
    void print()
    {
        cout << x << "\t" << y << endl;
    }
};
/**
    类 -->抽象
    成员赋值方式:
            1.构造函数    定义对象的时候给他赋值
            2.定义其他函数    后面用对象调用给他赋值
*/

class student
{
    int x;
public:
    student(int x)   // 有参数
    {
        this->x = x;
    }
    /*student()
    {

    }*/

};

int main()
{
#if 0
    sunmer seven,six;       // 定义一个seven对象
    sunmer ou(3, 2.15);     // 调用有参数构造   参数可以是变量
    sunmer danny(2);        // 调用缺省构造函数

    ou.print();
    getchar();
    seven.setSummer(six);   // 调用(2)行的函数
    /**
        temp.x   ->相当等于: six.x
        thix->x  ->相对等于: seven.x
    */
    seven.play();            //函数调用的时候记得加括号
    seven.setSummer();        // 输入数据
    seven.print();            // 打印数据

#else
    //student bug;   // 不写()   调用默认(无参)构造
    // 错误  不存在默认构造函数  解决方案1  自己写一个没有参数的构造函数
    // 解决方案2  调用有参构造函数  写参数

    //student arr[10];  // 定义类数组  对象没办法传递参数   -->调用无参构造
    // 用堆内存申请类的动态数组
    
#endif

    getchar();
    return 0;
}