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

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

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

例如，我们可以定义一个简单的学生类：

class Student        //Student为类名
{
    public：         //访问限定符
    void Display（） //成员函数
    {}
    private：
    char name[10];    //成员变量
    int num;
    char sex;
};

C++的三大特性：封装、继承、多态。
函数是封装的一种形式：函数所执行的细节行为被封装在函数本身这个更大的实体中，被封装的元素隐藏了他们的实现细节—可以调用一个函数但是不能够访问函数所执行的语句。
封装：隐藏对象的属性和实现细节，仅对外公开接口和对象进行交互，将数据和操作数据的方法进行有机结合。
类成员有以下3种不同的访问限定符
（1）公有成员访问限定符（public）：既可以被本类中的成员函数访问，也可以被类的作用域内的其他函数访问。
（2）私有成员访问限定符（private）：成员只能被该类中的成员函数访问，类外的其他函数则不能（友元类除外）
（3）保护成员访问限定符（protected）：成员只能被该类的成员函数或派生类的成员函数访问。
【说明】
1、public成员在类外可以直接访问
2、protected和private成员在类外(在此可将protected和private理解成private)不能够访问。
3、它们的作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
4、class的默认访问权限是private，而struct为public型(因为struct要兼容C)。
5、如果在类的定义中既不指定private，也不指定public，则系统默认是私有的。

class Date
{
  public:
  void SetDate(int year=2017, int month = 6, int day = 24)
  {
   _year = year;
   _month = month;
   _day = day;
  }
  void PrintDate()
  {
   cout<<_year<< "-"<<_month<<"-" <<_day<<endl;
  }
  private:
  int _year;
  int _month;
  public:
  int _day;
};
int main()
{
   Date d;
   d.SetDate(2017, 6, 25);
   d.PrintDate();
   // d._year = 2017; // 私有成员变量不能再类外直接访问
   // d._month = 6;
      d._day = 25;
   return 0;
}

类实例化
用类类型创建对象的过程称为实例化。

Date d; // 类实例化

1.类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
2.一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间存储类成员变量。
类对象存储模型
所以每个对象的大小为类中所有成员变量的大小之和，当然这里也遵循内存对齐原则。
2：整理四个默认成员函数及运算符重载相关知识
构造函数
变量应该被初始化，对象也需要初始化，那么怎么初始化一个对象呢？
C++中定义了一种特殊的初始化函数，称为构造函数，当对象被创建时，构造函数自动被调用。其名字与类名相同，在对象的生命周期内只且只调用一次，以保证每个数据成员都有一个合适的初始值。
【构造函数特性】
1、函数名与类名相同。
2、没有返回值。
3、有初始化列表(可以不用)。
4、新对象被创建，由编译器自动调用，且在对象的生命期内仅调用一次。
5、构造函数可以重载，实参决定了调用那个构造函数。
6、如果没有显式定义时，编译器会提供一个默认的构造函数。
7、无参构造函数和带有缺省值得构造函数都认为是缺省构造函数，并且缺省构造函数只能有一个。
例如：

class Date
{
  public:
  Date(int year=2017, int month = 6, int day = 24) //全缺省的构造函数，不能和无参的构造函数Date（）{}同时存在，因为两个都可以不传参调用
  {
   _year = year;
   _month = month;
   _day = day;
  }

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

【默认构造函数】
类如果没有显式定义构造函数时，编译器会合成一个默认的构造函数，该构造函数中什么工作都不做。只要显式定义了，即使该构造函数什么也不做，编译器也不会为该类合成默认的构造函数。编译器生成的默认构造函数使用与成员变量初始化相同的规则来初始化成员，具有类类型的成员通过运行各自的默认构造函数来进行初始化。内置和复合类型的成员如指针、数组，只对定义在全局作用域中的对象初始化，当对象定义在局部作用域时，内置和符合类型的成员不进行初始化。在某些情况下，默认构造函数是由编译器隐式使用的。

拷贝构造函数
只有单个形参，而且该形参是对本类类型对象的引用(常用const修饰)，这样的构造函数称为拷贝构造函数。拷贝构造函数是特殊的构造函数，创建对象时使用已存在的同类对象来进行初始化，由编译器自动调用。

class Date
{
  public:
  Date()
  {
  }
  Date(int year, int month, int day) 
  {
   _year = year;
   _month = month;
   _day = day;
  }
  Date(const Date& date)
 {
   _year = date._year;
   _month = date._month;
   _day = date._day;
  }
  private:
  int _year;
  int _month;
  int _day;
};

【特征】
1、它是构造函数的重载。
2、它的参数必须使用同类型对象的引用传递。
3、如果没有显式定义，系统会自动合成一个默认的拷贝构
造函数。默认的拷贝构造函数会依次拷贝类的数据成员完成初始化。
【使用场景】
1、对象实例化对象

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

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

void FunTest(const Date date)
{}

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

Date FunTest()
{
   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;
};

【特性】
a、析构函数在类名（即构造函数名）加上字符~。
b、析构函数无参数无返回值。
c、一个类有且只有一个析构函数。若未显示定义，系统会
自动生成缺省的析构函数。
d、对象生命周期结束时，C++编译系统系统自动调用析构函
数。
e、注意析构函数体内并不是删除对象，而是做一些清理工
作。
运算符重载
在C++中可以用关键字operator加上运算符来表示一个函数，即运算符重载。下面两个复数相加的函数为例进行介绍。假定定义了复数类Complex，则有：

Complex Addition（Complex a，Complex b）;

可以用运算符重载来表示

Complex operator+（Complex a，Complex b）;

这样就可以写成a+b的形式了。
然而并非所有的运算符都可以重载，下面是不能重载的运算符函数：

注意：
1、不能通过连接其他符号来创建新的操作符：比如

operator@；
void operator @(){}

2、重载操作符必须有一个类类型或者枚举类型的操作数

int operator +(const int _iNum1 , const int _iNum2 )
// 报错
{
return ( _iNum1 + _iNum2);
}
typedef enum TEST {one ,two ,three };
int operator+(const int _iNum1 , const TEST _test )
{
return _iNum1;
}

3、用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
5、不再具备短求职特性重载操作符不能保证操作符的求值顺序,在重载&&和||中，对每个操作数都要进行求值，而且对操作数的求职顺序不能做规定，因此：重载&&、||和逗号操作符不是好的做法。
6、作为类成员的重载函数，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参。

CTest operator+(const CTest test1, const CTest test2)const // 报错
{
return test1;
}
CTest operator+(const CTest test1)const
{
return test1;
}

7、一般将算术操作符定义为非成员函数，将赋值运算符定义成员函数
8、操作符定义为非类的成员函数时，一般将其定义为类的友元
9、== 和 != 操作符一般要成对重载
10、下标操作符[]：一个非const成员并返回引用，一个是const成员并返回引用
11、解引用操作符*和->操作符，不显示任何参数
13、自增自减操作符
前置式++/–必须返回被增量或者减量的引用
后缀式操作符必须返回旧值，并且应该是值返回而不是引用
返回
14、输入操作符>>和输出操作符<<必须定义为类的友元函数

3.隐含的this指针
http://blog.csdn.net/rae8023/article/