【C++初阶路】--- 类和对象(中)

class Date
{
public:
  //void InitDate(Date* const this, int year = 2024, int month = 6, int day = 14)
  void InitDate(int year = 2024, int month = 6, int day = 14)
  {
    _year = year;
    _month = month;
    _day = day;
  }

  //void PrintDate(Date* const this);
  void PrintDate()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }

private:
  int _year;
  int _month;
  int _day;
};

int main()
{
  Date d1;
  Date d2;
  //d1.InitDate(&d1);
  d1.InitDate();
  d2.InitDate(2024, 6, 17);
  d1.PrintDate();
  d2.PrintDate();

  return 0;
}

class A
{
public:
  void Print()
  {
    cout << "Print()" << endl;
  }
private:
  int _a;
};
int main()
{
  A* p = nullptr;
  p->Print();
  //(*p).PrintA(); ---- question 2
  return 0;
}

 1.下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行
class A
{
public:
  //void PrintA(A* const this)
    void PrintA()
    {
      //cout << this->_a << endl;
        cout << _a << endl;
    }
private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}
//

typedef int DataType;
typedef struct Stack
{
  DataType* array;
  int capacity;
  int size;
}Stack;
void StackInit(Stack* ps)
{
  assert(ps);
  ps->array = (DataType*)malloc(sizeof(DataType) * 3);
  if (NULL == ps->array)
  {
    assert(0);
    return;
  }
  ps->capacity = 3;
  ps->size = 0;
}
void StackDestroy(Stack* ps)
{
  assert(ps);
  if (ps->array)
  {
    free(ps->array);
    ps->array = NULL;
    ps->capacity = 0;
    ps->size = 0;
  }
}

void CheckCapacity(Stack* ps)
{
  if (ps->size == ps->capacity)
  {
    int newcapacity = ps->capacity * 2;
    DataType* temp = (DataType*)realloc(ps->array,
      newcapacity * sizeof(DataType));
    if (temp == NULL)
    {
      perror("realloc申请空间失败!!!");
      return;
    }
    ps->array = temp;
    ps->capacity = newcapacity;
  }
}

void StackPush(Stack* ps, DataType data)
{
  assert(ps);
  CheckCapacity(ps);
  ps->array[ps->size] = data;
  ps->size++;
}
int StackEmpty(Stack* ps)
{
  assert(ps);
  return 0 == ps->size;
}
void StackPop(Stack* ps)
{
  if (StackEmpty(ps))
    return;
  ps->size--;
}

DataType StackTop(Stack* ps)
{
  assert(!StackEmpty(ps));
  return ps->array[ps->size - 1];
}
int StackSize(Stack* ps)
{
  assert(ps);
  return ps->size;
}
int main()
{
  Stack s;
  StackInit(&s);
  StackPush(&s, 1);
  StackPush(&s, 2);
  StackPush(&s, 3);
  StackPush(&s, 4);
  printf("%d\n", StackTop(&s));
  printf("%d\n", StackSize(&s));
  StackPop(&s);
  StackPop(&s);
  printf("%d\n", StackTop(&s));
  printf("%d\n", StackSize(&s));
  StackDestroy(&s);
  return 0;
}

typedef int DataType;
class Stack
{
public:
  void Init()
  {
    _array = (DataType*)malloc(sizeof(DataType) * 3);
    if (nullptr == _array)
    {
      perror("malloc申请空间失败!!!");
      return;
    }
    _capacity = 3;
    _size = 0;
  }
  void Push(DataType data)
  {
    CheckCapacity();
    _array[_size] = data;
    _size++;
  }
  void Pop()
  {
    if (Empty())
      return;
    _size--;
  }
  DataType Top() { return _array[_size - 1]; }
  int Empty() { return 0 == _size; }
  int Size() { return _size; }
  void Destroy()
  {
    if (_array)
    {
      free(_array);
      _array = nullptr;
      _capacity = 0;
      _size = 0;
    }
  }
private:
  void CheckCapacity()
  {
    if (_size == _capacity)
    {
      int newcapacity = _capacity * 2;
      DataType* temp = (DataType*)realloc(_array, newcapacity *
        sizeof(DataType));
      if (temp == nullptr)
      {
        perror("realloc申请空间失败!!!");
        return;
      }
      _array = temp;
      _capacity = newcapacity;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
};
int main()
{
  Stack s;
  s.Init();
  s.Push(1);
  s.Push(2);
  s.Push(3);
  s.Push(4);
  printf("%d\n", s.Top());
  printf("%d\n", s.Size());
  s.Pop();
  s.Pop();
  printf("%d\n", s.Top());
  printf("%d\n", s.Size());
  s.Destroy();
  return 0;
}

class Date{};

class Date
{
public:
  //1. 无参构造函数
  Date()
  {}

  //2. 带参构造函数
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }

private:
  int _year;
  int _month;
  int _day;
};

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

class Date
{
public:
  /*
  // 如果用户显式定义了构造函数，编译器将不再生成
   Date(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;
  return 0;
}

class Date
{
public:
  Date()
  {
    _year = 1900;
    _month = 1;
    _day = 1;
  }
  Date(int year = 2024, int month = 5, int day = 9)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
};
// 以下测试函数能通过编译吗？
int main()
{
  Date d1;
  return 0;
}