<C++> 类（2）：对象的种类 类之间的关系 重载操作符operator

一.对象的种类

1.全局对象：

①生命周期：程序结束

②执行顺序：return 0 → } → 析构

2.栈区局部对象：

①生命周期：作用域结束

②执行顺序：return 0 → 析构 → }

3.堆区的指针对象：

①生命周期：遇到delete结束

注：new出来的对象没有delete就没有析构函数 哪怕是作用域结束了也没有

4.临时对象：

①生命周期：仅限当前这一行

②代码说明：

#include<iostream>
using namespace std;

class CPerson
{
public:
    CPerson QQ()
    {
        CPerson qq;
        return qq;
    }
};

int main()
{
    CPerson kk;
    kk = kk.QQ();

    return 0;
}

其实到return pp的那一行 return完了就已经把qq删了 所以才会创建一个临时对象接着qq的值

也就是说 下面主函数在第17行执行调用QQ函数的时候 会在这一行创建一个临时对象

临时对象的产生是电脑做的 临时对象的构造函数执行的是电脑里面默认的

用这个临时对象接着函数的返回值 然后把这个临时对象装在kk里面

如果你不想让他创建临时对象的话 可以把函数返回值和参数改成CPerson&类型的

返回值类型如果是CPerson 那么在外面就叫创建临时对象

返回值类型如果是CPerson& 这就相当于只是把一个名字拿出来了

总结：大部分对象都是在堆区new出来的 因为这样比较方便去控制他的生命周期

5.为什么有了malloc和free还要有new和delete呢？（new还是用malloc去定义的）

malloc和free是不调用构造函数和析构函数的 只是单纯的去申请空间和释放空间的

但是！！！

new：①分配空间 ②调用构造和初始化 ③返回空间地址

delete：①调用析构 ②删除对象空间

也就是说：new和delete都可以触发构造函数和析构函数

6.杂乱补充：

①空类的大小：一个字节（后面还会对空类的内容进行补充）

类是抽象的 不存在的 是有定义类的实体 也就是只有定义对象的时候 才会被分配空间

②成员变量和成员函数：

成员变量是在创建对象的时候就存在的 普通的成员变量每个对象都有一份 静态成员变量是所有对象公用一份（这个在后面也会再写 具体有所补充）

成员函数是在编译的时候就存在了 并且只有一份

③不同的地址取得的就是不同的变量 谁调用就用谁的地址 就把谁的地址传进去

普通的成员函数 都会有一个隐藏的参数：CPerson* this（拿CPerson为例）

每一个普通的成员参数都有一个隐藏的指针this 这个指针用来装调用对象的地址 用来区分不同对象的成员

例如：

#include<iostream>
using namespace std;

class CPerson
{
public:
    int a;
public:
    CPerson(int b)
    {
        a = b;
    }
    void Show(/*CPerson* this*/)
    {
        cout << this << endl;
        cout << this -> a << endl;
    }
};

int main()
{
    CPerson aa(100);
    cout << &aa << endl;
    aa.Show(/* &aa */);

    CPerson bb(200);
    cout << &bb << endl;
    bb.Show(/* &bb */);
    return 0;
}

二.类之间的关系

类之间的关系分为两种：

1.纵向关系：继承

①语法：class CSuperman : public CPerson{ ... };

把父类中的所有成员拿过来

横线处的访问修饰符可以替换 访问修饰符不同 继承过来也是有差别的

#include<iostream>
using namespace std;

class CPerson
{
public:
    void ShowEat()
    {
        cout << "吃饭" << endl;
    }
};

class CSuperMan : public CPerson
{
public:
    void ShowFly()
    {
        cout << "我能飞" << endl;
    }
};

int main()
{
    CSuperMan sm;
    sm.ShowEat();
    sm.ShowFly();

    return 0;
}

②原有类：基类 父类

新类：派生类 子类

③作用：提高复用性

④父类和子类中同名的成员变量和成员函数是通过作用域来区分的

子类的大小=子类+父类

#include<iostream>
using namespace std;

class CFather
{
public:
    int m_nMoney;
public:
    CFather()
    {
        m_nMoney = 1000000;
    }
};

class CSon : public CFather
{
public:
    int m_nMoney;
public:
    CSon()
    {
        m_nMoney = 100;
    }
};

int main()
{
    CFather cf;
    CSon cs;

    cout << cs.m_nMoney << endl;
    cout << cs.CFather::m_nMoney << endl;
    cout << sizeof(cs) << endl; //输出 8

    return 0;
}

⑥继承方式：影响的是继承过来的访问修饰符 即子类的访问修饰符

public继承：public和protected没有变化 但是父类的private在子类中是不可访问的

protected继承：public变成protected protected不变 private依然不可访问

private继承：public和protected都变成private 所有内容不可访问

特别注意：自己的类中不可定义自己的类对象 但是定义指针可以！！！

⑦继承关系的构造和析构函数的调用顺序：

定义一个派生类对象：先执行父类构造 然后子类构造 然后子类析构 父类析构

换句话说 构造函数是从父类到子类 析构是从子类到父类

#include<iostream>
using namespace std;

class CFather
{
public:
    CFather()
    {
        cout << "CFather" << endl; 
    }
    ~CFather()
    {
        cout << "~CFather" << endl; 
    }
};

class CSon : public CFather
{
public:
    CSon()
    {
        cout << "CSon" << endl; 
    }
    ~CSon()
    {
        cout << "~CSon" << endl; 
    }
};

int main()
{
    CSon son;

    return 0;
}

注意：

父类的构造函数是在子类的构造函数初始化列表中调用的 默认的调用是无参的

如果父类中只有带参数 也需要在子类的构造函数初始化列表中调用带参数的

2.横向关系：依赖<关联<聚合<组合

①组合：是部分与整体的关系

它是你的一部分 缺少一部分就是不完整的

直接要求：包含对象对被包含对象的拥有 以及 包含对象与被包含对象生命期的关系

例如：笔记本电脑和笔记本电脑键盘 汽车和轮胎 人和手

②聚合：是一对多的关系

暗含了一种所属关系以及生命期的关系（有无是不一定的） 被聚合对象还可以再被别的对象关联

注意：是A中放了多个B 而不是A中放了B C D

例如：班级有很多人 部门有很多职工

③关联：

某个对象长期持有对另一对象的引用 可以随时解除关联或者进行关联

关联是没有生命周期的 可以是相互的

例如：朋友（人在出生的时候 可以在类里放一根指针 有就指向这个对象 没有就指空）

④依赖：

某个对象的功能依赖另外一个对象 被依赖的对象只作为工具使用

依赖是没有生命周期的 只是使用 不持有对它的引用

例如：人依赖空气呼吸

3.总结：

①有生命周期的：组合和聚合

②没有生命周期的：关联和依赖

三.重载操作符operator

1.重载操作符有两种方法：

①在类内：调用的对象一定在左边

②在类外：需要有符号左边和符号右边（双目运算符）

2.需要注意的地方：

①表达式都有结果 所以重载的符号需要有返回值 返回值是为了和其他符号结合

②在重载输入输出操作符的时候 输入一定要放& 否则是改变不了其中的内容的

输出无所谓（这么说未免太不负责任） 但是为了养成良好的习惯 还是都加上比较好 也方便记忆嘛

3.代码：

#include<iostream>
using namespace std; 

class CNum
{
public:
    int m_num; 
public:
    CNum(void)
    {
    }

    ~CNum(void)
    {
    }

    int operator=(int num)
    {    
        this -> m_num = num;
        return m_num;
    }

    int operator+(int num)
    {
        return this -> m_num + num;
    }

    int operator++()
    {
        m_num = m_num + 1;
        return m_num;
    }

    int operator++(int aaa)
    {
        aaa = m_num;
        m_num = m_num + 1;
        return aaa;
    }
};

int operator+(int num,CNum& cn)
{
    return num + cn.m_num;
}
int operator+(CNum& cn1,CNum& cn2)
{
    return cn1.m_num + cn2.m_num;
}

istream& operator>>(istream& is,CNum& cn)
{
    cin >> cn.m_num;
    return is;
}

ostream& operator<<(ostream& os,CNum& cn)
{
    cout << cn.m_num;
    return os;
}

int main()
{
    CNum a;
    a = 100;
    cout << a.m_num << endl; //100

    CNum b;
    b = a = 200;
    cout << a.m_num << endl; //200
    cout << b.m_num << endl; //200

    CNum c;
    c = a + 100;
    cout << c.m_num << endl; //200+100=300

    CNum d;
    d = 100 + a;
    cout << d.m_num << endl; //100+200=300

    CNum e;
    e = a + b;
    cout << e.m_num << endl; //200+200=400

    cin >> a;
    cout << a << endl;

    return 0;
}