c++学习笔记(四)

类 & 对象

c++面向对象的三大特征为:封装、继承、多态

封装

封装的意义:

  • 将属性和行为作为一个整体,表现生活中的事物(数据成员和方法)
  • 将属性和行为加以权限控制(访问修饰符)

类中的属性和行为我们一般称为成员,属性为成员属性,行为是成员方法

这里以盒子为例,定义一个类,并声明两个对象

class Box
{
    //访问权限
    //公共权限
    public:
    //数据成员
    	double lenth;	//长
    	double breadth; //宽
    	double height;  //高
    //方法
    //求盒子体积
    	double cal_Volume()
        {
            return lenth * breadth * height;
        }
};

int main()
{
    Box box1;	// 声明 box1,类型为 Box
    Box box2;	// 声明 box2,类型为 Box
    //对象box1和box2都有他们各自的成员
}

访问权限

类在设计时,可以把属性和行为放在不同的权限下来加以控制

访问权限有三种:

  1. public 公共权限

    其成员类内可以访问,类外可以访问

  2. protected 保护权限

    其成员类内可以访问,类外不可以访问,但在子类(派生类)中可以访问

  3. private(默认) 私有权限

    其成员类内可以访问,类外不可以访问,不可查看

class Person
{
    public:
    	String name;
    
    protected:
    	int age;
    
    int id_card;//默认为private
    
    public:
    	func()
        {
            name = "alen";
            age = 26;
            id_card = 114514;
        }
};

int main()
{
    Person p;
    p.name = "walker";
    p.age = 23;//报错,类外不能访问
    p.id_card = 1919810;//报错,类外不能访问
}

struct和class区别

两者的唯一区别在于默认的访问权限

  • struct默认权限为公共

  • class默认权限为私有

  • class C1
    {
        int a;  //默认是私有权限 private
    };
    
    struct C2
    {
        int a;  //默认是公共权限 public
    };
    

    成员属性设置为私有

    优点:

    1. 将所有成员属性设置为私有,可以自己控制读写权限
    2. 对于写权限,我们可以检测数据的有效性
class Person
{
    public:
    	//设置名字
    	void setName(string name)
        {
            m_Name = name;
        }
    	
    	//设置偶像
    	void setIdol(string idol)
        {
            m_Idol = idol;
        }
    
    	//设置年龄
    	void setAge(int age)
        {
            if (age < 0 || age > 150)
            {
                cout<<"年龄"<<age<<"输入有误"<<endl;
                return;
            }
            m_Age = age;
        }
    
    	string getName()
        {
            return m_Name;
        }
    
    	int getAge()
        {
            return m_Age;
        }
    
    private:
    	string m_Name;//姓名 可读可写
    	int m_Age = 18;//年龄 只读	(当可写的时候,年龄限制在0-150之间)
    	string m_Idol;//偶像 只写
    
};

类的构造函数&析构函数

c++中的构造函数析构函数的作用是对对象的初始化清理

对象的初始化和清理工作是强制的,如果我们没有提供构造和析构函数的话,编译器将自动提供空实现的构造和析构函数

  • 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无需手动调用
  • 析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作

构建函数语法(内联):类名( ) { }

  1. 没有返回值,也不用写void
  2. 函数名称与类名相同
  3. 构造函数可以有参数,因此可以发生重载
  4. 程序在调用对象的时候会自动调用构造,无须手动调用,而且只会调用一次

析构函数语法(内联):~类名( ) { }

  1. 没有返回值,也不用写void
  2. 函数名称与类名相同,在名称前加上符号 ~
  3. 析构函数不可以有参数,因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次
class Person
{
public:
    //构造函数	进行初始化操作
    Person()
    {
        cout<<"Person构造函数的调用"<<endl;
    }
    
	~Person()
    {
        cout<<"Person析构函数的调用"<<endl;
    }
};

void test01()
{
    Person p;	//在栈上的数据,p创建时执行构造函数,test01执行完毕后释放这个对象,对象的析构函数被调用
}

int main()
{
    test01();
    return 0;
}

构造函数的分类及调用

两种分类方式:

  • 按参数分为:有参构造和无参构造(默认)
  • 按类型分为:普通构造和拷贝构造

三种调用方式:

  • 括号法
  • 显示法
  • 隐式转换法
class Person
{
public:
    //普通构造
    Person()
    {
        cout<<"Person无参函数的调用"<<endl;
    }
	Person(int a)
    {
        age = a;
        cout<<"Person有参函数的调用"<<endl;
    }
    //拷贝构造
    Person(const Person &p)
    {
        //将传入对象的所有属性,拷贝到当前对象上
        age = p.age;
    }
    
    
    
    
    ~Person()
    {
        cout<<"Person析构函数的调用"<<endl;
    }
    
private:
    int age;
};

void test01()
{
	//括号法
    Person p1;//默认构造函数调用
    Person p2(10);//有参构造函数
    Person p3(p2);//拷贝构造函数
    
    /*
    注意事项:
    调用默认构造函数的时候,不要加()
    因为这句代码“  Person p1();  ”编译器会认为是一个函数声明,不会认为是在创建对象
    */
    
    //显示法
    Person p4;
    Person p5 = Person(10); //有参
    Person p6 = Person(p5); //拷贝
    
    Person(10); //匿名对象 特点:当前行执行结束后,系统会立即回收掉匿名对象
    
    /*
    注意事项2:
    不要用拷贝构造函数初始化匿名对象
    Person(p3) 会被视为对象p3的重定义
    */
    //隐式转换法
    Person p7 = 10; //有参	相当于 Person p7 = Person(10)
    Person p8 = p7; //拷贝
}

int main()
{
    test01();
	return 0;
}

拷贝构造函数的调用时机

c++中拷贝构造函数调用实机通常有三种情况

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值(值传递本质是拷贝一个临时的副本来传递,因此会调用拷贝构造函数)
  • 以值方式返回局部对象(同上)

构造函数调用规则

默认情况下,c++编译器至少给一个类添加3个函数

  1. 默认构造函数(无参,函数体为空)
  2. 默认析构函数(无参,函数体为空)
  3. 默认拷贝函数,对属性进行值拷贝

构造函数调用规则如下:

  • 如果用户定义有参构造函数,c++不再提供默认无参构造,但是会提供默认拷贝构造
  • 如果用户定义拷贝构造函数,c++不会再提供其他构造函数

深拷贝与浅拷贝

浅拷贝(默认):简单的赋值拷贝操作

深拷贝:在堆区重新申请空间,进行拷贝操作

浅拷贝可能带来的问题是堆区的内存重复释放

class Person
{
    Person(const Person &p)
    {
        m_Age = p.m_Age;
        m_Height = p.m_Height;	//编译器默认的浅拷贝(单纯的值拷贝)
    }
    
        Person(const Person &p)
    {
        m_Age = p.m_Age;
        m_Height = new int(*p.m_Height);	//深拷贝操作,另外开辟一片堆内存进行拷贝
    }
};

初始化列表

作用:c++提供了初始化列表语法,用来初始化属性

语法:构造函数( ) : 属性(值1), 属性(值2)...{ }

class Person
{
    //传统初始化操作
    Person(int a, int b, int c)
    {
        m_A = a;
        m_B = b;
        m_C = c;
    }
    
    //初始化列表初始化属性
    Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
    {
        
    }
    private:
    	int m_A;
    	int m_B;
    	int m_C;
}

类对象作为类成员

c++类中的成员可以是另一个类的对象,我们称该成员为 对象成员

class A
{
    
};

class B
{
	A a;
}

B类中有对象A作为成员,A


静态成员

静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员

静态成员分为:

  • 静态成员变量

    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明,类外初始化
  • 静态成员函数

    • 所有对象共享一个函数
    • 静态成员函数只能访问静态成员变量
class Person
{
public:   
    //静态成员变量
    //编译阶段就分配内存
    static int m_A;
private:
    static int m_B;//静态成员变量也有访问权限
};
//类内声明,类外初始化操作
int Person:: m_A = 100;

void test01()
{
    Person p;
    cout<< p.m_A <<endl;//100
    Person p2;
    p2.m_A = 200;
    cout<< p.m_A <<endl;//200
    //所有对象都共享同一份数据
}

void test02()
{
    //静态成员变量不专属于某个对象,所有对象都共享同一份数据
    //因此静态成员变量有两种访问方式:
    //1.通过对象进行访问
    Person p;
    cout<< p.m_A <<endl;
    //2.通过类名进行访问
    cout<< Person::m_A<<endl;
}
class Person
{
public:
    static void func()
    {
        cout <<"静态成员函数调用"<< endl;
    }
};

void test01()
{
    //两种访问方式
    //通过对象访问
    Person p;
    p.func();
    //通过类名访问
    Person::func();
}

C++对象模型和this指针

成员变量和成员函数分开存储

在c++中,类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

class Person
{

};

class Human
{
public:
    int m_A;//非静态成员变量	属于类的对象上的数据
    static int m_B;//静态成员变量	不属于类对象上
    void func(){}//非静态成员函数	不属于类对象上
    static void func2(){}//静态成员函数	不属于类对象上
};

void test01()
{
    Person p;
    //空对象占用内存空间为:1 (byte)
    //C++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
    //每个空对象也应该有一个独一无二的内存地址
    cout << "size of p = " << sizeof(p) << endl;
}

void test02()
{
    Human p1;
    //占4 (byte) -> 非静态成员变量(int)所占的内存
    //因为静态成员变量、非静态成员函数、静态成员函数不在类的对象上所以分开存储
    cout << "size of p = " << sizeof(p1) << endl;
}

this指针概念

c++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会产生一份函数实例,也就是说多个同类型的对象会公用同一份代码

那么问题是:这一块代码是如何区分哪个对象调用自己的呢?

c++通过提供特殊的对象指针,this指针来解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义,直接使用即可

this指针的本质是指针常量,指针的指向是不可修改的

this指针的用途:

  • 当形参和成员变量同名时,可用this指针来区分
  • 在类的非静态成员函数中返回对象本身,可使用 return *this
class Person
{
public:
    Person(int age)
    {
        age = age;//形参和成员属性名字相同,编译器误以为他俩是同一个东西
    	
        //this指针指向的是被调用的成员函数(这里调用的是构造函数)所属的对象(这里的对象是p1)
        this->age = age;//使用this指针可解决名称冲突
    }
    
    //要返回本体的话须加引用
    Person& PersonAddAge(Person &p)
    {
        this->age += p.age;
        //this指向p2的指针,而*this指向的就是p2的本身
        return *this;
    }
    
    int age;//应该使用别的规范名称,如m_Age
};
//1.解决名称冲突
void test01()
{
    Person p1(18);
    cout << "p1的年龄是" << p1.age << endl;//并非18
}
//2.返回对象本身用*this
void test02()
{
    Person p1(10);
    
    Person p2(10);
    //返回值为对象本身,即p2 = p2.PersonAddAge(p1)
    //链式编程思想
    p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
    cout << "p2的年龄是" << p2.age << endl;//
}


空指针访问成员函数

c++中空指针也是可以调用成员函数的,但是也要注意有没有用到this指针

如果用到this指针,需要加以判断保证代码的健壮性

//空指针调用成员函数
class Person
{
public:
    void showClassName()
    {
        cout << "this is Person class" << endl;
    }
    
    void showPersonAge()
    {
        //报错的原因是传入的指针为NULL
        /*解决措施:
        if (this == NULL)
        {
        	return;
        }
        */
        cout << "age = " << this->m_Age << endl;
    }
    
    int m_Age;
};

void test01
{
    Person * p = null;
    
    p->showClassName();//不报错
    
    p->showPersonAge();//报错,因为调用了成员属性,但指针为空指针
}

const修饰成员函数

常函数:

  • 成员函数后加const后我们称这个函数为常函数
  • 常函数内不可以修改成员属性
  • 成员属性声明时加关键字mutable后,在常函数中依然可以修改

常对象:

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数
//常函数
class Person
{
public:
    
    //在成员函数后面加const,修饰的是this指向,让this指针指向的值也无法修改
    void showPerson() const
    {
        //this->m_A = 100;	不可修改
        this->m_B = 100;
    }
    
    int m_A;
    mutable int m_B;//特殊变量,即使在常函数中,也可以修改这个变量
}

void test02()
{
    const Person p; //在对象前加const,变为常对象
    //p.m_A = 100; 报错
    p.m_B = 100; //m_B是特殊值,在常对象中可修改
    //常对象只能调用常函数
    p.showPerson();
    //p.func();	//报错	常对象不可以调用普通成员函数,因为普通成员函数可以修改属性
}

友元

生活中,家里(class)有客厅(public)也有卧室(private),客厅所有客人都能进,但是卧室除了好友之外的普通客人不能进

在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术

友元的目的就是让一个函数或者类访问另一个类中私有成员

友元的关键词为friend

友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元

全局函数做友元

class Building
{
    //友元声明
    friend void goodFriend(Building &building);
public:
    Building()
    {
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
    
public:
    string m_SittingRoom;
    
private:
    string m_BedRoom;
};

//全局函数
void goodFriend(Building &building)
{
    cout << "猴米全局函数正在访问:"<< building->m_BedRoom/*private*/ <<endl;
}

void test01()
{
    Building building;
    goodFriend(&building);//成功访问
}

类做友元

class Building;
class GoodFriend
{
public:
    GoodFriend();
    
    void visit(); //参观函数	访问Building类中元素
    
    Building * building;
};

class Building
{
    //友元声明
    friend class GoodFriend;
    
public:
    Building();
public:
    string m_SittingRoom;
    
private:   
    string m_BedRoom;
};

//类外写成员函数
Building::Building()
{
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
}
GoodFriend::GoodFriend()
{
    //创建建筑物对象
	building = new Building;
}

void GoodFriend::visit()
{
    cout << "猴米类正在访问:" << building->m_BedRoom << endl;
}

void test01()
{
    GoodFriend gf;
    gf.visit();//调用成功
}

成员函数做友元

class Building;
class GoodFriend
{
public:
    GoodFriend();
    
    void visit01(); //让visit01函数可以访问Building类的私有成员
    void visit02(); //让visit02函数不可以访问Building类的私有成员
    
    Building * building;
};

class Building
{
    //友元声明
    friend void GoodFriend::visit01();
    
public:
    Building();
public:
    string m_SittingRoom;
    
private:   
    string m_BedRoom;
};

//类外写成员函数
Building::Building()
{
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
}
GoodFriend::GoodFriend()
{
    //创建建筑物对象
	building = new Building;
}

void GoodFriend::visit01()
{
    cout << "猴米类正在访问:" << building->m_BedRoom << endl;
}

void GoodFriend::visit01()
{
    cout << "猴米类正在访问:" << building->m_BedRoom << endl;//报错
}


运算符重载

运算符重载的概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型


加号运算符重载

作用:实现两个自定义数据类型相加的运算

Tips:

  • 对于内置的数据类型的表达式的运算符是不可能改变的
  • 不要滥用运算符重载
class Person
{
public:
    
    //成员函数重载+号
    Person operator+(Person &p)
    {
        Person temp;
        temp.m_A = this->m_A + p.m_A;
        temp.m_B = this->m_B + p.m_B;
        return temp;
    }
    
    int m_A;
    int m_B;
};

//全局函数重载+号
Person operator+(Person &p1, Person &p2)
{
	Person temp;
	temp.m_A = this->m_A + p.m_A;
	temp.m_B = this->m_B + p.m_B;
	return temp;
}

void test01
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    Person P2;
    p2.m_A = 10;
    p2.m_B = 10;
    
    //成员函数本质调用
    //Person p3 = p1.operator+(p2);
    Person p3 = p1 + p2;//简化
    
    cout << "p3.m_A = " << p3.m_A << endl;
    cout << "p3.m_B = " << p3.m_B << endl;
}

左移运算符重载

作用:可以输出自定义数据类型

class Person
{
    friend ostream& operator<<(ostream &cout,Person &p);
public:
    Person(int a, int b)
    {
        m_A = a;
        m_B = b;
    }
private:
    //不会利用成员函数重载<<运算符,因为无法实现cout在左侧
    int m_A;
    int m_B;
};

//只能利用全局函数重载左移运算符
ostream& operator<<(ostream &cout,Person &p)
{
    cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
    return cout;
}

void test01()
{
    Person p(10,10);

    cout << p << endl;
}
int main() {
    cout << "Hello, World!" << endl;
    test01();
    return 0;
}

递增 / 递减运算符重载

作用:通过重载递增 / 递减运算符,实现自己的整形数据

//重载递增运算符

//自定义整型
class MyInteger
{
    friend ostream & operator<<(ostream& cout, MyInteger myint);
public:
    MyInteger()
    {
        m_Num = 0;
    }

//重载前置++运算符
//返回引用是为了一直对一个数据进行递增操作
    MyInteger& operator++()
    {
        //先进行++运算
        m_Num++;

        //再将自身返回
        return *this;
    }

//重载后置++运算符
//int代表占位参数,可用于区分前置和后置递增
    MyInteger operator++(int)
    {
        //先 记录当时结果
        MyInteger temp = *this;
        //后 递增
        m_Num++;
        //最后将记录结果做返回
        return temp;
    }

    //重载前置--运算符
//返回引用是为了一直对一个数据进行递减操作
    MyInteger& operator--()
    {
        //先进行--运算
        m_Num--;

        //再将自身返回
        return *this;
    }

//重载后置--运算符
//int代表占位参数,可用于区分前置和后置递减
    MyInteger operator--(int)
    {
        //先 记录当时结果
        MyInteger temp = *this;
        //后 递减
        m_Num--;
        //最后将记录结果做返回
        return temp;
    }

private:
    int m_Num;
};

ostream & operator<<(ostream& cout, MyInteger myint)
{
    cout << myint.m_Num;
    return cout;
}


void test01()
{
    MyInteger myint;		    //0
    cout << ++myint << endl;	//1
    cout << myint++ << endl;	//1
    cout << myint << endl;		//2
    
    cout << --myint << endl;	//1
    cout << myint-- << endl;	//1
    cout << myint << endl;		//0

}

赋值运算符重载

c++编译器至少给一个类添加4个函数

  1. 默认构造函数(无参,函数体为空)
  2. 默认析构函数(无参,函数体为空)
  3. 默认拷贝构造函数,对属性进行值拷贝
  4. 赋值运算符operator=,对属性进行值拷贝

如果类中有属性指向堆区,做赋值操作时也会出现深浅拷贝问题

//赋值运算符重载

class Person
{
public:

    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;
    }

    int *m_Age;
};

void test01()
{
    Person p1(10);
    Person p2(20);
    Person p3(30);

    p3 = p2 = p1;    //赋值操作

    cout << "p1's age = " << *p1.m_Age << endl;

    cout << "p2's age = " << *p2.m_Age << endl;

    cout << "p3's age = " << *p3.m_Age << endl;
}

关系运算符重载

作用:重载关系运算符,可以让两个自定义类型对象进行对比操作

//关系运算符重载

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)
        {
            return true;
        }
        return false;
    }

    //重载!=号
    bool operator!=(Person &p)
    {
        if (this->m_Name != p.m_Name)
        {
            return true;
        }
        return false;
    }

    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;
    }
}

函数调用运算符重载

  • 函数调用运算符()也可以重载
  • 与哦于重载后使用的方式非常像函数的调用,因此称为仿函数
  • 仿函数没有固定写法,非常灵活
//函数调用运算符重载
class MyPrint
{
public:

    //重载函数调用运算符
    void operator()(string test)
    {
        cout << test <<endl;
    }
};

class MyAdd
{
public:
    int operator()(int num1, int num2)
    {
        return num1 + num2;
    }
};
void test01()
{
    MyPrint myPrint;
    myPrint("hello world");

    //匿名对象调用
    int a = MyAdd()(10,20);
    cout << "a = " << a << endl;
}

继承

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

继承允许我们依据另一个类来定义一个类,有重用代码功能和提高执行效率的效果。

当创建一个类时,不必重新编写新的数据成员和成员函数,只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类,新建的类称为派生类。也可以称为父类子类

基本语法

class 子类 : 继承方式 父类

class A : public B

以上图为例

// 基类
class Animal {
public:    
    void eat()
    {
        cout << "吃!" << endl;
    }
    void sleep()
    {
        cout << "zzzZZZ" << endl;
    }
    
    string name;
    int age;
};


//派生类
class Dog : public Animal {
public:	
    void bark()
    {
        cout << "汪汪汪!" << endl;
    }
};

子类中的成员,包含两大部分:

  • 从父类继承过来的
  • 自己增加的成员

从父类继承过来的表现其共性,而新增的成员体现了其个性。

一个子类继承了所有的基类方法,但下列情况除外:

  • 父类的构造函数、析构函数和拷贝构造函数。
  • 父类的重载运算符
  • 父类的友元函数

继承方式

继承方式一共有三种:

  • 公共继承(public):当一个类派生自公有基类时,基类的公有成员也是派生类的公有成员,基类的保护成员也是派生类的保护成员,基类的私有成员不能直接被派生类访问,但是可以通过调用基类的公有保护成员来访问。
  • 保护继承(protected):当一个类派生自保护基类时,基类的公有保护成员将成为派生类的保护成员。
  • 私有继承(private):当一个类派生自私有基类时,基类的公有保护成员将成为派生类的私有成员。

我们几乎不使用 protectedprivate 继承,通常使用 public 继承。

构造和析构顺序

在继承后,派生类也会继承基类的构造函数与析构函数

那么他们之间的调用顺序如下:

父类构造——子类构造——子类析构——父类析构

继承同名成员处理方式

当子类与父类出现同名的成员时:

  • 如访问子类同名成员,直接访问即可
  • 如访问父类同名成员,需要加作用域(类名::)
class Base{
public:
    Base()
    {
        m_A = 100;
    }
    
    void func()
    {
        cout << "Base" << endl;
    }
    
    int m_A;
};

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

//同名数据成员处理
void test01()
{
    Son s;
    cout << "Son下  m_A = " << s.m_A << endl;//200
    cout << "Base下 m_A = " << s.Base::m_A << endl;//100
}
//同名成员函数处理
void test02()
{
    Son s;
    
    s.func();//Son
    s.Base::func();//Base
}

总结:

  • 子类对象可以直接访问到子类中同名成员
  • 子类对象加作用域可以访问到父类同名函数
  • 当子类和父类拥有同名的成员函数,子类会隐藏父类中同名成员函数,但加作用域可以访问到

多继承

多继承即一个子类可以有多个父类,它继承了多个父类的特性。

C++ 类可以从多个类继承成员,语法如下:

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

c++实际开发中不建议使用多继承,因为可能会引发多个父类中有同名成员导致作用域管理混乱

示例如下:

// 形状基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 刷漆基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
 
   return 0;
}

菱形继承

菱形继承概念:

  • 两个派生类继承同一个基类
  • 又有某个类同时继承着两个派生类
  • 这种继承被称为菱形继承,或者钻石继承

典型的菱形继承案例:

菱形继承问题:

  1. 老虎继承了动物的数据,狮子同样也继承了动物的数据;当狮虎兽使用数据时,就会产生二义性
    • 当菱形继承,两个父类拥有相同数据时,需要加以作用域区分
  2. 狮虎兽继承自动物的数据继承了两份,但我们应该清楚,这份数据我们只需要一份即可,导致资源浪费
    • 利用虚继承来解决(在继承方式前加上关键字virtual:class Tiger : virtual public Animal,基类Animal变成虚基类)

多态

多态的基本概念

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

多态按字面的意思就是多种形态。当类之间存在层次结构,并且类之间是通过继承关联时,就会用到多态。调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。

多态分为两类:

  • 静态多态:函数重载和运算符重载属于静态多态,服用函数名
  • 动态多态:派生类和虚函数来实现运行时的多态

静态多态和动态多态区别:

  • 静态多态的函数地址早绑定 —— 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 —— 运行阶段确定函数地址
class Animal
{
public:
    void speak()
    {
        cout<<"动物在说话"<<endl;
    }
};

class Cat :public Animal
{
public:
    void speak()
    {
        cout<<"meow,meow,meow"<<endl;
    }
};

//执行说话的函数
//地址早绑定	在编译阶段确定函数地址
//如果想执行让猫说话,那么这个函数地址就不能提前绑定,需要晚绑定
void doSpeak(Animal &animal)
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);//动物在说话
}
class Animal
{
public:
    //虚函数	实现晚绑定
    virtual void speak()
    {
        cout<<"动物在说话"<<endl;
    }
};

class Cat :public Animal
{
public:
    //重写	函数返回值类型、函数名、参数列表完全相同
    void speak()
    {
        cout<<"meow,meow,meow"<<endl;
    }
};

//执行说话的函数
void doSpeak(Animal &animal)
{
    animal.speak();
}

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

总结:

动态多态满足条件:

  1. 有继承关系
  2. 子类重写父类的虚函数

多态使用条件

  • 父类指针或引用指向子类对象

多态案例(一)——计算器类

案例描述:

分别用普通写法和多态技术,设计实现两个操作数进行的计算器类

多态的优点:

  • 代码组织结构清晰
  • 可读性强
  • 利于前期和后期的扩展以及维护
//普通实现
class Calculator
{
public:
    Calculator(int num1, int num2)
    {
        m_Num1 = num1;
        m_Num2 = num2;
    }

    int getResult(string oper)
    {
        if (oper == "+") return m_Num1 + m_Num2;
        else if (oper == "-") return m_Num1 - m_Num2;
        else if (oper == "*") return m_Num1 * m_Num2;
        //(普通写法下)如果想扩展新功能,就需要修改源码
        //在真实开发中,我们提倡开闭原则:对扩展进行开放,对修改进行关闭
    }


    int m_Num1;//操作数1
    int m_Num2;//操作数2
};


void test01()
{
    //创建一个计算器对象
    Calculator c(10,10);

    cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
    cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;
    cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;
}

//利用多态实现计算器
//实现计算器抽象类
class AbstractCalculator
{
public:

    virtual int getResult()
    {
        return 0;
    }

    int m_Num1;//操作数1
    int m_Num2;//操作数2
};

//加法计算器类
class AddCaculator :public AbstractCalculator
{
public:
    virtual int getResult()
    {
        return m_Num1 + m_Num2;
    }
};

//减法计算器类
class SubCaculator :public AbstractCalculator
{
public:
    virtual int getResult()
    {
        return m_Num1 - m_Num2;
    }
};

//乘法计算器类
class MulCaculator :public AbstractCalculator
{
public:
    virtual int getResult()
    {
        return m_Num1 * m_Num2;
    }
};

void test02()
{
    //多态使用条件:父类指针/引用指向子类对象

    //加法运算
    AbstractCalculator * abc = new AddCaculator;//父类指针
    abc->m_Num1 = 100;
    abc->m_Num2 = 100;

    cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
    //用完后记得销毁
    delete abc;

    //减法运算
    abc = new SubCaculator;
    abc->m_Num1 = 100;
    abc->m_Num2 = 100;

    cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
    //用完后记得销毁
    delete abc;

    //乘法运算
    abc = new MulCaculator;
    abc->m_Num1 = 100;
    abc->m_Num2 = 100;

    cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
    //用完后记得销毁
    delete abc;
}

纯虚函数和抽象类

在多态中,通常父类中虚函数的实现是无意义的,主要是调用子类重写的内容(例如计算器类案例中的抽象计算器类)

因此可以将虚函数改为纯虚函数

纯虚函数语法:virtual 返回值类型 函数名(参数列表)= 0;

当类中有了纯虚函数,这个类也成为抽象类

抽象类特点:

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数,否则也属于抽象类
class AbstractCalculator//有纯虚函数的类就是抽象类
{
public:
	//纯虚函数
    virtual int getResult() = 0;

    int m_Num1;//操作数1
    int m_Num2;//操作数2
};

//加法计算器类
class AddCalculator : public AbstractCalculator
{
public:
    virtual int getResult()
    {
        return m_Num1 + m_Num2;
    }
};

void test01()
{
    //多态使用条件:父类指针/引用指向子类对象

    //加法运算
    AbstractCalculator * abc = new AddCalculator;//父类指针
    abc->m_Num1 = 100;
    abc->m_Num2 = 100;

    cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
    //用完后记得销毁
    delete abc;

    AbstractCalculator abc;//报错	抽象类无法实例化对象
    new AbstractCalculator;//报错 堆区或栈区都不行
}

多态案例(二)——饮品类

案例描述:

制作饮品的大致流程为:煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例,提供抽象制作饮品基类,提供子类制作咖啡和茶叶

class AbstractDrinking
{
public:
    //煮水
    virtual void Boil() = 0;
    //冲泡
    virtual void Brew() = 0;
    //倒入杯中
    virtual void PourInCup() = 0;
    //加入辅料
    virtual void PutSth() = 0;
    //制作饮品
    void makeDrink()
    {
        Boil();
        Brew();
        PourInCup();
        PutSth();
    }
};

//制作咖啡
class Coffee :public AbstractDrinking
{
    //煮水
    virtual void Boil(){
        cout << "用阿拉斯加山脉泉水煮水" << endl;
    }
    //冲泡
    virtual void Brew(){
        cout << "冲泡咖啡" << endl;
    }
    //倒入杯中
    virtual void PourInCup(){
        cout << "倒入咖啡杯中" << endl;
    }
    //加入辅料
    virtual void PutSth(){
        cout << "加入方糖和牛奶" << endl;
    }
};

//制作茶叶
class Tea :public AbstractDrinking
{
    //煮水
    virtual void Boil(){
        cout << "用长白山泉水煮水" << endl;
    }
    //冲泡
    virtual void Brew(){
        cout << "冲泡茶叶" << endl;
    }
    //倒入杯中
    virtual void PourInCup(){
        cout << "倒入茶杯中" << endl;
    }
    //加入辅料
    virtual void PutSth(){
        cout << "加入茉莉花" << endl;
    }
};
//制作函数
void doWork(AbstractDrinking * abs)
{
    abs->makeDrink();
    delete abs; //释放堆区数据
}

void test01()
{
    //制作咖啡
    doWork(new Coffee);
    cout << "----------------" << endl;
    //制作茶叶
    doWork(new Tea);
}

虚析构和纯虚析构

多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码

解决方式:将父类中的析构函数改为虚析构或者纯虚析构

虚析构或者纯虚析构共性:

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构或者纯虚析构区别:

  • 如果是纯虚析构,该类属于抽象类,无法实例化对象

虚析构语法:

virtual ~类名( ) { }

纯虚析构语法:

virtual ~类名( ) = 0 ;

类名::~类名(){ }

总结:

  1. 虚析构或纯虚析构就是用来解决父类指针释放子类对象
  2. 如果子类中没有堆区数据,可以不写为虚析构或纯虚析构
  3. 拥有纯虚析构函数的类也属于抽象类

多态案例(三)—— 电脑组装

案例描述:

电脑主要组成部分为CPU(计算)、显卡(显示)和内存条(存储)

将每个零件封装成抽象基类,并且提供不同的厂商生产的不同的零件,例如Intel和AMD厂商

创建电脑类提供让电脑工作的函数,并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

//抽象类
//CPU
class CPU
{
public:
    //抽象计算函数
    virtual void Calculate() = 0;
};
//GPU
class GPU
{
public:
    //抽象显示函数
    virtual void Display() = 0;
};
//内存条
class Memory
{
public:
    //抽象存储函数
    virtual void Storage() = 0;
};

//电脑类
class Computer
{
public:
    Computer(CPU * cpu, GPU * gpu, Memory * mem)
    {
        m_cpu = cpu;
        m_gpu = gpu;
        m_mem = mem;
    }
    //提供工作的函数
    void work()
    {
        //调用零件接口
        m_cpu->Calculate();
        m_gpu->Display();
        m_mem->Storage();
    }
    //提供析构函数来释放3个创建在堆区的电脑零件
    ~Computer()
    {
        if (m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        if (m_gpu != NULL)
        {
            delete m_gpu;
            m_gpu = NULL;
        }
        if (m_mem != NULL)
        {
            delete m_mem;
            m_mem = NULL;
        }
    }

private:
    CPU * m_cpu;//CPU的零件指针
    GPU * m_gpu;//GPU的零件指针
    Memory * m_mem;//内存条的零件指针
};

//具体厂商零件
//Intel
class IntelCPU :public CPU
{
public:
    virtual void Calculate()
    {
        cout << "Intel CPU is working!" << endl;
    }
};

class IntelGPU :public GPU
{
public:
    virtual void Display()
    {
        cout << "Intel GPU is working!" << endl;
    }
};

class IntelMemory :public Memory
{
public:
    virtual void Storage()
    {
        cout << "Intel Memory is working!" << endl;
    }
};

//AMD
class AMDCPU :public CPU
{
public:
    virtual void Calculate()
    {
        cout << "AMD CPU is working!" << endl;
    }
};

class AMDGPU :public GPU
{
public:
    virtual void Display()
    {
        cout << "AMD GPU is working!" << endl;
    }
};

class AMDMemory :public Memory
{
public:
    virtual void Storage()
    {
        cout << "AMD Memory is working!" << endl;
    }
};

void test01()
{
    //no.1 pc
    CPU * intelCpu = new IntelCPU;
    GPU * intelGpu = new IntelGPU;
    Memory * intelMem = new IntelMemory;

    Computer * pc1 = new Computer(intelCpu,intelGpu,intelMem);
    pc1->work();
    delete pc1;

    //no.2 pc
    CPU * amdCpu = new AMDCPU;
    GPU * amdGpu = new AMDGPU;
    Memory * amdMem = new AMDMemory;

    Computer * pc2 = new Computer(amdCpu,amdGpu,amdMem);
    pc1->work();
    delete pc2;
}

热门相关:永恒王权   大唐杨国舅   灭世魔帝   豪门24小时:吻别霸道前夫   重生不嫁豪门