类和对象（中）-阿里云开发者社区

1. 类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。

2. 构造函数

2.1 概念

对于以下的日期类：

class Date
{
public:
  void SetDate(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Display()
  {
    cout <<_year<< "-" <<_month << "-"<< _day <<endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1,d2;
  d1.SetDate(2022,6,21);
  d1.Display();
  Date d2;
  d2.SetDate(2022,6,22);
  d2.Display();
  return 0;
}

对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

答案是通过构造函数实现，构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。

2.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特性如下：

函数名与类名相同。
无返回值。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。
例如：

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 (2015, 1, 1); // 调用带参的构造函数
  // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
  // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
  Date d3();
}

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
例如：

class Date
{
public:
  /*
  // 如果用户显式定义了构造函数，编译器将不再生成
  Date (int year, int month, int day)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  */
private:
  int _year;
  int _month;
  int _day;
};
void Test()
{
  // 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
  Date d;
}

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
例如：

// 默认构造函数
class Date
{
public:
  Date()
  {
    _year = 1900 ;
    _month = 1 ;
    _day = 1;
  }
  Date (int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private :
  int _year ;
  int _month ;
  int _day ;
};

以下测试函数能通过编译吗？

void Test()
{
  Date d1;
}

显然，答案是不能，因为此时无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

3. 析构函数

3.1 概念

析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

3.2 特性

析构函数是特殊的成员函数。

其特征如下：

析构函数名是在类名前加上字符 ~。
无参数无返回值。
一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
对象生命周期结束时，C++编译系统系统自动调用析构函数。
例如：

typedef int DataType;
class SeqList
{
public :
  SeqList (int capacity = 10)
  {
    _pData = (DataType*)malloc(capacity * sizeof(DataType));
    assert(_pData);
    _size = 0;
    _capacity = capacity;
  }
  ~SeqList()
  {
    if (_pData)
    {
      free(_pData ); // 释放堆上的空间
      _pData = NULL; // 将指针置为空
      _capacity = 0;
      _size = 0;
    }
  }
private:
  int* _pData ;
  size_t _size;
  size_t _capacity;
};

关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。
例如：

class String
{
public:
  String(const char* str = "jack")
  {
    _str = (char*)malloc(strlen(str) + 1);
    strcpy(_str, str);
  }
  ~String()
  {
    cout << "~String()" << endl;
    free(_str);
  }
private:
  char* _str;
  };
    class Person
  {
private:
  String _name;
  int _age;
};
int main()
{
  Person p;
  return 0;
}

4. 拷贝构造函数

4.1 概念

构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

4.2 特征

拷贝构造函数也是特殊的成员函数，其特征如下：

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
例如：

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  Date(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  Date d2(d1);
  return 0;
}

若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。
例如：

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  // 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
  Date d2(d1);
  return 0;
}

5. 赋值操作符重载

5.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型或者枚举类型的操作数
用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
操作符有一个默认的形参this，限定为第一个形参全局的operator==

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
//private:
  int _year;
  int _month;
  int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
  return d1._year == d2._year;
  && d1._month == d2._month
  && d1._day == d2._day;
}
void Test ()
{
  Date d1(2018, 9, 26);
  Date d2(2018, 9, 27);
  cout<<(d1 == d2)<<endl;
}

类内的operator==

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  // bool operator==(Date* this, const Date& d2)
  // 这里需要注意的是，左操作数是this指向的调用函数的对象
  bool operator==(const Date& d2)
  {
    return _year == d2._year;
    && _month == d2._month
    && _day == d2._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
void Test ()
{
  Date d1(2018, 9, 26);
  Date d2(2018, 9, 27);
  cout<<(d1 == d2)<<endl;
}

5.2 赋值运算符重载

class Date
{
public :
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  Date (const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
  Date& operator=(const Date& d)
  {
    if(this != &d)
    {
      _year = d._year;
      _month = d._month;
      _day = d._day;
    }
  }
private:
  int _year ;
  int _month ;
  int _day ;
};

赋值运算符主要有四点：

参数类型
返回值
检测是否自己给自己赋值
返回*this

另外，一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  Date d2(2018，10， 1);
  // 这里d1调用的编译器生成operator=完成拷贝，d2和d1的值也是一样的。
  d1 = d2；
  return 0;
}

6. const成员函数

const修饰类的成员函数：

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

7. 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器默认会生成。

class Date
{
public :
  Date* operator&()
  {
    return this ;
  }
  const Date* operator&()const
  {
    return this ;
  }
private :
  int _year ; // 年
  int _month ; // 月
  int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

类和对象（中）

1. 类的6个默认成员函数

2. 构造函数

2.1 概念

2.2 特性

3. 析构函数

3.1 概念

3.2 特性

4. 拷贝构造函数

4.1 概念

4.2 特征

5. 赋值操作符重载

5.1 运算符重载

5.2 赋值运算符重载

6. const成员函数

7. 取地址及const取地址操作符重载

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

类和对象（中）

1. 类的6个默认成员函数

2. 构造函数

2.1 概念

2.2 特性

3. 析构函数

3.1 概念

3.2 特性

4. 拷贝构造函数

4.1 概念

4.2 特征

5. 赋值操作符重载

5.1 运算符重载

5.2 赋值运算符重载

6. const成员函数

7. 取地址及const取地址操作符重载

热门文章

最新文章

相关课程

相关电子书

相关实验场景