Cpp类和对象之四个默认成员函数和运算符重载

访问限定符

访问限定符分为 public,protected,private;
1.public成员可从类外部直接访问，private/protected成员不能从类外部直接访问

2.每个限定符在类体中可使用多次，它的作用域是从该限定符出现开始到下一个限定符之前或类体结束
3.类体中如果没有定义限定符，则默认为私有的
4.类的访问限定符体现了面向对象的封装型

类的作用域:

作用域分为局部域，全局域，类域，名字空间域
1.每个类都定义了自己的作用域，类的成员(成员函数/成员变量)都在类的这个作用域内，成员函数内可任意访问成员变量和其它成员函数
2.对象可以通过.直接访问公有成员，指向对象的指针通过->也可以直接访问对象的公有成员。
3.在类体外定义成员，需要使用::作用域解析符指明成员属于哪个类域。

类的定义:

class Person
{
public:
    //类内定义成员函数
    void Display()
    {}
private:
    char * _name;
    char* _sex;
    int _age;

}
void Person::Find()
{
}

对象:

类相当于房子的设计图，只是一个模子，不占用内存，真正用的时候需要实例化一个对象，对象可以实际存储数据，占用物理空间

void test()
{
    Person p;//这个占真正的物理空间，可以存储数据

}

类对象的存储模型

每个对象数据存储在内存中，成员函数在公共代码区(这样明显更高效，更省空间)

内存对齐

结构体内存对其规则：
1.第一个成员在与结构体变量偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
//对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的值为8
gcc中的默认值为4
3.结构体总大小为最大对齐数（每个成员变量除了第一个成员都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体
的对齐数）的整数倍

class A
{
    char ch;
    int a;

};
class B
{
    char c;
    A a;
    int d;

}

类的六个默认成员函数

类的六个默认成员函数分别是
1.构造函数
2.拷贝构造函数
3.析构函数
4.赋值操作符重载
5.取地址操作符重载
6.const修饰的取地址操作符重载
主要来了解最常用的前四个

1.构造函数

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

class Date
{
public:
    //1.无参构造函数
    Date()
    {}
    //2.带参数构造函数
    Date(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //3.缺省参数的构造函数
    Date(iny year=2000,int month = 1, int day =1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;

};
void test()
{
    Date d1;            //调用无参构造函数
    Date d2(2016,1,1);  //调用带参的构造函数
    Date d3();          //注意这里没有调用d3的构造函数定义出d3
    Date d4;            //这个调用3.缺省参数的构造函数

}

2.拷贝构造函数

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

class Date
{
public:
    Date()
    {}
    Date(const Date& d)
    {
        //这里的对象可以直接访问私有的成员变量原因
        //1.在类的成员函数可以直接访问同类对象的私有/保护成员
        //2.C++的访问限定符是以类为单位的，也就是说在这个单位内的成员可以互相访问
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};
void test()
{
    Date d1;
    //下面两者等价
    Date d2(d1);//调用拷贝构造函数
    Date d3=d1; //调用拷贝构造函数

}

3.析构函数

当一个对象的生命周期结束时，C++编译系统会自动调用一个成员函数，这个特殊的成员函数即析构函数
其特征如下：
1. 析构函数在类名加上字符~。
2. 析构函数无参数无返回值。
3. 一个类有且只有一个析构函数。若未显示定义，系统会自动生成缺省的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 注意析构函数体内并不是删除对象，而是做一些清理工作(本质是释放空间)。

运算符重载

运算符的重载是为了增强程序的可读性，c++支持运算符重载
运算符重载特征：
1.operator+合法的运算符构成函数名(例如重载<运算符：operator<)
2.重载运算符以后，不能改变运算符的优先级/结合性/操作数个数
这里注意：.*/::/sizeof/?:/. 这5个运算符不支持重载

class Date
{
public:
    //这里返回值必须是Date&d的返回值，这样方便链式访问
    //我们这里这样子给参数列表实际在编译器是
    //Date& operator=(Date* this,const Date& d)
    //这里的这个this指针是隐含的
    Date& operator=(const Date& d)
    {
        //这里if是为了防止自己给自己赋值
        if(this!=&d)
        {
            this->_year = d. _year;
            this->_month = d. _month;
            this->_day = d. _day;
        }
            return *this;
    }
private:
    int _year;
    int _month;
    int _day;
};
void Test()
{
    Date d1;
    Date d2=d1;//调用拷贝构造函数

    Date d3;
    d3=d1;    //调用赋值运算符的重载
}