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

point of division

   1.类和对象的基础知识，如类的定义，访问限定符，面向对象封装性，对象的大小计算等等
   2.四个默认成员函数及运算符重载相关知识
   3.隐含的this指针等等，及对运算符重载背后做的事情

1.类和对象的基础知识

①类的定义：

    类是对某种类型的对象变量和方法的原型。类是从一些具有相同属性或功能的具体实例，抽象出共有的一些属性的，自定义抽象数据类型。

    类是对某个对象的定义。它包含有关对象动作方式的信息，包括它的名称、方法、属性和事件。实际上它本身并不是对象，因为它不存在于内存中。当引用类的代码运行时，类的一个新的实例，即对象，就在内存中创建了。虽然只有一个类，但能从这个类在内存中创建多个相同类型的对象。

C++中使用关键字 class 来定义类, 其基本形式如下:

class Person
{
public:
// 成员函数
 void Display()
 {
  cout<<_name<<":"<<_age<<":"<<_sex<<":"<<_id<<endl;
 }

private:
// 成员变量
 char* _name;
 int _age;
 char* _sex;
 int _id;
 // ...
};

②访问限定符

   公有成员public : 在程序的任何地方都可以被访问

   私有成员private: 只能被成员函数和类的友元访问实行信息隐藏的类把其数据成员声明为private

   保护成员protected: 对派生类derived class 就像public 成员一样对其他程序则表现得像private

   如果紧跟在类名称的后面声明私有成员，则关键字private可以省略，例如：
   class person
   {
       int age，id；//age和id是私有成员，即为private类型
   }；

③面向对象封装性

   面向对象有三大特性：封装、继承、多态。

   封装：将方法和数据封装在类里面，可以根据访问限定符的使用保证数据的安全性，隐藏了方法的实现细节，也方便使用。

   继承：对已有类增加属性和功能或进行部分修改来建立新的类，是实现代码的复用的重要手段，继承是类型之间的关系建模。

   多态：在面向对象的程序里面，同一个消息被不同的对象接受后可以导致不同的行为，是接口的多种不同的实现方式。

封装——Encapsulation
         隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
   1. 将变化隔离；
   2. 便于使用；
   3. 提高复用性；
   4. 提高安全性；
原则：
    1. 将不需要对外提供的内容都隐藏起来；
    2. 把属性都隐藏，提供公共方法对其访问。

④对象大小的计算

   C++中类的成员函数，静态成员是不占类的大小的。类的大小等于基类的大小+子类个non-static成员变量的大小再+非虚基类大小。

   1、空类的大小为1字节

   2、字节对齐的问题
   成员变量需要整齐的存储，所以若是有不同类型的变量（本身占用字节数不同），则所有变量的大小会按照最大的的大小进行补齐，比如说，若是一个类中有个bool型和int型，则bool型也会占用4个字节。若最大的为short，则bool型或者char型会补齐成为2个字节，最大的为double，则都补齐成为8字节。

2.四个默认成员函数及运算符重载相关知识

①四个默认成员函数：

   对于一个空类，编译器默认生成四个成员函数：默认构造函数、析构函数、拷贝构造函数、赋值函数。

1）默认构造函数

    默认构造函数（default constructor）就是在没有显式提供初始化式时调用的构造函数。它由不带参数的构造函数，或者为所有的形参提供默认实参的构造函数定义。如果定义某个类的变量时没有提供初始化式就会使用默认构造函数。
　如果用户定义的类中没有显式的定义任何构造函数，编译器就会自动为该类型生成默认构造函数，称为合成的构造函数。

构造函数是特殊的成员函数，其特征如下：
  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象构造（对象实例化）时系统自动调用对应的构造函数。
  4. 构造函数可以重载。
  5. 构造函数可以在类中定义，也可以在类外定义。
  6. 如果类定义中没有给出构造函数，则C++编译器自动产生一个缺省的构造函数，但只要我们定义了一个构造函数，系统就不会自动 生成缺省的构造函数。
  7. 无参的构造函数和全缺省值的构造函数都认为是缺省构造函数，并且缺省的构造函数只能有一个。

分类：

a. 无参构造函数&带参的构造函数

// 1.无参构造函数     
   Date ()
   {}
// 2.带参构造函数    
   Date (int year, int month , int day )
   {         
          _year = year ;
          _month = month ;
          _day = day ;
    }

b. 带缺省参数的构造函数

// 3.缺省参数的构造函数
     Date (int year = 2000, int month = 1, int day = 1)
     {          
           _year = year ;
          _month = month ;
          _day = day ;
    }
// 4.半缺省参数的构造函数（不常用）
     Date (int year, int month = 1)
     {         
           _year = year ;
          _month = month ;
          _day = 1;
    } 

2）拷贝构造函数

   创建对象时使用同类对象来进行初始化，这时所用的构造函数称为拷贝构造函数（Copy Constructor），拷贝构造函数是特殊的构造函数。
特征：
1. 拷贝构造函数其实是一个构造函数的重载。
2. 拷贝构造函数的参数必须使用引用传参，使用传值方式会引发无穷递归调用。
3. 若未显示定义，系统会默认缺省的拷贝构造函数。缺省的拷贝构造函数会，依次拷贝类成员进行初始化。

// 拷贝构造函数     
   Date (const Date& d)  //必须使用引用传参  
   {          
         _year = d ._year;
         _month = d ._month;
         _day = d ._day;
    } 

3）析构函数

   当程序员没有给类创建析构函数，那么系统会在类中自动创建一个析构函数，形式为：~A（）{},为类A创建的析构函数。当程序执行完后，系统自动调用自动创建的析构函数，将对象释放。
   默认的析构函数不能删除new运算符在自由存储器中分配的对象或对象成员。如果类成员占用的空间是在构造函数中动态分配的，我们就必须自定义析构函数，然后显式使用delete运算符来释放构造函数使用new运算符分配的内存，就像销毁普通变量一样。
构造函数是特殊的成员函数，其特征如下：
  1. 析构函数在类名加上字符~。
  2. 析构函数无参数无返回值。
  3. 一个类有且只有一个析构函数。若未显示定义，系统会自动生成缺省的析构函数。
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
  5. 注意析构函数体内并不是删除对象，而是做一些清理工作。

class Array 
{ 
public :     
    Array (int size)    
   {          
         _ptr = (int *)malloc( size*sizeof (int));    
   }
     // 这里的析构函数需要完成清理,释放工作   
     ~ Array ()    
     {          
          if (_ptr )         
          {              
              free(_ptr );
              _ptr = 0;
          }    
     }
private :     
    int* _ptr ;
 };

4）赋值函数

   每个类只有一个赋值函数，赋值运算符的重载是对一个已存在的对象进行拷贝赋值，它是两个已有对象一个给另一个赋值的过程。它不同于拷贝构造函数，拷贝构造函数是用已有对象给新生成的对象赋初值的过程。

   默认的赋值运算符重载函数实现的数据成员的逐一赋值的方法是一种浅层拷贝。

// 赋值操作符的重载
Date& operator = (const Date& d)    
{            
       if (this != &d)         
       {              
            this->_year = d. _year;
            this->_month = d. _month;
            this->_day = d. _day;
        }
          return *this ;
}

②运算符重载相关知识

1）参数

一般地，赋值运算符重载函数的参数是函数所在类的const类型的引用，加const是因为：

①我们不希望在这个函数中对用来进行赋值的原值做任何修改。

②加上const，对于const的和非const的实参，函数就能接受；如果不加，就只能接受非const的实参。

用引用是因为：

这样可以避免在函数调用时对实参的一次拷贝，提高了效率。但是比如++运算符就不适合用const，const只是一个建议，它就是提升你文件的严密性。

2）返回值

一般地，返回值是被赋值者的引用，即*this。原因：

①这样在函数返回时避免一次拷贝，提高了效率。

②更重要的，这样可以实现连续赋值，即类似a=b=c这样。如果不是返回引用而是返回值类型，那么，执行a=b时，调用赋值运算符重载函数，在函数返回时，由于返回的是值类型，所以要对return后边的“东西”进行一次拷贝，得到一个未命名的副本（有些资料上称之为“匿名对象”），然后将这个副本返回，而这个副本是右值，所以，执行a=b后，得到的是一个右值，再执行=c就会出错。

3）赋值运算符重载函数要避免自赋值

对于赋值运算符重载函数，我们要避免自赋值情况的发生，一般地，我们通过比较赋值者与被赋值者的地址是否相同来判断两者是否是同一对象。

①为了效率。显然，自己给自己赋值完全是毫无意义的无用功，特别地，对于基类数据成员间的赋值，还会调用基类的赋值运算符重载函数，开销是很大的。如果我们一旦判定是自赋值，就立即return *this，会避免对其它函数的调用。

②如果类的数据成员中含有指针，自赋值有时会导致灾难性的后果。对于指针间的赋值，先要将p所指向的空间delete掉，然后再为p重新分配空间，将_p所指的内容拷贝到p所指的空间。如果是自赋值，那么p和_p是同一指针，在赋值操作前对p的delete操作，将导致p所指的数据同时被销毁。对于赋值运算符重载函数，一定要先检查是否是自赋值，如果是，直接return *this。

3.隐含的this指针

  1. 每个成员函数都有一个指针形参，它的名字是固定的，称为this指针，this指针是隐式的。(构造函数比较特殊，没有这个隐含this形 参)
  2. 编译器会对成员函数进行处理，在对象调用成员函数时，对象地址作实参传递给成员函数的第一个形参this指针。
  3. this指针是成员函数隐含指针形参，是编译器自己处理的，我们不能在成员函数的形参中添加this指针的参数定义，也不能在调用时 显示传递对象的地址给this指针。

例如：

void Display (Date* this)
{
	//cout <<_year<< "-" <<_month << "-"<< _day <<endl;
	cout <<this->_year<< "-" <<this->_month << "-"<<this->_day <<endl;
}

关于运算符重载背后做的事情 —— 编辑器处理

类如：

bool operator == (Date* this, const Date& d)
{
	return this->_year == d._year
		&& this->_month == d._month
		&& this->_day == d._day;
}

Date d1, d2;               Date d1, d2;

d1 == d2;                   d1.operator == (&d1 , d2);