第9章 继承和派生习题(详解)

于 2024-01-01 21:40:31 发布
阅读量1.2k 收藏 24
点赞数 20
文章标签： 开发语言 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74774974/article/details/135327041
版权

在这里插入图片描述

一、选择题

1．下列表示引用的方法中， （） 是正确的。已知：int m=10：

A．int &x=m； B．int &y=10； C．int &z； D．float &t=&m；

在C++中，引用是一个变量的别名。正确的引用声明方式应遵循C++的引用规则。

选项分析：

A．`int &x=m;` 这是一个正确的引用声明。`x` 成为 `m` 的引用，`x` 和 `m` 指向同一内存位置。

B．`int &y=10;` 这是一个错误的引用声明。引用必须绑定到一个变量，不能直接绑定到字面值（如10）。

C．`int &z;` 这是一个错误的声明。引用在声明时必须被初始化。

D．`float &t=&m;` 这是一个错误的声明。首先，`&m` 获得的是变量 `m` 的地址，其类型是 `int*` 而不是 `float`。其次，`t` 应该直接绑定到一个 `float` 类型的变量，而不是一个地址。

因此，正确的选项是：

A．`int &x=m;`

2. 在以下类定义中， () 的虚基类

A)类B、类C是类A B)类A是类B、类C C)类B、类C是类D D)类A是类D

class A{
public: 
int x;
A(int a=0){x=a;}
 	};
class B:public virtual A
{ ... };
class C:virtual public A
{  ... };
class D:public B,public C
{   	A x; 
public: 
int m; 
D(int a,int b,int c):B(a),C(b),x(c)  //F
...
};

在C++中，如果一个基类被多个直接或间接派生类通过不同的路径继承，
并且这个基类在继承路径中至少有一次是作为虚基类来继承的，那么这个基类就是虚基类。
如果一个基类包含另一个基类的指针或引用，那么这个基类就被称为虚基类。 选D

3．C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过 （），派生出新的类。

A．复用 B．继承C．单继承 D．多继承

继承允许新的类接收（或继承）一个或多个类的成员（包括数据成员和成员函数）。
这是代码复用的一个主要手段。选B

4．继承具有 () ，即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。

A．规律性 B．传递性 C．重复性 D．多样性

B．传递性
这个特性确保了派生类能够从它的直接基类以及间接基类那里继承属性和方法，允许多层次的抽象和代码重用。

5．在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则 () 。

A．完全相同 B．完全不同 C．部分相同，部分不同 D．以上都不对

在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性的规则与单继承中的规则是完全相同的。
无论是单继承还是多继承，
基类成员的访问控制（public, protected, private）都遵循相同的规则。因此，正确的答案是：
A．完全相同
公有继承（public inheritance）意味着基类的公有成员和保护成员在派生类中保持原有的访问权限，
而私有继承（private inheritance）意味着基类的所有成员在派生类中都变成了私有成员，
无论它们在基类中原来是什么访问权限。

6．派生类的构造函数的成员初始化列表中，不能包含 。

A．基类的构造函数 B．派生类中子对象的初始化
C．基类的子对象初始化 D．派生类中一般数据成员的初始化

在派生类的构造函数的成员初始化列表中可以包含以下元素：
A. 基类的构造函数 - 派生类的构造函数可以（并且在多数情况下应该）
在其成员初始化列表中调用基类的构造函数，以确保基类部分被正确初始化。
B. 派生类中子对象的初始化 - 如果派生类有类类型的成员（子对象），
则可以（也应该）在成员初始化列表中初始化它们。
C. 基类的子对象初始化 - 这一选项是有歧义的。如果指的是基类的成员（即基类中的子对象）
，那么这些在基类构造函数中被初始化，不应直接出现在派生类的成员初始化列表中。
但是，如果这里指的是由基类派生出的另一个基类的对象，
则派生类可以在其成员初始化列表中直接初始化这样的基类的子对象。
D. 派生类中一般数据成员的初始化 -
 派生类的构造函数的成员初始化列表当然可以包含派生类中一般数据成员的初始化。
因此，如果我们解释C为“基类中的子对象”，那么它是不能被派生类的构造函数的成员初始化列表直接初始化的，因为这是基类构造函数的责任。这样看来，C是正确的答案。如果解释C为“由基类派生的其他基类”，那么派生类是可以（并且应该）在其成员初始化列表中初始化这样的对象的。这里需要明确题目中“基类的子对象初始化”的具体含义。
选C

7. 定义派生类时，若不使用关键字显式地规定采用何种继承方式，则默认方式是 。

A. 私有继承 B. 非私有继承 C. 保护继承 D. 公有继承

A 私有继承

8. 在一个派生类的成员函数中，试图调用其基类的成员函数“void f();”,但无法通过编译。这说明 （） 。

A. f()是基类的私有成员 B. f()是基类的保护成员
C. 派生类的继承方式是私有 D. 派生类的继承方式为保护

A f()是基类的私有成员

9. 有如下类定义：

class AA{
int a;
public:
AA(int n=0):a(n){}
};
class BB:public AA{
public;
BB(int n).......。
};

其中横线处缺失部分是 。
A.:a(n){} B.;AA(n){} C.{a(n)}; D.{a=n};

选项B `:AA(n){}` 正确的填写了类 BB 的构造函数，在初始化列表中调用了基类 AA 的构造函数，将 n 作为参数传递给它。这是正确的继承和初始化方式，能够确保派生类 BB 创建时，其基类 AA 的部分也得到了正确的初始化。

以下是各个选项的解释：

A. `:a(n){}` - 这是不合法的，因为 `a` 是基类 AA 的私有成员，不可以在派生类的初始化列表中直接初始化。

B. `:AA(n){}` - 这是正确的。它使用基类的构造函数来初始化基类部分。

C. `{a(n)};` - 这也是不合法的，因为像选项 A，`a` 是私有成员，不能在派生类中直接初始化或访问。

D. `{a=n};` - 这同样是不合法的，因为 `a` 是基类的私有成员，不能在派生类中直接赋值。

因此，正确答案是 B，它正确地使用了基类构造函数初始化基类成员变量。

10. 已知基类 Employee只有一个构造函数，其定义如下：

Employee::Employee(int n):id(n){}
Manager 是 Employee 的派生类，则下列对 Manager 的构造函数定义中，正确的是 。
A.Manager::Manager(int n):id(n){}
B.Manager::Manager(int n){id=n}
C.Manager::Manager(int n):Employee(n){}
D.Manager::Manager(int n){ Employee(n);}

C

11.有如下程序：

#include<iostream>
using namespace std;
class Base{
public;
void fun(){cout<'B';  }
};
class  Derived:public  Base{
public:
void fun()
{   .......        ;                                              
cout<<'D';
}
};
int main()
{  	Derived d;
d.fun();
return 0;
}

若程序的输出结果是 BD, 则画线处缺失的部分是 。
A.fun(); B.Base,fun(); C.Base::fun(); D.Base->fun();

C

12. 关于虚基类的描述中，错误的是 () 。

A, 使用虚基类可以消除由多继承产生的二义性
B. 构造派生类对象时，虚基类的构造函数只被调用一次
C. 声明“class B:virtual public A”,说明类 B为虚基类
D. 建立派生类对象时，首先调用虚基类的构造函数

C. 声明“class B:virtual public A”,说明类 B为虚基类

这个描述是错误的。该声明实际上是指 A 是 B 的虚基类，而不是 B 是某个虚基类。当使用虚继承时，
类 A 将成为类 B 的虚基类，这样做是为了解决多重继承中可能出现的菱形继承问题，
其中一个类可能通过不同的路径多次继承同一个基类。

二、填空题

1. 如果类 A 继承了类 B, 那么类 A 被称为 （基） 类，而类 B 被称为 （派生） 类。
2 . C++的两种继承为： （公有继承） 和 （私有继承） 。
3. 在默认情况下的继承方式为（私有继承） 。
4. 从基类中公有派生一个类时，基类的公有成员就成为派生类的（公有） 成员，而这个基类的保护成员就成为派生类的 （保护） 成员。
5. C++提供了（多继承） 机制，允许一个派生类可以继承多个基类，甚至这些基类是互 不相关的。
6. 类X中的名字N 支配类Y中同名的名字N, 是指类X 以类Y 为它的一个基类，这称为 （支配规则） 。
7. 引进虚基类的目的是 （消除多重继承中由于继承同一个基类而产生的二义性和重复基类成员问题） 。
8. 在一个继承结构中，解决二义性的方法有 （虚继承） 和 （使用作用域运算符） 。

三、阅读程序题

1. 下列程序的输出结果是（3） 。

#include<iostream>
using namespace std;
class Base
{	int k;
public:
	void set(int n){k=n;}
	int get(){return k;}
};
class Derived:protected Base
{  	int j;
public:
	void set(int m,int n){Base::set(m);j=n;}
	int get(){return Base::get()+j; }
};
int main()
{
	Derived d;
	d.set(1,2);
	cout<<d.get()<<endl;
	return 0;
}

2,下列程序的输出结果是

#include<iostream>
using namespace std;
class A
{
public:
	A(){ cout<<"A";}
	~A(){cout<<"~A"; }
};
class B:public A
{	A *p;
public:
	B()
	{   cout<<"B";
		p=new A();
	}
	~B()
	{   cout<<"~B";
		delete p;
	}
};
int main()
{  	B obj;
	return 0;
}

程序的输出结果是 `ABAB~A~B~A`。

下面是程序执行过程中的详细解释：

1. 在main函数中，创建了一个`B`类的对象`obj`。
2. 调用`B`的构造函数`B()`，由于`B`继承自`A`，首先调用基类`A`的构造函数。
3. 输出`A`。
4. 然后执行`B`的构造函数体，输出`B`。
5. 在`B`的构造函数中，使用`new`创建了一个`A`类的对象，并将其地址赋值给指针`p`，因此会再次调用`A`的构造函数。
6. 输出`A`。
7. 程序接着会离开`B`构造函数的作用域，但此时对象`obj`的生命周期并未结束，故不会调用任何析构函数。
8. 当main函数执行完毕，`obj`的生命周期结束，此时会首先调用`B`类的析构函数`~B()`。
9. 输出`~B`。
10. 在`~B()`中，`delete p;`会删除之前构造函数中创建的`A`对象，因此调用`A`的析构函数。
11. 输出`~A`。
12. 跳出`~B()`的作用域，`B`的析构函数执行完毕，接着调用基类`A`的析构函数。
13. 输出`~A`。

因此，整个程序的输出为`ABAB~A~B~A~A`。

3. 下列程序的输出结果是 。

#include<iostream>
using namespace std;
class A{
public:
	int x;
	A(){ x=100; }
	A(int  i){x=i; }
	void Show(){ cout<<"x="<<x<<'\t'<<"AA\n"; }
};
class B{
public:
	int y;
	B(){y=300;}
	B(int x){y=x; }
	void Show(){cout<<"y="<<y<<'\t'<<"BB\n";}
};
class C:public A,public B{
public:
	int y;
	C(int a,int b,int c):A(a),B(b){y=c; }
	void Show(){ cout<<"y="<<y<<'\t'<<"cc\n"; }
};
int  main()
{  	C c1(400,500,600);
	c1.y=200;
	c1.Show();
	c1.A::Show();
	c1.B::Show();
	return 0;
}

4. 下列程序的输出结果是

#include<iostream>
using namespace std;
class base
{
public:
	void who(){ cout<<"base class"<<endl;}
};
class derivel:public base
{
public:
	void who(){cout<<"derivel class"<<endl;}
};
class derive2:public base
{
public:
	void who(){cout<<"derive2 class"<<endl; }
};
void fun(base *p)
{   p->who();}
int main()
{   base obj1,*p;
	derivel obj2;
	derive2 obj3;
	fun(&obj1);
	fun(&obj2);
	fun(&obj3);
	obj2.who();
	obj3.who();
	return 0;
}

base class
base class
base class
derivel class
derive2 class
程序解释：

base obj1,*p; 声明了基类 base 的一个对象 obj1 和一个指针 p。

derivel obj2; 声明了派生类 derivel 的一个对象 obj2。

derive2 obj3; 声明了派生类 derive2 的一个对象 obj3。

fun(&obj1); 调用函数 fun 传入 base 类的对象地址，函数中的 p->who(); 调用的是基类 base 的 who 方法。

fun(&obj2); 和 fun(&obj3); 由于 fun 的参数类型是 base 类的指针，根据参数的静态类型，调用的也是 base 类的 who 方法。这里没有发生多态，因为 who 方法在基类中没有被声明为 virtual。

最后，obj2.who(); 和 obj3.who(); 直接调用其各自类的 who 方法，因为这里是通过对象调用，不涉及多态。

由于基类的 who() 方法没有被声明为虚函数 (virtual)，fun() 函数中的 p->who() 调用不会展现多态行为（即不会根据对象的实际类型来调用对应的函数），而是会根据指针类型（基类 base）调用基类的 who() 方法。因此，前三次调用 fun() 都会输出 "base class"。而直接通过派生类对象调用 who() 时，则会调用相应派生类中的方法，分别输出 "derivel class" 和 "derive2 class"。

三、编程题

1. 定义一个长方形 Rect 类，派生出长方体类 Cub, 计算派生类对象的表面积和体积。

#include <iostream>
using namespace std;
class Rect{
	public:
	double length;
	double width;
		Rect(double l,double w){
			length=l;width=w;
		}
		double area1(){
			return length*width;
		}
}; 
class Cub:public Rect{
	double height;
	public:
		Cub(double l,double w,double r):Rect(l,w){
		height=r;
		}
		double bs(){
			return 2*length*width+2*length*height+2*width*height;
		}
		double volume(){
			return area1()*height;
		}
};
int main(){
	Cub A(3,4,5);
	cout<<"表面积为:"<<A.bs()<<"体积为:"<<A.volume();
}
}

在这里插入图片描述

2. 定义一个 Shape 基类，并派生出圆球体(Sphere) 和立方体类(Cube), 分别求圆球体 与立方体对象的表面积和体积。

#include<iostream>
using namespace std;
class Shape {
protected: // protected允许子类访问
    double x, y;
public:
    Shape(double a, double b) {
    	x=a;y=b;
	}
    double area() {
        return 0;
    } 
    double volume() {
        return 0;
    }
};
class Sphere : public Shape {
    double radius;
public:
    Sphere(double d): Shape(d, d){
    	radius=d;
	} // 调用基类构造函数并初始化radius
    double area() {
        return 3.14 * radius * radius * 4;
    }
    double volume() {
        return 3.14 * radius * radius * radius * 4 / 3;
    }
};
class Cube : public Shape {
    double z;
public:
    Cube(double a, double b, double c) : Shape(a, b) {
    	z=c;
	} // 调用基类构造函数并初始化z
    double area() {
        return 2 * (x * y + x * z + y * z);
    }
    double volume() {
        return x * y * z;
    }
};
int main() {
    Sphere A(1);
    cout << "圆球体的表面积为：" << A.area() << "\n"; 
    cout << "圆球体的体积为：" << A.volume() << "\n"; 
    Cube B(3, 4, 5);
    cout << "立方体的表面积为：" << B.area() << "\n"; 
    cout << "立方体的体积为：" << B.volume() << "\n"; 
    return 0;
}

在这里插入图片描述

3. 定义一个点类（Point）、矩形类（Rectangle和立方体类（Cube）的层次结构。矩形包括长度和宽度两个新数据成员，矩形的位置从点类继承。立方体类由长度、宽度和高度构成要求各类提供支持初始化的构造函数和显示自己成员的成员函数。编写主函数，测试这个层次结构，输出立方体类的相关信息。

#include<iostream>
using namespace std;
class Point//描述二维平面中一个点的类
{
    double x, y;
public:
    Point(float i=0, float j=0) { x=i; y=j;}
    double area( ) { return 0.0;}
};
class Rectangle:public Point
{
	float length;
	protected:
		float width;
	public:
		Rectangle(){
			length=0;width=0;
		} 
		Rectangle(float l,float w){
			length=l;width=w;
		}
		float Area(){
			return length*width;
		}
		float GetL(){
			return length;
		}
		float GetW(){
			return width;
		}
		void RPrint(){
			cout<<"矩形的长为："<<length;
			cout<<"\t宽为"<<width;
		}
};
class Cuboid:public Rectangle
{
	float high;
	public:
		Cuboid(){
			high=0;
		}
		Cuboid(float l,float w,float h):Rectangle(l,w){
			high=h;
		} 
		void CPrint()
		{
			cout<<"长方体的长为:"<<GetL()<<"\t宽为:"<<width;
			cout<<"\t高为："<<high<<"\t体积为:"<<high*Area()<<'\n';
		}
};
int main(){
	Rectangle r(10,5);
	r.RPrint();
	cout<<"\t面积为:"<<r.Area()<<'\n';
	Cuboid c(6,3,10);
	cout<<"矩形的长为："<<c.GetL()<<"\t宽为："<<c.GetW();
	cout<<"\t面积为:"<<c.Area()<<'\n';
	c.CPrint(); 
}

在这里插入图片描述

暗托涅瓦
关注
  • 20
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
android 面向对象 5,C++基础学习笔记(5)---面向对象(测试题)
weixin_28987001的博客
05-26 1631
C/C++测试题面向对象选择题：C++概述1、以下C++新增的关键字为D。AbreakBcontinueCstuctDinline2、面向对象程序设计将数据与__A___放在一起，作为相互依存、不可分割的整体来处理。A对数据的操作B信息C数据隐藏D数据抽象3、面向对象程序设计优于传统的结构化程序设计，其优越性主要表现在，它有希望解决软件工程的两个主要问题：软件复杂性和__A____。A 软...
c++继承与派生习题答案
csq542586的博客
05-01 6298
1．概念填空题 1.1在C++中，三种派生方式的说明符号为 public 、 private 、 protected不加说明，则默认的派生方式为private 。 1.2当公有派生时，基类的公有成员成为派生类的 公有成员 ；保护成员成为派生类的 保护成员 ；私有成员成为派生类的 不能直接访问成员 。当保护派生时，基类的公有成员成为派生类的 保护成员；保护成员成为派生类的 保护成员 ；私有成员成为派生类的 不能直接访问成员 。 1.3 派生类的构造函数一般有3项工作要完成：首先 基类初始化 ，其次 成员
MOOC派生类构造函数的成员初始化列表中,不能包含的初始化项?
阿腾木的小世界
12-14 9481
这里所说的“基类的子对象”即基类的数据成员 在C＋＋中，构造函数不能被继承，因此，派生类的构造函数必须通过调用基类的构造函数来初始化基类子对象。 在派生类初始化列表直接初始化基类的成员，被称为“越级初始化”，是会报错的。 举个栗子： 我们先创建一个基类，里面有一个int型子对象 class A{ protected: int n;//基类的子对象 public: A(); A...
【C/C++笔试练习】继承和派生的概念、虚函数的概念、派生类的析构函数、纯虚函数的概念、动态编译、多态的实现、参数解析、跳石板
最新发布
Crocodile1006的博客
11-18 1196
C/C++笔试练习、选择部分、继承和派生的概念、虚函数的概念、派生类的析构函数、纯虚函数的概念、动态编译、子类的析构函数、多态的实现、程序分析、编程题、参数解析、跳石板
继承与派生练习题
Lucky_追梦仔的博客
02-16 8020
我是计算机专业的一位大一本科生，C++小白，下面是我们学校在学习C++时用的基础练习题，我感觉这些题比较适合初学C++的码友，所以利用空闲时间将这些题整理出来，一是为了让初学C++的码友有所参考，二也是为了复习一下所学过知识。（因准备急促，如有代码错误，还请各位码友指正。） 继承与派生 01 请以点类Point为基类派生出一个圆类Circle。圆类Circle的数据成员为r（私有属性，存储圆的半径，圆心的点坐标通过继承点类Point加以实现），成员函数有构造函数Circle、计算圆的面积函数Area、计算圆
C++给学生习题第6章练习题 .pdf
02-27
9. 类的继承与访问权限： 如果类A是类B的友元，类B是类C的友元，这并不意味着类A自动成为类C的友元。类C的成员函数可以访问类B的公有和受保护成员，但不能直接访问私有成员。 10. 静态成员的访问： 要访问类的...
程序设计教程--c++语言编程习题详解.doc
11-08
1.9 第9章 类属（泛型）机制――模板 模板是C++中的泛型编程工具，可以用于创建函数模板和类模板，实现代码的通用性和复用。 1.10 第10章 输入/输出（I/O） C++提供了iostream库进行输入输出操作，包括cin和cout...
C++选择题练习.pdf
02-27
- 私有继承时，基类的所有成员在派生类中都被视为私有的，因此派生类对象无法直接访问基类的公有成员函数或私有数据成员，所以B和C选项均错误。 2. 继承和派生的特性： - 派生类可以访问通过私有继承的基类的保护...
c++第三版习题答案
02-18
### 选择题详解 5. **选择题解析**： - **1题**：关键字`public`用于声明类中的公共成员。 - **2题**：友元函数不是类的成员函数，而是独立于类之外的函数。 - **3题**：作用域运算符(`::`)用于标识某个成员属于...
C++习题 (2).pdf
02-27
7. **构造函数和静态成员**：程序中的`Sample`类有一个构造函数，每次调用`fn`函数都会创建一个静态成员`c`，所以第一次调用`fn(10)`时输出`constructore`和`i=10`，第二次调用`fn(20)`不会再次构造`c`，因此输出`i=...
C++编程：继承与派生
qq_52052302的博客
08-21 416
3.定义个人信息类Person，其数据成员有姓名、性别、出生年月。并以Person为基类定义一个学生的派生类Student，增加描述学生的信息：班级、学号、专业、英语成绩和数学成绩。再由基类Person定义一个职工的派生类Employee，增加描述职工的信息：部门、职务、工资。编写程序实现学生与职工信息的输入与输出。（3）掌握派生类的构造函数与析构函数的应用及调用顺序；（1）掌握类的继承和派生概念;（2）掌握派生类的定义与使用；（4）理解赋值兼容原则的应用。
C++郑莉课后题-第七章-继承与派生-编程部分
qq_58879623的博客
09-22 400
—派生里重写的函数在基类里要virtual；——基类指针可以指派生类，父可以指子，父可以指子，父可以指子public:double w,h;return w;return h;//基类可以指向派生类cout<<"圆面积"<<p->getArea()<<endl;delete p;cout<<"长方形面积"<<p->getArea()<<endl;
浅谈c++
max_LLL的博客
07-14 988
浅谈C++ 1.类的定义 为了在程序中创建对象,必须首先定义类.c++语言用保留字class定义一个类,一般形式为: class 类名 { • public: • <共有数据和函数> • protected: • <保护数据和函数> • private: • <私有数据和函数> ​ }; #值得注意的是,右花括号后的分号";"作为类声明的结束标志是不能漏
第四章 课后习题
Lijing_666的博客
04-24 2005
一、填空题（1）如类果类A继承了B，那么类A被称为     基     类，而类B被称为     派生     类。（2）C++的两种继承为:   单继承   和  多继承   。（3）在默认情况下的继承方式为  私有继承方式  。（4）从基类中公有派生一个类时，基类的公有成员就成为派生类的  公有  成员，而这个基类的保护成员就成为派生类的  保护成员。（5）C++提供了  多继承   机制，允...
每日一练20210715
upon120的博客
07-18 527
1、将域名转换为IP地址是由( )服务器完成？ 2021-07-16 02:22:24 A、 WINS B、 DHCP C、 DNS D、 IIS 回答正确正确答案:C 解析: WINS实现的是ip地址和计算机名称的映射，他集中管理计算机名称和IP地址，作用范围是内网。 DNS实现的是IP地址与域名的映射，范围是整个互联网。 IIS是互联网信息服务，是微软公司提供的基于Windows的互联网基础服务 DHCP动态主机配置协议，局域网的网络协议，使用udp协议工作，主要用途:集中地管理...
继承与派生编程题1（C++程序设计第5周）
NodYoung
12-20 6202
问题描述写一个MyString 类，使得下面程序的输出结果是： abcd-efgh-abcd- abcd- 3. abcd-efgh- efgh- c abcd- ijAl- ijAl-mnop qrst-abcd- abcd-qrst-abcd- uvw xyz aboutbigmetakeabcdqrst-abcd-要求：MyString类必须是从C++的标准类string类派生而来。提示1：如
公有继承，私有继承，保护继承的区别
dwj6336736的博客
08-29 645
一个子类继承父类时，可按照public、private和protected方式继承父类，每种继承方式的区别如下：1) public继承方式基类中所有public成员在派生类中为public属性； 基类中所有protected成员在派生类中为protected属性； 基类中所有private成员在派生类中不可访问。2) protected继承方式基类中的所有public成员在派生类中为protec
C++总结6——继承与多态的笔试题
wendy_keeping的博客
07-17 3221
1———————————————- #include using namespace std; class Base { public: Base(int data):_ma(data) { cout"Base()"<<endl; } virtual ~Base() { cout"~Base()"<<endl; }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值