从C语言到C++⑤(第二章_类和对象_中篇)(6个默认成员函数+运算符重载+const成员)（上）

#include <iostream>
using namespace std;
 
class Date 
{
public:
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        printf("%d-%d-%d\n", _year, _month, _day);
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d1;
    d1.Init(2023, 4, 23);
    d1.Print();
 
    Date d2;
    d2.Init(2022, 5, 2);
    d2.Print();
 
    return 0;
}

#include <iostream>
using namespace std;
 
class Date 
{
public:
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
 
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    void Print()
    {
        printf("%d-%d-%d\n", _year, _month, _day);
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d1; // 对象实例化，此时触发构造，调用无参构造函数
    d1.Print();
 
    Date d2(2023, 5, 2); // 对象实例化，此时触发构造，调用带参构造函数
    // 这里如果调用带参构造函数，我们需要传递三个参数（这里我们没设缺省） 。
    //如果想传几个就传几个可以自己设置重载
    d2.Print();
 
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    Date d3();
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
 
    //构造函数是特殊的，不是常规的成员函数，不能直接调d1.Data();
 
    return 0;
}

class Date 
{
public:
    //无参构造函数 是 默认构造函数 
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
 
    //全缺省构造函数 也是 默认构造函数 （一般写全缺省，不写上面那个）
    Date(int year = 1, int month = 1, int day = 1) 
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
private:
    int _year;
    int _month;
    int _day;
};

#include <iostream>
using namespace std;
class Time
{
public:
  Time()
  {
    cout << "Time()" << endl;
    _hour = 0;
    _minute = 0;
    _second = 0;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
 
class Date
{
public:
 
  void Print()
  {
    printf("%d %d %d\n", _year, _month, _day);
  }
 
private:
 
  int _year;// 基本类型(内置类型)
  int _month;
  int _day;
 
  Time _t;// 自定义类型
};
 
int main()
{
  Date d;
  d.Print();
  return 0;
}

#include <iostream>
using namespace std;
class Time
{
public:
  Time()
  {
    cout << "Time()" << endl;
    _hour = 0;
    _minute = 0;
    _second = 0;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
 
class Date
{
public:
 
  void Print()
  {
    printf("%d %d %d\n", _year, _month, _day);
  }
 
private:
  
  int _year = 1;// 基本类型(内置类型)
  int _month = 1;
  int _day = 1;
  //注意这里不是初始化，是给默认构造函数缺省值
 
  Time _t;// 自定义类型
};
 
int main()
{
  Date d;
  d.Print();
  return 0;
}

#include <iostream>
using namespace std;
 
class Date 
{
public:
    Date(int year = 1, int month = 1, int day = 1) 
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print() 
    {
        printf("%d-%d-%d\n", _year, _month, _day);
    }
 
    ~Date() 
    {
        cout << "~Date()" << endl;// 日期类没有资源需要清理，所以只打印下知道调用了
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d1;
    Date d2(2023, 5, 2);
 
    return 0;
}

#include<iostream>
#include<stdlib.h>
using namespace std;
 
typedef int StackDataType;
class Stack 
{
public:
    Stack(int capacity = 4) // 这里只需要一个capacity就够了，默认给4（利用缺省参数）
    {
        _array = (StackDataType*)malloc(sizeof(StackDataType) * capacity);
        if (_array == NULL) 
        {
            cout << "Malloc Failed!" << endl;
            exit(-1);
        }
        _top = 0;
        _capacity = capacity;
    }
 
    ~Stack() // 这里就用的上析构函数了，我们需要清理开辟的内存空间（防止内存泄漏）
    {
        free(_array);
        _array = nullptr;//下面这两行可以不写，这个野指针已经没人能访问到了
        _top = _capacity = 0;//但写了也是个好习惯
    }
 
private:
    int* _array;
    size_t _top;
    size_t _capacity;
};
 
int main(void)
{
    Stack s1;
    Stack s2(20); //初始capacity给20
 
    return 0;
}