【C++初阶】第三站:类和对象(中) -- 类的6个默认成员函数-1

有时候我们写好了一个栈，头脑中第一件事情就会先去，Push压栈，各种操作，经常会忘掉一件事情--初始化，当忘记初始化栈的时候，那就会引发程序的崩溃：

class Date
{
public :
        void Init ( int year , int month , int day )
        {
               _year = year ;
                _month = month ;
                _day = day ;
        }
        void Print ()
        {
                cout << _year << "-" << _month << "-" << _day << endl ;
        }
private :
        int _year ;
        int _month ;
        int _day ;
};
int main ()
{
        Date d1 ;
        d1 . Init ( 2022 , 7 , 5 );//创建对象d1之后，需要调用这个初始化函数对d1对象进行初始化
        d1 . Print ();
     
        Date d2 ;
        d2 . Init ( 2022 , 7 , 6 );//这样未免有点太麻烦了
        d2 . Print ();
        return 0 ;
}

1. 函数名与类名相同。
2. 无返回值。
        解析:函数名前面无数据类型，不需要写void,
3. 对象实例化时编译器自动调用对应的构造函数。
        解析:当创建一个对象的时候，编译器会自动调用该类的构造函数对新创建的变量进行初始化
4. 构造函数可以重载
        解析:本质就是我们写多个构造函数，提供多种初始化方式
5.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意，并不是我们不写，编译器默认生成的构造函数才被叫做默认构造函数，
以下三种都可以称为默认构造函数：
         1.无参构造函数
        2.全缺省构造函数
        3.我们没写编译器默认生成的构造函数
6. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

Date d1();   
// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)

class Date
{
public:
  //情况1，(以下没有注释)如果用户显式定义了构造函数，编译器将不再生成
  Date(int year, int month, int day)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  //情况2，全缺省改成半缺省
  Date(int year , int month = 1, int day = 1)
  {
  cout << "Date(int year =1,int month = 1.int day = 1)" << endl;
  _year = year;
  _month = month;
  _day = day;
  }
  void Print()
  {
  cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
  Date d1;
  d1.Print();
  return 0;
}

class Stack
{
public:
  //Stack()
  //{
  //  a = nullptr;
  //  top = capacity = 0;//栈顶元素的下一个位置
  //}
//优化后的构造函数
  Stack(size_t n = 4)//优化的写法
  {
  if (n == 0)
  {
    a = nullptr;
    top = capacity = 0;
  }
  else
  {
    a = (int*)malloc(sizeof(int) * n);
    if (a == nullptr)
    {
    perror("realloc fail");
    exit(-1);
    }
    top = 0;
    capacity = n;
  }
  }
  //void Init()
  //{
  //  a = nullptr;
  //  top = capacity = 0;
  //}
  void Push(int x)
  {
  if (top == capacity)
  {
    size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
    int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
    //tmp 会指向新的内存区域（如果发生迁移），否则它仍指向原内存区域（如果没有迁移）。
    ///无论是否发生迁移，原有的指针 a 应该被 tmp 替代，
    //以确保后续操作使用的都是正确且可能已改变的内存地址：
    if (tmp == nullptr)
    {
    perror("realloc fail");
    exit(-1);//以异常的方式退出
    }
    if (tmp == a)
    {
    cout << capacity << "原地扩容" << endl;
    }
    else
    {
    cout << capacity << "异地扩容" << endl;
    }
    a = tmp;
    capacity = newcapacity;
  }
  a[top++] = x;
  }
  int Top()
  {
  return a[top - 1];
  }
  void Pop()
  {
  assert(top > 0);
  --top;
  }
  void Destroy()
  {
  free(a);
  a = nullptr;
  top = capacity = 0;
  }
  bool Empty()
  {
  return top == 0;
  }
private:
  //成员变量 
  int* a;//指针都是内置类型
  int top;
  int capacity;
};
int main()
{
  Stack st1;//使用栈的构造函数的默认初始值
  //st1.Init();
  st1.Push(1);
  st1.Push(2);
  st1.Push(3);
  st1.Push(4);
  while (!st1.Empty())
  {
  cout << st1.Top() << " ";
  st1.Pop();
  }
  cout << endl;
  st1.Destroy();
//直接写这种 -- 优化的写法
    Stack st2(0);//可以自定义初始化栈的数据 
  for (size_t i = 0; i < 1000; i++)
  {
  st2.Push(i);
  }
  while (!st2.Empty())
  {
  cout << st2.Top() << " ";
  st2.Pop();
  }
  cout << endl;
  st2.Destroy();
}

/
class Date
{
public:
//以下Date构造函数注释掉
  /*Date(int year=1 , int month = 1, int day = 1)
  {
  cout << "Date(int year =1,int month = 1.int day = 1)" << endl;
  _year = year;
  _month = month;
  _day = day;
  }*/
  void Print()
  {
  cout << _year << "/" << _month << "/" << _day;
  }
private:
  int _year =1;//这里给值是声明，不是初始化，因为初始化的特征是开空间，这里并没有开空间
  int _month ;
  int _day ;
};
int main()
{
  Date d1;//我们没写，编译器自动调用默认生成的构造函数，我们在声明的_year处给了初始值，所以    只有这个地方是赋值的，其他地方都是随机数
  d1.Print();
}

bool isValid(const char* s) {
  Stack st;
  while (*s)
  {
  if (*s == '[' || *s == '(' || *s == '{')
  {
    st.Push(*s);
    ++s;
  }
  else
  {
    // 不匹配
    if (st.Empty())
    return false;
    char top = st.Top();
    st.Pop();
    // 不匹配
    if ((*s == ']' && top != '[')
    || (*s == ')' && top != '(')
    || (*s == '}' && top == '{'))
    {
    return false;
    }
  
    ++s;
  }
  }
  return st.Empty();
}
int main()
{
  cout << isValid("[[]]()()") << endl;
  cout << isValid("[[]]]") << endl;
  return 0;
}

#日期类的构造函数和析构函数
class Date
{
public:
  Date()//构造函数
  {}
  ~Date()//析构函数
  {}
private:
  int _year ;
  int _month ;
  int _day ;
};
#栈类的构造函数和析构函数
class Stack
{
public:
  Stack()
  {}
  ~Stack()
  {}
private:
  int* a;
  int top;
  int capacity;
};

对于日期类，成员变量是_year、_month、_day(内置类型)，是属于d1对象的，这个对象在栈帧里面，栈帧出了作用域自动就销毁了，所以是不需要销毁的，日期类都不用写析构函数
        对于栈类(自定义类型)，是需要写析构函数的，但不用写Destroy()函数了,因为有析构函数就行了，它的作用就是清理资源，何为资源：malloc、fopen(动态)等

class Stack
{
public:
    Stack(size_t n=10)
    {
  if (n == 0)
     {
      a = nullptr;
    top = capacity = 0;
  }
  else
  {
    a = (int*)malloc(sizeof(int) * n);
    if (a == nullptr)
    {
    perror("realloc fail");
    exit(-1);
    }
  top = 0;
  capacity = n;
      }
  }
  ~Stack()
  {
  cout << "~Stack()" << endl;
  free(a);
  a = nullptr;
  top = capacity = 0;
  }
private:
  //成员变量 
  int* a;
  int top;
  int capacity;
};
class MyQueue
{
private:
  Stack _pushst;
  Stack _popst;
};
int main()
{
  MyQueue mq;
}