c++学习

类与对象

重载

赋值运算符重载

 

#include <iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:

    int *m_Age;

    Person(int age)
    {
        m_Age = new int(age);
    }

    ~Person()
    {
        if(m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
    }

    //重载赋值运算符
    Person& operator=(Person &p)
    {
        //编译器提供浅拷贝

        //判断是否有属性在堆区，如果有，就先释放干净再深拷贝
        if(m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }

        //深拷贝
        m_Age = new int(*p.m_Age);

        //返回对象自身
        return *this;
    }

};


void test01()
{
    Person p1(18);
    cout << "年龄:" << *p1.m_Age << endl;

    Person p2(20);

    //赋值操作，相当于浅拷贝，会触发double free的操作
    p2 = p1;

    cout << "年龄:" << *p2.m_Age << endl;

}

int main()
{
    test01();
}

 

关系运算符重载

#include <iostream>
#include <string>
using namespace std;

//重载关系运算符

class Person
{
public:
    Person(string name,int age)
    {
        m_Name = name;
        m_Age = age;
    }
    
    //重载 == 号
    bool operator==(Person &p)
    {
        if(this -> m_Name == p.m_Name and this -> m_Age == p.m_Age)
        {
            return true;
        }
        else
            return false;
    }


public:
    string m_Name;
    int m_Age;
};


void test01()
{
    Person p1("tom",18);
    Person p2("tom",18);

    if(p1 == p2)
        cout << "p1和p2相等" << endl;
    else
        cout << "p1和p2不相等" << endl;
}

int main()
{
    test01();
}

 

函数调用运算符重载

• 函数调用运算符()也可以重载
• 称为仿函数：在类中重载了小括号
• 调用非常灵活

#include <iostream>
#include <string>
using namespace std;

//重载函数调用运算符

class myAdd
{
public:

    //函数调用运算符重载
    int operator()(int a,int b)
    {
        return a+b;
    }
};

int myadd(int a,int b)
{
    return a+b;
}

void test01()
{
    myAdd add1;
    int ret = add1(1,2);
    cout << "仿函数返回：" << ret << endl;
    int ret1 = myadd(1,2);
    cout << "真实函数返回：" << ret1 << endl;
}    

int main()
{
    test01();
}

 

继承

继承是面向对象三大特性之一

作用：可减少重复代码

继承基本语法

在一个网页中许多信息都是重复的，比如顶部信息，底部信息和侧边栏，所以我们可用继承的方式来写

#include <iostream>
#include <string>
using namespace std;

//继承好处：减少重复代码
//语法 class 子类: 继承方式 父类
// 子类 == 派生类
// 父类 == 基类

class PageBase
{
public:
    void top_page()
    {
        cout << "网页的顶部信息" << endl;
    }
    void bottom_page()
    {
        cout << "网页的底部信息" << endl;
    }
    void left_page()
    {
        cout << "网页的侧边栏信息" << endl;
    }
};

class Main_Page : public PageBase
{
public:
    void content()
    {
        cout << "主页面中独有的信息" << endl;
    }
};

class Second_Page : public PageBase
{
public:
    void content()
    {
        cout << "第二页中独有的信息" << endl;
    }
};


int main()
{
    Main_Page p1;
    p1.top_page();
    p1.bottom_page();
    p1.left_page();
    p1.content();

    Second_Page p2;
    p2.top_page();
    p2.bottom_page();
    p2.left_page();
    p2.content();
}

 

继承方式

继承方式一共有三种

• 公共继承：父类中的啥属性到子类中不变，比如public还是public，protect还是protect
• 保护继承：父类中的所有权限到子类都变成了保护权限
• 私有继承：父类中的所有权限到子类都变成了私有权限

无论哪种继承方式都无法访问父类中的private的东西

 

#include <iostream>
#include <string>
using namespace std;

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son1:public Base
{
public:

    void func()
    {
        m_A = 10;
        m_B = 10;
        //m_C = 10;
    }

};

class Son2:protected Base
{
public:

    void func()
    {
        m_A = 10;
        m_B = 10;
        //m_C = 10;
    }
    // 在该类中所有的属性都是protected属性
};

class Son3:private Base
{
public:

    void func()
    {
        m_A = 10;
        m_B = 10;
        //m_C = 10;
    }
    // 在该类中所有的属性都是private属性
};


int main()
{
    Son1 s_public;
    s_public.m_A = 10;
    //s_public.m_B = 10;

    Son2 s_protected;
    //s_protected.m_A = 10;
}

 

继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

#include <iostream>
using namespace std;

// 继承中的对象模型

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son:public Base
{
public:
    int m_D;
};

void test()
{

    // 16:在父类中非静态成员属性都会被子类继承下去
    // 虽然私有属性无法访问，但是也被继承了
    cout << "size of Son:" << sizeof(Son) << endl;
}

int main()
{
    test();
}

 

继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造函数谁先谁后？

 

#include <iostream>
using namespace std;

// 继承中的构造函数，和析构函数 顺序

class Base
{
public:
    Base()
    {
        cout << "Base的构造函数" << endl;
    }
    ~Base()
    {
        cout << "Base的析构函数" << endl;
    }
};

class Son:public Base
{
public:
    Son()
    {
        cout << "Son的构造函数" << endl;
    }
    ~Son()
    {
        cout << "Son的析构函数" << endl;
    }
};

void test()
{
    Son s1;
}

int main()
{
    test();
}

 

继承同名成员处理方式

#include <iostream>
using namespace std;

// 继承中的构造函数，和析构函数 顺序

class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    void func()
    {
        cout << "Base中的func调用" << endl;
    }
    
public:
    int m_A;
};

class Son:public Base
{
public:
    Son()
    {
        m_A = 200;
    }
    void func()
    {
        cout << "Son中的func调用" << endl;
    }
public:
    int m_A;
};

//同名属性处理方式
void test1()
{
    Son s1;
    // 如果出现同名成员，默认调用子类的成员，如果要调用父类，则要加作用域
    cout << "m_A = " << s1.m_A << endl ;
    cout << "m_A = " << s1.Base::m_A << endl;
}

// 同名函数处理方式
void test2()
{
    Son s2;
    s2.func();
    // 如果子类中出现和父类中同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数(包括重载的)
    // 如果想访问父类的成员函数，则必须加作用域
    s2.Base::func();
}

int main()
{
    test1();
    test2();
}

总结

1. 子类对象可以直接访问到子类中同名成员
2. 子类对象加作用域可以访问到父类对象的同名成员
3. 如果子类中出现和父类中同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数(包括重载的)

 

继承同名静态成员处理方式

同非静态的成员处理方法一样

#include <iostream>
using namespace std;



class Base
{
public:
    static int m_A;
    static void func()
    {
        cout << "Base static func" << endl;
    }
};

int Base::m_A = 100; // 定义静态成员属性在类外必须初始化，且所有对象共享这个静态成员属性


class Son:public Base
{
public:
    static int m_A;
    static void func()
    {
        cout << "Son static func" << endl;
    }
};

int Son::m_A = 200;

//同名静态属性
void test1()
{
    Son s1;
    cout << "通过对象访问：" << endl;
    cout << "Son下静态成员属性" << s1.m_A << endl;
    cout << "Base下静态成员属性" << s1.Base::m_A << endl;

    cout << "通过类名访问：" << endl;
    cout << "Son下静态成员属性" << Son::m_A << endl;
    // 第一个双冒号：代表通过类名访问，第二个双冒号：代表访问父类作用域下
    cout << "Base下静态成员属性" << Son::Base::m_A << endl;
}


//同名静态函数
void test2()
{
    Son s1;
    s1.func();
    s1.Base::func();

    Son::func();
    Son::Base::func();
}

int main()
{
    //test1();
    test2();

}

 

多继承语法

c++允许一个类继承多个类

语法：class 子类:继承方式 父类1，继承方式 父类2……

 

菱形继承

概念：

两个派生类继承同一个基类

又有某个类同时继承这两个派生类

 

菱形继承问题：

1，两个派生类继承了基类的数据，当派生类的子类使用数据时，会引发二义性

2，子类的子类继承基类，继承了两份数据，其实只需要一份就可以了

 

多态

多态的基本概念与语法

多态是c++面向对象三大特性之一

多态分类

• 静态多态：函数重载和运算符重载属于静态多态，复用函数名
• 动态多态：派生类和虚函数实现运行时多态

区别：静态多态编译阶段就确定函数地址，动态多态运行时才确定

#include <iostream>
#include <string.h>
using namespace std;

class Animal
{
public:
    void speak()
    {
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal
{
public:
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

void doSpeak(Animal &animal)    // Animal &animal = cat;
{

    animal.speak();
    // 运行结果是动物在说话  原因：地址早绑定，无论传什么动物都是动物在说话
    // 要想猫在说话，就需要地址晚绑定
}

void test01()
{
    Cat cat;
    doSpeak(cat);
}

int main()
{
    test01();
}

 

#include <iostream>
#include <string.h>
using namespace std;

class Animal
{
public:
    virtual void speak()    // 虚函数，地址晚绑定
    {
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal
{
public:
    // 重写概念：函数返回值类型，函数名，形参列表完全相同
    // 子类中的virtual可写可不写
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

// 动态多态满足条件：
// 1，有继承关系
// 2，子类重写父类的虚函数

// 多态使用方法：父类的指针或者引用，指向子类对象

void doSpeak(Animal &animal)    // Animal &animal = cat;
{

    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);
}

int main()
{
    test01();
}