类的6个默认成员函数。

构造函数:包括无参构造函数和带参构造函数。
构造函数的函数名和类名相同；构造函数不是开空间，而是对对象初始化；没有返回值；在对象实例化时，可自动调用；可重载。

#include <iostream>
using namespace std;
class Data{
 public:
 //无参构造函数
  Data ( ){
   _year = 2019;
   _month = 1;
   _day = 15;
  }
 //带参构造函数:一般选择使用缺省参数。
  Data (int year = 2019, int month = 1, int day = 15){
   _year = year;
   _month = month;
   _day = day;
 }
 private:
  int _year;
  int _month;
  int _day;
}

注意：如果用户定义了构造函数，编译器不再生成。
C++把类型分成内置类型(基本类型)和自定义类型。
内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型。
编译器生成默认的构造函数会对自定类型成员调用的它的默认成员函数。

析构函数：析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而是对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
析构函数的函数名是在类名前加上~符号；无参数无返回值；一个类有且只有一个析构函数；对象生命周期结束时，C++编译系统系统会自动调用析构函数。

#include <iostream>
using namespaace std;
typedef int SEDataType;
class SeqList{
public:
 SeqList(int capacity = 6){
  _array = (SEDataType*)malloc(sizeof(int *)*capacity);
  assert (_array);
  _size = 0;
  _capacity = capacity;
 }
 ~SeqList( ){
  free(_array);
  _array = NULL;
  _size = 0;
  _capacity = 0;
 }
private:
 int* _array;
 int _size;
 int _capacity;
}
int main (){
 SeqList sq( );
 return 0;
}//对象生命周期结束时，C++编译系统系统自动调用析构函数.

编译器默认生成的析构函数，对会自定类型成员调用它的析构函数。

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

#include <iostream>
using namespace std;
class Data{
public:
 Data(int year=2019, int month=1, int day=15){
  _year = year;
  _month = month;
  _day = day;
  }
 Data(const Data**&** data1){
  _year = data1.year;
  _month = data1.month;
  _day = data1.day;
  }
 void Print( ){
 cout << _year << '-' << _month << '-' << _day << endl;
  }
private:
 int _year;
 int _month;
 int _day;
}
int main ( ){
 Data data1(2019,1,18);
 data1.Print( );
 Data copy(data1);
 copy.Print( );
 return 0;
}

运算符重载：关键字operator + 需要重载的运算符符号

重载操作符必须有一个类类型；
用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义；
作为类成员的重载函数时，其形参看起来比操作数数目少1，成员函数的操作符有一个默认的形参this，限定为第一个形参；
.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载

#include <iostream>
using namespace std;
class Data{
public:
  Data(int year,int month, int day){
  _year = year;
  _month = month;
  _day = day;
 }
 int _year;
 int _month;
 int _day;
}
//
bool operator==(const Data& d2,const Data& d3){
 return d2._year==d3._year && 
  d2._month==d3._month&&
  d2._day==d3._day;
}

#include <iostream>
using namespace std;
class Data{
public:
 Data(int year,int month, int day){
  _year = year;
  _month = month;
  _day = day;
 }
 //
 bool operator== (const Data& data3){
  return _year==d3._year && _month==d3._month && _day==d3._day;
 }
private:
int _year;
int _month;
int _day;
}
int main ( ){
 Data d2(2019,1,16);
 Data d3(2019,1,19);
 cout << (d2==d3) << endl;//其实是转换成cout<<operator==(d2,d3)<<endl;
 return 0;
}

operator既可以定义全局的，也可以在类中定义。

赋值运算符重载：

#include <iostream>
using namespace std;
class Data{
public:
 Data(int year,int month, int day){
  _year = year;
  _month = month;
  _day = day;
 }
 Data& operator=(const Data& d2){//引用
  if (this != &data2){//这里的d2是取地址,检查是否把自己赋给自己。
    _year = d2._year;
    _month = d2._month;
    _day = d2._day;
  }
  return *this;//注意！！！
}
private:
 int _year;
 int _month;
 int _day;
}
int main ( ){
 Data d2(2019,1,16);
 Data d1(2019,1,19);
 d1 = d2;// 把d1赋值给d2;
 return 0;
}

注意：赋值运算符重载的参数类型；有返回值（返回*this）；要检验是否自己给自己赋值。

const成员函数：在成员函数后面加const,const修饰this指针所指向的对象，也就是保证调用这个const成员函数的对象在函数内不会被改变。

const对象可以调用其他的const函数,但是不能调用非const函数；
非const对象既可以调用非const函数，又可以调用const函数。

类的6个默认成员函数。

猜你喜欢