C++实验（二）—— 继承和多态

最新推荐文章于 2025-03-26 18:03:17 发布

向阳而生|X

最新推荐文章于 2025-03-26 18:03:17 发布

阅读量934

点赞数 3

分类专栏： c++ 文章标签： c++ 开发语言

本文链接：https://blog.youkuaiyun.com/m0_50945459/article/details/120886142

版权

CPoint CTriangle CRect CCircle CircleInRect

一、继承访问权限测试

1、概述

C++面向对象的三大特性为：封装、继承、多态

继承是面向对象程序设计中最重要的概念之一。继承的作用是允许我们依据一个类来定义另外一个类，这就意味着创建和维护一个应用程序变得更容易，创建一个类时，不需要再重新编写新的数据成员和函数，而是直接使用已有的类的成员。这个已有的类称为基类，新建的类为派生类。比如，后面代码中的 Animal类是基类，而其他的动物类是派生类。

我们在设计类的时候，可以把属性和行为（成员变量和函数）放在不同的权限下

访问权限有三种：

public 公共权限类内可以访问，类外也可以访问
protected 保护权限类内可以访问，类外不可以访问
private 私有权限类内可以访问，类外不可以访问

其中

private是完全私有的，只有自己可以访问，派生类和外部都不可以访问。
protected是受保护的，只有派生类可以访问，外部不能访问。

同时

保护继承（protected）：如果继承方式为保护继承，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：如果继承方式为私有继承，基类的公有和保护成员将成为派生类的私有成员。

2、代码

设计类A具有public, protected, private等不同属性的成员函数或变量；
类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量；
在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量；
B以private方式继承A，尝试把A中的部分public成员提升为public。

#include<iostream>
using namespace std;

class Person
{
public:
	string name; //姓名
protected:
	string sex;  //性别
private:
	int age;    //年龄
};

//1.public继承
class Student1 :public Person
{
public:
	void test() {
		name = "hello world";
		sex = "male";
		//age=10;  age不可访问
	}
	int weight;//体重
protected:
	int height;//身高
private:
	int eye;//视力

};
//2.protected继承
class Student2 :protected Person
{
public:
	void test() {
		name = "hello world";
		sex = "male";
		//age=10;  age不可访问
	}
	int weight;//体重
protected:
	int height;//身高
private:
	int eye;//视力

};
//3.private继承
class Student3 :private Person
{
public:
	void test() {
		name = "hello world";
		sex = "male";
		//age=10;  age不可访问
	}
	int weight;//体重
protected:
	int height;//身高
private:
	int eye;//视力

};

void test()
{
	Person p;
	p.name;
	p.sex;
	p.age;

	Student1 s1;
	Student2 s2;
	Student3 s3;

	s1.name;
	s1.weight;
	s1.height;
	s1.eye;

	s2.name;
	s2.weight;
	s2.height;
	s2.eye;

	s3.name;
	s3.weight;
	s3.height;
	s3.eye;
}

结果如下图所示

二、友元类继承测试

1、概述

由前面的实验已知，私有成员只能在类的成员函数内部访问，如果想在别处访问对象的私有成员，只能通过类提供的接口（成员函数）间接地进行。

在定义一个类的时候，可以把一些函数（包括全局函数和其他类的成员函数）声明为“友元”，这样那些函数就成为该类的友元函数，在友元函数内部就可以访问该类对象的私有成员了。

2、代码

#include <iostream>

using namespace std;

//设计类A含有私有变量a，在类A中友元给类C；
class A {
private:
	int a;
	friend class C;
};

//设计类B继承A，添加私有变量b；
class B :public A {
private:
	int b;

};

//在类C中测试访问类B的成员变量a, b;
class C {
public:
	void Test() {
		B b1;
		b1.a; //友元 可以成功访问Class A 中的私有变量a
		b1.b;
	}
};

//设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。
class D :public C {
public:
	void Test() {
		A a1;
		a1.a;
		B b2;
		b2.a;
		b2.b;

	}

};

结果如下图所示

当class A友元给class C 时，则C可访问A中所有成员函数和变量。
友元关系是单向的，不具有交换性。

三、多态性综合运用

一般多态性函数

输入输出参数完全一样，在父类中添加virtual

#include <iostream>

using namespace std;


class Animal{
public:
    void outPut();
};

void Animal::outPut() {
    cout << "Animal output!" << endl;
}

class dog : public Animal {
public:
    void outPut();
};

void dog::outPut() {
    cout << "dog output!" << endl;
}

int main()
{
    Animal p;
    p.outPut();
    dog d;
    d.outPut();
    Animal* ptr = new dog();
    ptr->outPut();
    return 0;
}

子类重写父类的非virtual 方法，当父类指针指向子类对象时，通过指针调用该成员函数，调用的是父类的方法

class Animal{
public:
    virtual void outPut();
};

当子类重写父类的virtual函数时。在父类的函数声明中，前面加上virtual，父类指针调用的是实际指向对象的output函数

特殊多态性函数

输入或输出参数在子类中是父类的指针或基类的引用，在子类中对于的是子类的指针或子类的引用

#include <iostream>

using namespace std;


class Animal{
public:
    virtual void outPut(){
    	cout << "Animal output!" << endl;
	}
	
};

class Dog : public Animal {
public:
    void outPut(){
    	cout << "

最低0.47元/天解锁文章