1. 前置++和后置++

1.1前置++和后置++示例

前置++返回的是对象本身，后置++返回局部对象

Int& operator++()
{
    this->value;
    return *this;
}//++a;返回对象本身
Int


 operator++(int)
{
    Int old = *this;
    ++* this;
    return old;
}//c=a++;返回局部对象

1.2前置++和后置++在编译器的内部运行过程

Int operator++(int)
{
    Int old = *this;
    ++* this;
    return old;
}
Int operator++(const int x) const
{
    return Int(this->value + x);
}

int a = 0;
a = a++ + 1;
//编译器进行过程
a = a.operator++(0) + 1;
a = a.operator++(&a, 0) + 1;//第一个参数a传递给this指针，第二个参数用于区分前置和后置，只要是整型数值均可
a = operator++(&a,0).operator+(1)
a = operator+(&operator++(&a,0),1);//用对象调动成员方法，将对象地址传入相加

//赋值语句重载
a.operator=(operator+(&operator++(&a, 0), 1));
operator=(&a, operator+(&operator++(&a, 0), 1));
//1.对a进行+1操作  2.a的值变为1  3.后置++返回对象  4.返回对象与1相加变为1  5.相加后的值返回给a=1

1.3普通对象前置++和后置++

//举例：中缀表达式变为后缀表达式之后可以去掉括号等多余东西
a + b * c;
//1. a  b  c  *  +
//2. a  b*c  +入栈顺序

1.4在进行运算符重载时候什么情况下以引用返回，什么时候以值返回？

两个整数相加有返回值，赋值语句相加也有返回值。若运算符操作后返回自身，以引用返回；如果返回临时量或者将亡值，就返回值。

2. 构造函数

2.1 构造函数用途

① 创建对象
② 初始化对象中的属性
③类型转换（可以将内置类型转换为自己设计的类型，从而给变量进行赋值，当构造函数只有一个参数时，才能进行类型转换）

2.2构造函数类型转换（运算符重载）

（1）将内置类型转换为自己设计的类型

如不允许隐式构造，则加上explicit关键字

explicit关键字详解

#include<iostream>
using namespace std;

class Int
{
private:
    int value;
public:
    explicit Int(int x = 0) :value(x)//explicit关键字
    {
        cout << "Create Int:" << this << endl;
    }
    Int(const Int& it) :value(it.value)
    {
        cout << "Copy Create Int" << this << endl;
    }
    Int& operator=(const Int& it)
    {
        if (this != &it)
        {
            value = it.value;
        }
        cout << this << " + " << &it << endl;
        return *this;
    }
    ~Int()
    {
        cout << "Destroy Int:" << this << endl;
    }
};
int main()
{
    Int a(10);
    int b = 100;

    a = (Int)b;//强转后赋值
    return 0;
}

    Int(int x,int y = 0) :value(x + y)//explicit关键字
    {
        cout << "Create Int:" << this << endl;
    }
    //int b=100;
    //1.a=(Int)(b,20); 20 强转将20赋值给x,y=0，类型转换方式产生，构造函数单参;
    //2.a=Int(b,20); 120 调用构造函数创建无名对象,将20赋值给y,x=100;

（2）将对象赋值给内置类型

设计强转类型
注：强转后返回类型为自身类型，所以函数无返回类型

类型强转函数

 //重载整型强转运算符，对象强转赋值个变量
    operator int() const
    {
        return value;
    }
int main()
{
    Int a(10);
    int b = 100;
    a = (Int)b;//强转后赋值

    b = a;
    b = a.operator int();
    //b=operator int(&a);
    b = (int)a;

    return 0;
}

2.3其他运算符重载

c++ 关键字 mutable

class Add
{
    mutable int value;
public:
    Add(int x=0) :value(x) {}
    //重载()运算符
    int operator()(int a, int b) const
    {
        value = a + b;
        return value;
    }

};
int main()
{
    int a = 10, b = 20, c = 0;
    Add add;
    c = add(a, b);//重载()运算符的对象称之为仿函数（add）
    //c= add.operator()(a,b);
    return 0;
}

（1）对象调用拷贝构造函数，调动缺省构造函数构建全局对象num和val
（2）进入构造函数函数内部，对num和val进行赋值
（3）调用构造函数创建临时对象，调动赋值语句
（4）调动析构函数，obj对象构建完成，先释放成员对象，然后释放对象本身
构建顺序和参数列表无关

class Object
{
    int num;//调动缺省构造函数构建
    int val;
public:
    Object(int x, int y)//对象调用拷贝构造函数，进入函数之内，
    {
        num = x;
        val = y;
    }
};
int main()
{
    Object obj(1, 2);
}

2.4成员指针

class Object
{
    int* ip;//调动缺省构造函数构建
    int val;
public:
    Object(Int*s=NULL) :ip(s)//对象调用拷贝构造函数，进入函数之内，
    {

    }
    Object()
    {
        if (ip != NULL)
        {
            delete ip;
        }
        ip = NULL;
    }
};
int main()
{
    Object obj(new Int(10));
}

对生存期自动管理（系统自动生成析构函数）

1.从堆区申请空间
2.调用构造函数构建对象
3.返回构建对象地址

3. 运算符重载

3.1组合

强关联组合——弱关联组合——强引用关系

class Int() {};
class Object
{
    int num;
    Int value;
};
//值类型组合

class Int() {};
class Object
{
    int num;
    Int *ip;
};//指针类型组合
//重载*运算符，->运算符返回堆区地址

class Int() {};
class Object
{
    int num;
    Int& val;
};//引用类型组合