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

在这里插入图片描述

一、选择题

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

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/285264.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

双指针——移动零

双指针——移动零

题目 示例 算法原理 我们使用两个指针&#xff0c;cur扫描数组&#xff0c;如果nums[cur]为非0&#xff0c;dest&#xff0c;然后让nums[cur]与nums[dest]交换&#xff0c;从而实区间[0,dest]为非0,[dest1,cur]为0&#xff0c;[cur,numsSize-1]为未扫描 题目链接&#xff1a;28…
阅读更多...
1.1 理解大数据（2）

1.1 理解大数据（2）

小肥柴的Hadoop之旅 1.1 理解大数据&#xff08;2&#xff09; 目录1.1 理解大数据1.1.3 大数据概述1.1.4 更多思考 参考文献和资料 目录 1.1 理解大数据 1.1.3 大数据概述 step_0 大数据定义 【《大数据算法设计分析》】&#xff1a; 通常来讲大数据&#xff08;Big Data&am…
阅读更多...
pyqt5用qtdesign设计页面时，去掉页面的空白界面、边框和标题栏

pyqt5用qtdesign设计页面时，去掉页面的空白界面、边框和标题栏

前言 Windows默认的标题栏有时候自己觉得不太美观&#xff0c;就想自己设计一个&#xff0c;然后把默认的去掉&#xff0c;并且把长方形的边框和多余的空表界面去掉&#xff0c;就是下图中圈出来的区域&#xff1a; 去掉之后的效果如图&#xff1a; 这样我们就可以自定义窗…
阅读更多...
Spring Boot 3 集成 Jasypt详解

Spring Boot 3 集成 Jasypt详解

随着信息安全的日益受到重视&#xff0c;加密敏感数据在应用程序中变得越来越重要。Jasypt&#xff08;Java Simplified Encryption&#xff09;作为一个简化Java应用程序中数据加密的工具&#xff0c;为开发者提供了一种便捷而灵活的加密解决方案。本文将深入解析Jasypt的工作…
阅读更多...
57.网游逆向分析与插件开发-游戏增加自动化助手接口-接管游戏的自动药水设定功能

57.网游逆向分析与插件开发-游戏增加自动化助手接口-接管游戏的自动药水设定功能

内容来源于&#xff1a;易道云信息技术研究院VIP课 码云地址&#xff08;master分支&#xff09;&#xff1a;https://gitee.com/dye_your_fingers/sro_-ex.git 码云版本号&#xff1a;51307d6bf69f2f3c645c70d09f841f5e32da79b9 代码下载地址&#xff0c;在 SRO_EX 目录下&…
阅读更多...
MySQL 8.0 InnoDB Tablespaces之Undo Tablespaces（UNDO表空间）

MySQL 8.0 InnoDB Tablespaces之Undo Tablespaces（UNDO表空间）

文章目录 MySQL 8.0 InnoDB Tablespaces之Undo Tablespaces&#xff08;UNDO表空间&#xff09;Undo Tablespaces&#xff08;UNDO表空间&#xff09;默认UNDO表空间添加 Undo 表空间查看Undo 相关的信息查看Undo 相关参数变量查看Undo 状态信息通过information_schema.innodb_…
阅读更多...
Java ArrayList在遍历时删除元素

Java ArrayList在遍历时删除元素

文章目录 1. Arrays.asList()获取到的ArrayList只能遍历&#xff0c;不能增加或删除元素2. java.util.ArrayList.SubList有实现add()、remove()方法3. 遍历集合时对元素重新赋值、对元素中的属性赋值、删除元素、新增元素3.1 普通for循环3.2 增强for循环3.3 forEach循环3.4 str…
阅读更多...
JavaScript编程进阶 – 迭代器

JavaScript编程进阶 – 迭代器

JavaScript编程进阶 – 迭代器 JavaScript Programming Advanced - Iterators By JacksonML 在JavaScript语言中&#xff0c;迭代器是对象(Object), 它事先定义好了一个序列&#xff0c;并在其终止时有可能地&#xff08;潜在地&#xff09;返回值。 本文简要介绍迭代器对象如…
阅读更多...
初识HTTP协议

初识HTTP协议

Web服务器可以接收浏览器的请求&#xff0c;并将服务器中的web项目资源响应给浏览器&#xff0c;浏览器与服务器之间进行网络通信遵循HTTP协议。 一、什么是HTTP协议 超文本传输协议&#xff08;HTTP&#xff0c;HyperText Transfer Protocol&#xff09;(浏览器---->web服务…
阅读更多...
2024新版塔罗占卜网站源码风水起名附带搭建视频及文本教程

2024新版塔罗占卜网站源码风水起名附带搭建视频及文本教程

附带文本教学及视频教程安装方法以linux为例&#xff1a; 1、建议在服务器上面安装宝塔面板&#xff0c;以便操作&#xff0c;高逼格技术员可以忽略这步操作。 2、把安装包文件解压到根目录&#xff0c;同时建立数据库&#xff0c;把数据文件导入数据库 3、修改核心文件conf…
阅读更多...
Linux下使用Wireshark抓包教程

Linux下使用Wireshark抓包教程

在实际开发中&#xff0c;涉及网络传输的环节是非常多的。在这些过程中&#xff0c;我们经常有查看被传输的数据信息的需求&#xff0c;因此&#xff0c;抓包工具应运而生。Wireshark便是一款非常有名的抓包及分析软件&#xff0c;具有强大的协议解析能力。本文将介绍如何在Lin…
阅读更多...
前端算法之二叉树

前端算法之二叉树

二叉树 二叉树用于解决什么问题 数据的组织与搜索&#xff1a;排序&#xff1a;表达式和计算&#xff1a;图形处理&#xff1a; 举例&#xff1a;二叉树的最近公共祖先 思路&#xff1a; 排序/排布方式 和 &#xff08;排序中&#xff09;当前树和节点的关系 举例2&#xff1a;…
阅读更多...
二叉树的前序遍历 、二叉树的最大深度、平衡二叉树、二叉树遍历（leetcode）

二叉树的前序遍历 、二叉树的最大深度、平衡二叉树、二叉树遍历（leetcode）

目录 一、二叉树的前序遍历 方法一&#xff1a;全局变量记录节点个数 方法二&#xff1a;传址调用记录节点个数 二、二叉树的最大深度 三、平衡二叉树 四、二叉树遍历 一、二叉树的前序遍历 方法一&#xff1a;全局变量记录节点个数 计算树的节点数: 函数TreeSize用于递…
阅读更多...
Zookeeper注册中心实战

Zookeeper注册中心实战

Java学习手册面试指南&#xff1a;https://javaxiaobear.cn Spring Cloud Zookeeper通过自动配置和绑定到 Spring 环境和其他 Spring 编程模型习惯用法&#xff0c;为 Spring Boot 应用程序提供Apache Zookeeper集成。通过一些简单的注释&#xff0c;您可以快速启用和配置应用…
阅读更多...
51单片机中TCON, IE, PCON等寄存器的剖析

51单片机中TCON, IE, PCON等寄存器的剖析

在单片机中&#xff0c;如何快速通过名字记忆IQ寄存器中每一个控制位的作用呢&#xff1f; IE&#xff08;interrupt enable&#xff09;寄存器中&#xff0c;都是中断的使能位置。 其中的EA&#xff08;enable all&#xff09;是总使能位&#xff0c;ES(enable serial)是串口…
阅读更多...
Head First Design Patterns - 装饰者模式

Head First Design Patterns - 装饰者模式

什么是装饰者模式 装饰者模式动态地将额外责任附加到对象上。对于拓展功能&#xff0c;装饰者提供子类化的弹性替代方案。 --《Head First Design Patterns》中的定义 为什么会有装饰者模式 根据上述定义&#xff0c;简单来说&#xff0c;装饰者模式就是对原有的类&#xff0c…
阅读更多...
STM32与TB6612电机驱动器的基础入门教程

STM32与TB6612电机驱动器的基础入门教程

TB6612是一款常用的双路直流电机驱动芯片&#xff0c;适用于小型机器人以及其他需要控制电机方向和转速的应用。在STM32微控制器的配合下&#xff0c;可以实现对TB6612电机驱动器的控制&#xff0c;进而实现电机的控制。本文将带领读者一步步了解如何搭建基于STM32与TB6612的电…
阅读更多...
华为云默认安全组配置规则说明

华为云默认安全组配置规则说明

华为云服务器默认安全组可选Sys-default、Sys-WebServer或Sys-FullAccess。default是默认安全组规则&#xff0c;只开放了22和3389端口&#xff1b;Sys-WebServer适用于Web网站开发场景&#xff0c;开放了80和443端口&#xff1b;Sys-FullAccess开放了全部端口。阿腾云atengyun…
阅读更多...
机器学习——主成分分析（PCA）

机器学习——主成分分析（PCA）

目录 背景 引入 特征维度约减 特征维度约减的概念 为何要维度约减? 维度约减的应用 常规维度约减方法 主成分分析 主成分分析 (PCA)基本思路 主成分的代数定义和代数推导 主成分的代数定义 主成分的代数推导 PCA算法两种实现方法 1、基于特征值分解协方差矩阵实…
阅读更多...
以太网二层交换机实验

以太网二层交换机实验

实验目的&#xff1a; &#xff08;1&#xff09;理解二层交换机的原理及工作方式&#xff1b; &#xff08;2&#xff09;利用交换机组建小型交换式局域网。 实验器材&#xff1a; Cisco packet 实验内容&#xff1a; 本实验可用一台主机去ping另一台主机&#xff0c;并…
阅读更多...
最新文章

Copyright @ 2022~2023