C++ -- 深入理解多态

news2024/11/28 14:38:06

        前言：多态的概念，通俗地来讲就是多种形态。当我们要完成某个行为的时候，不同的对象去完成时会产生不同的状态，这就叫做多态。具体点就是去完成某个行为，当不同的对象去完成时会 产生出不同的状态。多态在C++的类和对象中具有十分重要的作用，大部分学校对于C++中多态的讲解并不透彻，下面，我们就一起来深入了解多态......

注意：我们在本次的讲解中，用到的代码环境均为vs2022的x86环境，32位的环境下，指针是4字节，需要注意不同的运行环境下代码可能会有不同。

目录

1.多态的定义及其实现

多态的构成条件

虚函数的重写

两个例外

1. 协变(基类与派生类虚函数返回值类型不同)     

2. 析构函数的重写(基类与派生类析构函数的名字不同)

什么情况下需要析构函数重写呢？

C++11 override 和 final

1. final：修饰虚函数，表示该虚函数不能再被重写

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

重载、覆盖(重写)、隐藏(重定义)的对比

2.抽象类

接口继承和实现继承

典例解析

3.多态的原理

虚函数表

为什么多态实现不能是传对象类型而必须是引用或指针？

虚函数的地址一定会被放进虚函数表吗？

监视窗口不可信情况

最可信的大招-打印虚表

动态绑定与静态绑定

多继承中的虚函数表

结论

一些细节问题

4.菱形继承、菱形虚拟继承（了解）

菱形继承

菱形虚拟继承

5.多态经典题

都看到这里了，休息一下叭~

1.多态的定义及其实现

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

多态的构成条件

在继承中要构成多态有两个条件：

1. 必须通过基类的指针或者引用调用虚函数

2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

虚函数的重写

       虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

下面一段代码实现了一个最简单的多态：

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
	为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
	这样使用*/
	/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

用相同的func函数实现了传入不同对象返回了不同的功能，这就是最简单的多态。

两个例外

1. 协变(基类与派生类虚函数返回值类型不同)     

        派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指 针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

我们可以将上述的代码进行简单的修改，

class Person {
public:
	virtual Person* BuyTicket() { cout << "买票-全价" << endl; return new Person; }
};
class Student : public Person {
public:
	virtual Student* BuyTicket() { cout << "买票-半价" << endl; return new Student; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

此时，我们发现，其也能实现多态的功能，这种特殊情况了解即可。

2. 析构函数的重写(基类与派生类析构函数的名字不同)

       如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字， 都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同， 看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

什么情况下需要析构函数重写呢？

       普通的情况下，析构函数没问题。Student先析构，子类析构函数不需要显式调用父类的析构函数，会自动调用父类析构函数来完成析构，达成子类对象先析构，父类对象后析构的目的。

但是，当父类对象尝试new一个子类对象后，也想要实现达成多态的条件之一时，如果不把析构函数写成虚函数便会出问题。

      这种情况下，只是释放了父类对象的空间，而实际上父类的指针指向的其实是一个子类的对象，正常调用应该是先释放子类对象，然后在释放父类对象，只调用父类的析构函数，将会导致内存泄漏的问题。

C++11 override 和 final

       C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数 名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮 助用户检测是否重写。

1. final：修饰虚函数，表示该虚函数不能再被重写

class Car
{
public:
 virtual void Drive() final {}
};
class Benz :public Car
{
public:
 virtual void Drive() {cout << "Benz-舒适" << endl;}
};

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car{
public:
 virtual void Drive(){}
};
class Benz :public Car {
public:
 virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

重载、覆盖(重写)、隐藏(重定义)的对比

2.抽象类

       在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数（只要有纯虚函数）的类叫做抽象类（也叫接口 类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生 类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。这也是多态的另外一种表达形式，由一对一的父子继承关系，变成了一对多的一父多子的继承关系，各个子类重写的是同一个父类的纯虚函数。

示例：

class Car{
public:
	virtual void Drive() = 0;
};
class Benz :public Car{
public:
	virtual void Drive(){cout << "Benz-舒适" << endl;}
};
class BMW :public Car{
public:
	virtual void Drive(){cout << "BMW-操控" << endl;}
};
void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
}

接口继承和实现继承

        普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成 多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

典例解析

请移步至多态经典题目第一小题。

3.多态的原理

虚函数表

我们来看下面一段含有虚函数的代码及其输出结果：

我们发现，类的大小比我们预想的四个字节正好又多了四个字节，下面我们来进行调试，查看这个Base类内部的成员变量，

       我们发现，在类对象的内部，除了私有成员变量 _b,还有一个指针变量_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针（每一个虚表指针都是一个函数指针，可以用来保存若干虚函数的函数地址），因为虚函数 的地址要被放到虚函数表中，虚函数表也简称虚表。

      有时候监视窗口并不能很好地反应变量在内存中存储的内容，我们可以通过内存调试，将该对象的内存中存储的内容显示出来，

那么派生类中这个表放了些什么呢？我们针对上面的代码做出修改，使之符合派生类继承和重写的要求，

class Base{
public:
	virtual void Func1(){cout << "Base::Func1()" << endl;}
	virtual void Func2(){cout << "Base::Func2()" << endl;}
	void Func3(){cout << "Base::Func3()" << endl;}
private:
	int _b = 1;
};
class Derive : public Base{
public:
	virtual void Func1(){cout << "Derive::Func1()" << endl;}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;

	return 0;
}

通过调试，我们可以得到b和d的内部成员信息：

由于上面基类对象b的结构即内存分布在上面已经给出，这里重点介绍基类在派生类中的内存分布，并且给出多态的实现的一般性原理，

为什么多态实现不能是传对象类型而必须是引用或指针？

       一般的，我们将子类对象通过赋值兼容规则赋值给父类对象的时候，编译器只会拷贝子类对象中父类的数据，但是却不会拷贝虚函数表指针给父类，但是一旦采取了赋值的方式，拷贝了虚函数表指针给父类，父类对象就不能保证父类对象的需要是自己的，也有可能是子类的虚表拷贝过来的，这就无法实现父类和子类的虚函数各自保存在自己的虚表中以通过子类重写以实现多态的目的。

虚函数的地址一定会被放进虚函数表吗？

      正确的回答是是的，每个类的所有虚函数的地址一定会被放进虚函数表中，但是有一些特殊情况容易导致我们误认为虚函数没有被放进虚函数表，我们来分析一下这些情况：

监视窗口不可信情况

我们给出一段多继承代码如下，尝试查看对象的虚函数表的情况：

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
	void func5() { cout << "Derive::func5" << endl; }
private:
	int b;
};
class X :public Derive {
public:
	virtual void func3() { cout << "X::func3" << endl; }
};
int main()
{
	Base b;
	Derive d;
	X x;

	Derive* p = &d;
	p->func3();

	p = &x;
	p->func3();

	return 0;
}

调出监视窗口，我们发现事实并不像我们想的那样，

监视窗口并没有显示出虚函数表的全部函数，从上面我们可以看出，明明上面都写着虚函数表的大小是5，也就是保存了四个虚函数地址，最终却只显示出来了2个虚函数，所以，当前的监视窗口变得不可信了，因为它是经过开发人员优化过的结果，最终目的是为了让用户更加容易理解。

       监视窗口会骗我们，但是内存窗口不会，所以，我们调出内存窗口继续观察这三个对象的虚表指针指向的位置，

最可信的大招-打印虚表

我们可以通过打印虚表的方式来获取对象虚表中的全部内容，具体可以参考以下代码：

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
	void func5() { cout << "Derive::func5" << endl; }
private:
	int b;
};
class X :public Derive {
public:
	virtual void func3() { cout << "X::func3" << endl; }
};

//虚表是一个函数指针数组
typedef void (*VFUNC)();//函数指针重命名
void PrintVFT(VFUNC a[])
{
	for (size_t i = 0; a[i] != 0; i++) //vs下虚表中的最后一个位置是nullptr，但是Linux环境不行，只能固定写多少个，这一点需要注意
	{
		printf("[%d]:%p->", i, a[i]);
		VFUNC f = a[i];
		f();//调用一下函数，根据输出辨别是哪一个函数
		//(*f)();
	}
	printf("\n");
}
int main()
{

    void (*f)();//普通函数指针的变量定义
	Base b;
	Derive d;
	X x;

	PrintVFT((VFUNC*)(*((int*)&b)));//int* 表示取前四个字节，还需要注意类型转换，直接打印就是int*型，和函数指针类型不匹配，所以需要再强转为函数指针型，关于数据强转，通常情况下，内存和类型相关或相似的才能够互相强转
	PrintVFT((VFUNC*)(*((int*)&d)));
	PrintVFT((VFUNC*)(*((int*)&x)));
	return 0;
}

      这里需要注意，这个代码使我们直接访问内存，所以可能会出现异常访问的情况，这个时候，我们需要重新生成一下解决方案就可以了。 

       这个时候，各个类中的虚函数就一目了然了，后面，我们还会继续使用这种方法来显示类对象的所有虚函数，由于这种方式是直接访问内存，所以其结果也是非常可靠的。

动态绑定与静态绑定

       1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态， 比如：函数重载

       2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体 行为，调用具体的函数，也称为动态多态。

多继承中的虚函数表

我们给出如下的多继承示例代码：

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};
class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private: int b2;
};
class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

int main()
{
	Derive d;

	return 0;
}

我们考虑查看出d的虚表结构进行观察，下面是监视结果。 

d对象的结构也是按照我们监视出来的成员从上到下的顺序分布的，所以我们可以大致看出d的成员变量分布如下：

     

       为了确定Base1和Base2中虚表的信息和d对象本身将自己的虚表保存在何处？我们需要打印出虚表的详细信息，这里有细节需要注意，就是我们如何获取Base2的前四个字节，这里给出其中一种方式，我们可以将d对象整体强转为一字节地址，然后将其加上Base1地址空间就是Base2的首地址了，接着再进行强转即可。

typedef void (*VFUNC)();//函数指针重命名
void PrintVFT(VFUNC a[])
{
	for (size_t i = 0; a[i] != 0; i++)
	{
		printf("[%d]:%p->", i, a[i]);
		VFUNC f = a[i];
		f();//调用一下函数，根据输出辨别是哪一个函数
		//(*f)();
	}
	printf("\n");
}
int main()
{
	Derive d;
	VFUNC* vTableb1 = (VFUNC*)(*(int*)&d);
	PrintVFT(vTableb1);
	VFUNC* vTableb2 = (VFUNC*)(*(int*)((char*)&d + sizeof(Base1)));//当前我们需要取Base2的虚表指针，由结构图可知其距离d对象首地址的偏移量为一个Base1的大小
	PrintVFT(vTableb2);
	return 0;
}

       哎~等等，你确定它实现了多态吗？为什么在上面显示的结果中，派生类中的func1函数明明已经被重写了，而在派生类func1函数只有一个，但是打印出虚表之后却是有两个不同的地址呢？

       话不多说，实践一下，我们给出一个多态的环境，看看它能否实现多态不就行了吗？下面是测试代码和运行结果，

我们发现，它确实能实现多态，但是这不合理啊，一个函数居然有两个地址吗？

       这里要是演示起来，需要利用汇编进行调试，比较费时费力，所以这里我们直接给出结论，我们知道，Base1和Base2指针在派生类对象中的位置不一样，当父类指针调用派生类虚函数的时候需要用到派生类的this指针，所以Base1和Base2指针需要在调用派生类函数时将自己的指针修正为派生类的指针（此处的修正并不是简单的强转，而是需要找到派生类指针存在的合理的位置，进行相同结构的强转，只有这样，才能按照派生类的模式正常的调用派生类的函数），而Base1指针的位置恰好与派生类对象指针重合，只要进行强转即可，不需要偏移，然而Base2指针与派生类指针相距8个4字节的距离，也就是相距一个Base1的地址，所以，在修正Base2时，需要将其向低地址偏移8个4字节，从而做到以统一的方式调用派生类中的函数。

       这个偏移8个4字节我们可以通过上面的地址直接验证出来，具体的计算如下：

        从输出结果我们可以看出，d对象将自己未重写的func3函数放在了Base1的虚表中，此时，我们不难联想到派生类的未重写的虚函数，将会放在其继承的第一个基类对象的虚表中，为了验证这个结论，我们可以将派生类的继承基类进行互换，再次打印虚表，我们将两次打印的结果进行对比可以得出结论。

所以，在多继承中，我们可以得出如下结论：

结论

       多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中，而将重写的虚函数放在继承下来的基类对象的虚表中。

一些细节问题

1.虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

2.同一个类的对象的虚表相同，理论上而言，一个类只有一个虚表（当然多继承就会不同，这个后面讲解）

3.总结一下派生类的虚表生成：

        a.先将基类中的虚表内容拷贝一份到派生类虚表中

        b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函             数对于派生类不重写的虚函数，派生类在自己的虚表中保存一份与基类相同的虚函数             地址。

        c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

4.虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段（常量区）的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。

针对第4点，我们来浅浅验证一下，我们给出如下代码，具体细节在注释中讲解：

class Base{
public:
	virtual void Func1(){cout << "Base::Func1()" << endl;}
	virtual void Func2(){cout << "Base::Func2()" << endl;}
	void Func3(){cout << "Base::Func3()" << endl;}
private:
	int _b = 1;
};

int main()
{
	Base b1;
	Base b2;
	static int a = 0;
	int b = 0;
	int* p1 = new int;
	const char* p2 = "hello world";
	printf("静态区：%p\n", &a);
	printf("栈区：%p\n", &b);
	printf("堆区：%p\n", p1);
	printf("代码段(常量区)：%p\n", p2);
	printf("虚表：%p\n", *((int*)&b1) ); //虚表保存在类对象的前四个字节中,取对象的地址然后使用int*将其强转为前四个字节，因为此处保存的是虚表指针，我们需要对前四个字节进行解引用得到指针所指向的地址
	printf("虚函数地址：%p\n", &Base::Func1);//类成员函数在获取地址时需要加上&，普通成员函数则不需要


	return 0;
}

从运行结果可以看出，虚表和虚函数地址与代码段的区域地址较为接近，所以他们都保存在代码段。

4.菱形继承、菱形虚拟继承（了解）

菱形继承

       菱形继承其实就是多继承的一种，派生类也是继承两张虚表，分别是两个父类的虚表，只是需要注意多进程的细节即可，比如，在派生类中添加虚函数，则该虚函数会被加入到派生类第一个声明的继承类中。

class A
{
public:
	virtual void func1() { cout << "A::func1" << endl;}
public:
	int _a;
};

class B : public A
//class B : virtual public A
{
public:
	virtual void func1(){cout << "B::func1" << endl;}
	virtual void func3(){cout << "B::func3" << endl;}
public:
	int _b;
};

class C : public A
//class C : virtual public A
{
public:
	virtual void func1(){cout << "C::func1" << endl;}
	virtual void func5(){cout << "C::func5" << endl;}
public:
	int _c;
};

class D : public B, public C
{
public:
	virtual void func1(){cout << "D::func1" << endl;}
	virtual void func2(){cout << "D::func2" << endl;}
public:
	int _d = 1;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

       菱形继承和本质上和多继承一样，派生类会继承两张虚表，分别来自其两个父亲，每一个父亲都会自己的虚表和从共同的父类上继承的虚表，其监视图如下：

菱形虚拟继承

       菱形虚继承的情况就要复杂得多，我们将上面的代码中B和C类设为虚继承，采用内存的方式查看派生类对应的虚表结构，因为菱形虚继承比我们想象的要复杂得多，这里只时简单的了解一下即可，实际中也要尽可能的避免用到菱形虚继承。

5.多态经典题

1.如下程序的输出结果是什么？

class A
{
public:
    virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
    virtual void test() { func(); }
};

class B : public A
{
public:
    void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
    B* p = new B;
    p->test();
    return 0;
}

      乍一看，p是一个派生类B的指针，p调用继承自A的test函数，func函数形成多态，所以答案其实就是 B-> 0了。嘿嘿，搞定~

等等，我还有话要说，咱先看看这个？

  这怎么可能呢？你快说啊，别卖关子了~

      子类的指针去调用test，因为test被public继承下来了。但是即使被继承下来的this指针还是A*的this，这里又涉及了赋值兼容的转换，因为B的指针要调用成员函数得把B的指针传给A*的this。子类传给父类，发生了切片，相当于test里面的this指向了new出来的B对象。

所以这里也符合多态的两个条件，参数是相同的，因为只看类型，不看缺省值。子类继承重写父类虚函数是接口继承，会把缺省值也继承下来。重写的是函数的实现。

2.inline函数可不可以是虚函数？

     内联函数本质上就是在编译阶段将代码展开，内联函数作为虚函数，在不同的情况下具有不同的效果，由于篇幅实在是太大了，所以，这里直接给出结论，内联函数可以是虚函数，只是在多态调用下，内联就会失去内联的作用，因为虚函数表和虚函数指针等结构不能在展开，内联属性只对普通调用生效。

3.静态成员函数可不可以是虚函数？

       不可以，因为静态成员函数没有this指针，静态本质是全局函数，只不过它受类域的限制。

4.构造函数能不能是虚函数呢？

      不可以，编译报错，因为对象中的虚表指针是构造函数阶段才初始化的（注意此时虚函数表已经生成了），如果还没有构造，虚函数的多态调用需要到虚表中查找，但是此时虚表指针还没有初始化。

4.多态调用和普通调用的效率问题？

     一般情况下，多态调用要比普通调用慢，因为要设涉及到虚表指针的问题，到虚表中查找的问题，效率要低下一些。

5.虚函数是在什么阶段生成的？

虚函数表在编译时就已经生成了，虚函数表指针构造时，才初始化给对象的。

都看到这里了，休息一下叭~

        无论你起多早，总有人比你早一步，无论你多努力，总有人比你更拼命。我希望屏幕前的你，好好生活，好好努力，也要好好休息。从现在起屏蔽所有不相关的信息，静下心来好好爱自己。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

python裁剪图片

python裁剪图片

我原本想找到一个小一点的彩色人脸数据集&#xff0c;但是都没有找到合适的 但是我找到了一个人脸数据集的封面 于是我把这两个图片裁开&#xff0c;得到了6464张彩色人脸照片 from PIL import Image# 打开大图 big_image Image.open(female.jpg) # 获取大图的宽度和高度 wid…
阅读更多...
windows 系统不设置密码也能远程登陆

windows 系统不设置密码也能远程登陆

前言 如果windows系统不设置密码&#xff0c;默认情况下是不能远程登陆的 解决办法 按下winr&#xff0c;输入gpedit.msc 再回车 点击windows设置 ----安全设置 ------本地策略-----安全选项 设置为禁用 远程就可以不输入密码了
阅读更多...
PMI-ACP（103：1-16）

PMI-ACP（103：1-16）

英文名&#xff1a;ACP 外文名&#xff1a;Agile Certified Practitioner 中文名&#xff1a;敏捷管理专业人士资格认证 是由 美国项目管理协会 PMI Project Management Institute 发起的&#xff0c;严格评估项目管理人员知识技能是否具有高品质的资格认证。 一年开展4次考…
阅读更多...
摆玩具[算法赛]（差分）

摆玩具[算法赛]（差分）

本题链接&#xff1a;用户登录 题目&#xff1a; 样例&#xff1a; 输入 5 2 2 5 7 10 13 输出 8 思路&#xff1a; 由题意&#xff0c;这是一个递增的数组&#xff0c;其次要求最小的极差&#xff0c;对 数组 进行分成 k 个分段数组。 由于是一个递增的数组&#xf…
阅读更多...
postgresql14管理（六）-备份与恢复

postgresql14管理（六）-备份与恢复

定义 备份&#xff08;backup&#xff09;&#xff1a;通过物理复制或逻辑导出的方式&#xff0c;将数据库的文件或结构和数据拷贝到其他位置进行存储&#xff1b; 还原&#xff08;restore&#xff09;&#xff1a;是一种不完全的恢复。使用备份文件将数据库恢复到备份时的状…
阅读更多...
4.多层感知机

4.多层感知机

#pic_center R 1 R_1 R1​ R 2 R^2 R2 目录 知识框架No.1 多层感知机一、感知机1、感知机2、训练感知机3、图形解释4、收敛定理5、XOR问题6、总结 二、多层感知机1、XOR2、单隐藏层3、单隐藏层-单分类4、为什么需要非线性激活函数5、Sigmoid函数6、Tanh函数7、ReLU函数8、多类分…
阅读更多...
C语言十进制转其它进制

C语言十进制转其它进制

短除法介绍 短除法&#xff1a; 主要功能为将十进制数据转为其它进制的数据&#xff0c;假设我们要转换为 X 进制&#xff0c;那么具体的流程如下&#xff1a; 十进制数字不断除以 X&#xff0c;直到商为 0 记录每次计算得到的余数 将余数倒序输出&#xff0c;即为对应的 X 进…
阅读更多...
C# 递归算法使用简介_常用整理

C# 递归算法使用简介_常用整理

一、递归简介 递归算法是一种直接或者间接调用自身函数或者方法的算法。 递归算法的实质是把问题分解成规模缩小的同类问题的子问题&#xff0c;然后递归调用方法来表示问题的解。递归算法对解决一大类问题很有效&#xff0c;它可以使算法简洁和易于理解。 递归本质是循环&a…
阅读更多...
正五边形的周长 题解

正五边形的周长 题解

描述 已知一个正五边形的一条边的长度是a&#xff0c;计算输出该正五边形的周长。 输入 一行一个正整数a&#xff0c;表示该正五边形的边长。a的数值不会超过int的范围。 输出 一行一个正整数&#xff0c;表示这个该正五边形的周长&#xff0c;也就是5条边加起来的和。 输入样…
阅读更多...
计网小题题库整理第一轮（面向期末基础）（1）

计网小题题库整理第一轮（面向期末基础）（1）

整理了一部分选择和填空&#xff0c;比较基础。计网的核心在于&#xff1a;背就完事~ 一.填空题 在采用电信号表达数据的系统中&#xff0c;数据有数字数据 和 模拟数据 两种。域名系统 DNS 是一个 分布式数据库 系统。TCP/IP 的网络层最重要的协议是 IP 互连网协议&#xff0…
阅读更多...
STM32GPIO有几种模式，

STM32GPIO有几种模式，

一&#xff1a;GPIO有八种模式 输入&#xff1a; GPIO_Mode_AIN 模拟输入 GPIO_Mode_IN_FLOATING 浮空输入 GPIO_Mode_IPD 下拉输入 GPIO_Mode_IPU 上拉输入 输出 GPIO_Mode_Out_OD 开漏输出 GPIO_Mode_Out_PP 推挽输出 GPIO_Mode_AF_OD 复用开漏输出 GPIO_Mode_AF_PP 复用推挽…
阅读更多...
数组与链表算法-单向链表算法

数组与链表算法-单向链表算法

目录 数组与链表算法-单向链表算法 C代码 单向链表插入节点的算法 C代码 单向链表删除节点的算法 C代码 对单向链表进行反转的算法 C代码 单向链表串接的算法 C代码 数组与链表算法-单向链表算法 在C中&#xff0c;若以动态分配产生链表节点的方式&#xff0c;则可以…
阅读更多...
标准ACL，扩展ACL，基本ACL，高级ACL

标准ACL，扩展ACL，基本ACL，高级ACL

其实标准ACL&#xff0c;扩展ACL&#xff0c;基本ACL&#xff0c;高级ACL是同一个概念的不同名称&#xff0c;区别在于: 思科路由器支持标准ACL和扩展ACL两种类型的访问控制列表&#xff0c;没有”基本ACL“和”高级ACL“的概念&#xff0c;而华为路由器都支持 编号范围&…
阅读更多...
2024年天津中德应用技术大学专升本自动化专业基础考试大纲

2024年天津中德应用技术大学专升本自动化专业基础考试大纲

天津中德应用技术大学自动化专业&#xff08;高职升本科&#xff09;2024年专业基础考试大纲 一、试卷类型&#xff08;仅供参考&#xff09; 试卷卷面成绩共200分&#xff0c;考试时间为2小时。内容包含电工基础30%&#xff0c;电子技术30%&#xff0c;电机原理与拖动40%。试…
阅读更多...
PLC程序常用模块

PLC程序常用模块

常用程序块 中继复位&#xff08;使用特殊中继SM&#xff09;初始化置位&#xff08;set&#xff09;初始化急停互锁按时断电模块&#xff08;按下按钮&#xff0c;1s后自动断电&#xff09;一次性开关循环的几种方法并联常开点定时器循环&#xff08;串联常闭&#xff0c;断电…
阅读更多...
对Happens-Before的理解

对Happens-Before的理解

Happens-Before Happens-Before 是一种可见性模型&#xff0c;也就是说&#xff0c;在多线程环境下。原本因为指令重排序的存在会导致数据的可见性问题&#xff0c;也就是 A 线程修改某个共享变量对 B 线程不可见。因此&#xff0c;JMM 通过 Happens-Before 关系向开发人员提供…
阅读更多...
使用 kube-downscaler 降低Kubernetes集群成本

使用 kube-downscaler 降低Kubernetes集群成本

新钛云服已累计为您分享772篇技术干货 介绍 Kube-downscaler 是一款开源工具&#xff0c;允许用户定义 Kubernetes 中 pod 资源自动缩减的时间。这有助于通过减少非高峰时段的资源使用量来降低基础设施成本。 在本文中&#xff0c;我们将详细介绍 kube-downscaler 的功能、安装…
阅读更多...
Vue全局事件总线实现任意组件间通信

Vue全局事件总线实现任意组件间通信

一、安装全局事件总线 全局事件总线就像是一个工具&#xff0c;专门用于挂载自定义事件和。 想要所有的组件都能使用这个全局事件总线&#xff0c;就只有在Vue的原型身上添加一个能够绑定自定义事件的属性。 所以我们在创建Vue实例对象的时候就可以添加如下代码&#xff1a;…
阅读更多...
C语言实现将密码译回原文，并输出密码和原文

C语言实现将密码译回原文，并输出密码和原文

完整代码&#xff1a; // 有一行电文&#xff0c;已按下面规律译成密码&#xff1a; // A→Z a→z // B→Y b→y // C→X c→x /*即第 1 个字母变成第 26 个字母&#xff0c;第 i 个字母变成第&#xff08;26-i1&#xff09;个字母&#xff0c;非字母字 符不变。要求编程序将…
阅读更多...
UVa129 Krypton Factor（困难的串）

UVa129 Krypton Factor（困难的串）

1、题目 2、题意 如果一个字符串包含两个相邻的重复子串&#xff0c;则称它是“容易的串”&#xff0c;其他串称为“困难的串”。例如&#xff0c;BB、ABCDACABCAB、ABCDABCD都是容易的的串&#xff0c;而D、DC、ABDAB、CBABCBA 都是困难的串。 输入正整数 k k k 和 L L L&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023