【c++】类和对象--四个默认成员函数+运算符重载

类的声明和定义
c++中类的定义一般分为类的声明部分和类的实现部分。类的声明部分用来说明该类中的成员（数据成员，成员函数），告诉使用者“干什么”。类的实现部分用来定义成员函数，该函数用来对数据成员进行操作，告诉使用者“怎么做”。
类定义的形式：

class <类名>
{
    public:
    <成员函数或者数据成员的说明>
    protected:
    <成员函数或者数据成员的说明>
    private:
    <成员函数或者数据成员的说明>
}：                      //类的声明部分
<各成员函数的实现>         //类的实现部分

实现一个简单的类：

class Student       //类名
{
public:            //访问限定符
    void Disply(); //成员函数
private:
    char _Name[10];//成员变量
    char _Sex[3];
    int _Age;
};

类的三大特性：封装，继承，多态
函数是封装的一种形式：函数所执行的细节行为被封装在函数本身这个更大的实体中，被封装的元素隐藏了他们的实现细节—可以调用一个函数但是不能够访问函数所执行的语句。
封装：隐藏对象的属性和实现细节，仅对外公开接口和对象进行交互，将数据和操作数据的方法进行有机结合。
类成员有以下3种不同的访问限定符
（1）公有成员访问限定符（public）：既可以被本类中的成员函数访问，也可以被类的作用域内的其他函数访问。
（2）私有成员访问限定符（private）：成员只能被该类中的成员函数访问，类外的其他函数则不能（友元类除外）
（3）保护成员访问限定符（protected）：成员只能被该类的成员函数或派生类的成员函数访问。
如果在类的定义中既不指定private，也不指定public，则系统默认是私有的。在一个类体中，public和pirvate可以分别出现多次，既在一个类体中可以包含多次，每个部分的作用范围到出现另外一个成员访问限定符或者类体的结束为止。

class Date
{
public:
    void SetDate(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Display()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d;
    d.SetDate(2017, 6, 26);
    d.Display();
    //d._year = 2017;//私有的成员不能再类外被访问
    system("pause");
    return 0;
}

类的实例化
对象是类的实例，类就像以一张图纸，而对象才是按照图纸建造的房子。

Date d;//实例化出对象d

构造函数
c++定义了一种特殊的初始化函数，叫做构造函数。当对象创建时，构造函数自动被调用
例子：

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)//构造函数
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Display()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d;
    d.Display();
    system("pause");
    return 0;
}

结果：

我们看到，当对象d创建后系统自动调用了构造函数。
【特征】：
1，函数名和类名相同
2，无返回值
3，对象构造时系统自动调用
4，可以再类内/类外定义。
5，当没有显式定义构造函数时，系统会自动生成一个默认的构造函数！
6，无参的构造函数，和全缺省的构造函数都认为是缺省的构造函数，并且缺省的构造函数只能有一个。
拷贝构造函数
拷贝构造函数是构造函数的重载，只有单个形参，而且该形参是对本类类型对象的引用(常用const修饰)，这样的构造函数称为拷贝构造函数。拷贝构造函数是特殊的构造函数，创建对象时使用已存在的同类对象来进行初始化，由编译器自动调用。
例子：

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;
    }
    void SetDate(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Display()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2017,6,26);//创建对象d1同时初始化。————调用了构造函数
    Date d2(d1);//创建对象d2同时用d1初始化它————调用了拷贝构造函数
    d1.Display();
    d2.Display();
    system("pause");
    return 0;
}

结果：

【特征】：
1，创建对象时使用同类对象进行初始化
2，必须使用引用传参
3，若未显示定义，系统就会默认生成，会依次拷贝类的数据成员完成初始化。
【使用场景】
1——对象实例化对象

Date d1(2017, 6, 25);
Date d2(d1);

2——传值方式作为函数的参数

void FunTest(const Date date)
{}

3——传值方式作为函数返回值

Date Fun()
{
   Date date;
   return date;
}

析构函数
析构函数与构造函数相反，是在对象被删除前由系统自动调用执行它做清理工作。例如，在建立对象是用new分配的内存空间，应在析构函数中用delete释放。析构函数也与类同名，但在名字前面有一个“~”符号，析构函数没有返回值和返回类型。
例子：

class Array
{
   public:
   Array(size_t capacity)
   : _capacity(capacity)
  {
    _pData = ( int*)malloc(capacity*sizeof (int));
    _size = 0;
  }
   ~Array()    //析构函数
  {
    if (NULL != _pData)
    {
     free(_pData);
     _pData = NULL; 
    }
    _size = 0;
    _capacity = 0;
  }
  private:
  int* _pData;
  size_t _size;
  size_t _capacity;
};

【特征】：
1，在类名前加“~”
2，无参，无返回值
3，若未显式定义，系统会UI自动默认生成
4，对象生命周期到了，系统默认生成
5，并不是删除对象，而是做清理工作

运算符重载
在c++中，可以用关键字operator加上运算符来表示一个数，
就是运算符重载就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。下面两个复数相加的函数为例进行介绍。假定定义了复数类Complex，则有：

Complex Addition(Complex a,Complex b)
{
 //
}

可以用运算符重载来表示：

Complex operator+(Complex a,Complex b)
{
 // 
}

这样就可以写成a+b的形式了。
不能重载的运算符:

【运算符重载为类的成员函数的一般语法形式为：】
函数类型 operator 运算符（形参表）
{
函数体；
}
【运算符重载规则如下：】
①、 C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。
②、 重载之后运算符的优先级和结合性都不会改变。
③、 运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。重载为类的成员函数和重载为类的友元函数。

this指针
this指针是一个自动生成,自动隐藏的私有成员，它存在类的非静态成员函数中，他指向被调用函数所在的对象。全局只有一个this指针，当一个对象被创建时，this指针就存放指向对象数据的首地址！
一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。
例如，调用date.SetMonth(9) <===> SetMonth(&date, 9)，this帮助完成了这一转换 .
【使用】
一种情况就是，在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this；另外一种情况是当参数与成员变量名相同时使用this指针，如this->n = n （不能写成n = n）。