C++面向对象程序设计（用通俗易懂的方式去理解它）

第二章   函数

第一节     什么是构造函数

第二节     函数重载

第三节     默认构造函数

第四节     拷贝构造函数

第五节     初始化

第一节    构造函数

1. 特殊的成员函数（说明具有一般成员函数所具有的所有特性），作用：为对象分配内存并初始化对象为一个特定的状态。
2. 构造函数的名称必须与它所属的类名相同，应该被声明为公有函数，而且没有任何类型的返回值。
3. 会由系统自动调用，不能像其他成员函数被用户直接调用。
4. 构造函数，日期代码，举例如下：

• #include<iostream>
  using namespace std;
  class Date
  {
  private:
      int year;
      int month;
      int day;
  public:
  Date(int y,int m,int d);       
  void show_date();
  };
  Date::Date(int y,int m,int d)                               //带参数的构造函数
  {
      year=y;
      month=m;
      day=d;
      cout<<"constructor called"<<endl;
  }
  void Date::show_date()
  {
      cout<<year<<"/"<<month<<"/"<<day<<endl;
  }
  int main()
  {
      Date Today(2021,10,24),Tomorrow(2021,10,24);                //Date类的两个对象
      cout<<"Today is";
      Today.show_date();
      cout<<"Tomorrow is";
      Tomorrow.show_date();
  }
  

  第二节  函数重载

1. 函数名相同，通过个数和类型进行区分构造函数。优点：重载节省命名空间，对用户友好。
2. 系统根据函数名和参数列表共同确定该调用哪个函数。

•         构造函数的重载输出日期代码，举例如下：

#include<iostream>
using namespace std;
class Date
{
private:
    int year;
    int month;
    int day;
public:
    Date();                                      //声明一个无参数的构造函数
    Date(int y,int m,int d);                     //声明一个有参数的构造函数
    void show_Date;                              //声明成员函数
};
Date::Date()                                     //在类外定义无参数构造函数
{
    year=2021;
    month=10;
    day=24;
}
Date::Date(int y,int m,int d)                    
{
    year=y;
    month=m;
    day=d;
}
void Date::show_Date()
{
    cout<<year<<"/"<<month<<"/"<<day<<endl;
}
int main()
{
    Date Today(2021,10,24);
    Date Tomorrow;
    Today.show_Date();
    Tomorrow.show_Date();
}

第三节   默认构造函数

1. 在C++的类中必须要有一个构造函数，这个构造函数可以是系统提供的，亦可以是自己定义的。
2. 声明构造函数时，可以为其提供默认参数。优点：在声明函数时没有提供参数，也会按照默认的参数对对象进行初始化。注意：一个类不能同时拥有多个默认构造函数。
3. 带默认参数的构造函数举例：

   #include<iostream>
   using namespace std;
   class Date
   {
   private:
       int year;
       int month;
       int day;
   public:
       Date(int y=2021,int m=10,int d=24);                 //默认参数值
       void show_Date();                                   //声明成员函数
   };

第四节  拷贝（复制）构造函数

1. 使用一个已经存在的对象去初始化一个新建的同类的对象，顾名思义，就是将一个已有对象的数据成员的值复制给正在创建的另一个的同类的对象。

        举例：已经有一个Date类的对象Today，希望生成一个相同的对象Tomorrow：

Date Today(2021,10,24);
Date Tomorrow(Today);

        拷贝构造函数也是构造函数，所以具有一般构造函数的所有特性，名字也与所属类名相同，且没有返回值；只能有一个参数，这个参数是这个类的地址引用。

        2.如果程序员不定义，系统会自动生成一个默认的复制构造函数。

        定义复制构造函数一般格式：

class 类名
{
public:
    类名(参数)
    类名(类名&对象名)
};

         代码举例：

class Date
{
private:
    int year;
    int month;
    int day;
public:
    Date(int y,int m,int d);
    Date(Date&day);
    void print();
};
...
Date::Date(Date&myday)
{
    year=myday.day;
    month=myday.month;
    day=myday.day;
}
 ...

第五节     对类和对象初始化

1. 对象初始化：在定义变量时对其赋以初值即可。举例：

   int x=1024;                   //定义一个整型变量x，x的初始值为1024

数据成员初始化：在定义对象的同时指定数据成员的初值即可。老生常谈：构造函数的名字必须与类名相同。不可以任意命名。

#include<iostream>
using namespace std;
class Date
{
private:
    int year;
    int month;
    int day;
public:
    Date()                                  //定义构造成员函数，函数名与类名相同
    {                           
    year=2021;                             //利用构造函数对对象中的数据成员赋初始值
    month=10;
    day=24;
    }
    void set_Date();
    void show_Date();
};
void Date::set_Date()                              //定义成员函数，向数据成员赋值
{
    cin>>year;
    cin>>month;
    cin>>day;
}
void Date::show_Date()                            //定义成员函数，输出数据成员的值
{
    cout<<year<<"/"<<month<<"/"<<day<<endl;
}
int main()
{
    Date D1;                                //建立对象D1,同时调用成员函数D1.Date()
    D1.set_Date;                            //对D1的数据成员赋值
    D1.show_Date;                           //显示D1的数据成员的值
    Date D2;                                //建立对象D2，同时调用成员函数D2.Date()
    D2.set_Date;                            //对D2的数据成员赋值
    D2.show_Date;                           //显示D2的数据成员的值
    return 0;
}

        2. 在函数首部用参数初始化表对数据成员初始化。举例：

Date::Date(int y,int m,int d):year(y),month(m),day(d){}

        即在原来函数首部的末尾加一个冒号，然后列出参数的初始化列表；后面的括号为空表示函数体为空。优点：减少函数体的长度，更加精炼。一般形式：

类名::构造函数名(参数表)：成员初始化表
{
构造函数体
}