【C++】从零开始认识多态

在这里插入图片描述

送给大家一句话：
一个犹豫不决的灵魂，奋起抗击无穷的忧患，而内心又矛盾重重，真实生活就是如此。 ​​​​ – 詹姆斯・乔伊斯 《尤利西斯》

_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ
_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ
_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ

从零开始认识多态

  • 1 前言
  • 2 什么是多态
  • 3 多态的构成
    • 3.1 协变
    • 3.2 析构函数的重写
    • 3.3 语法细节
    • 3.4 C++11 override 和 final
    • 3.5 重写（覆盖） - 重载 - 重定义（隐藏）
  • 4 多态的底层实现
    • 4.1 底层实现
    • 4.2 验证虚表
  • 5 抽象类
  • 6 多继承中的多态
    • 一般的多继承
    • 菱形继承和菱形虚拟继承
  • Thanks♪(･ω･)ﾉ谢谢阅读！！！
  • 下一篇文章见！！！

1 前言

面向对象技术（oop）的核心思想就是封装，继承和多态。通过之前的学习，我们了解了什么是封装，什么是继承。

封装就是对将一些属性装载到一个类对象中，不受外界的影响，比如：洗衣机就是对洗衣服功能，甩干功能，漂洗功能等的封装，其功能不会受到外界的微波炉影响。

继承就是可以将类对象进行继承，派生类会继承基类的功能与属性，类似父与子的关系。比如水果和苹果，苹果就有水果的特性。

接下来我们就来了解学习多态！

2 什么是多态

多态是面向对象技术（OOP）的核心思想，我们把具有继承关系的多个类型称为多态类型，通俗来讲：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：就拿刚刚结束的五一假期买票热为例，买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。同样一个行为在不同的对象上就有不同的显现。

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


#include<iostream>using namespace std;class Person 
{
public:virtual void BuyTicket() { cout << "买票->全价" << endl; }
};class Student : public Person
{
public:virtual void BuyTicket() { cout << "买票->半价" << endl; }
};void Func(Person& p)
{p.BuyTicket();
}int main()
{Person p;Student s;//同一个函数对不同对象有不同效果Func(p);Func(s);return 0;
}

比如Student继承了Person。Person对象买票全价，Student对象买票半价。我们运行看看：
在这里插入图片描述

  • 多态调用：运行时，到指定对象的虚表中找虚函数来调用（指向基类调用基类的虚函数，指向子类调用子类的虚函数）
  • 普通调用：编译时，调用对象是哪个类型，就调用它的函数。

乍一看还挺复杂，接下来我们就来了解多态的构成。

3 多态的构成

继承的情况下才有虚函数，才有多态！！！

多态构成的条件：

  1. 必须通过基类的指针或者引用调用虚函数（virtual修饰的类成员函数）
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（父子虚函数要求三同）
    • 虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数

看起来很是简单，当时其实有很多的坑！！！一不小心就会掉进去。

3.1 协变

上面我们说了多态的条件：父子虚函数要求三同。但是却有这样一个特殊情况：协变！
协变：派生类重写基类虚函数时，与基类虚函数返回值类型不同：

  1. 基类虚函数返回基类对象的指针或者引用
  2. 派生类虚函数返回派生类对象的指针或者引用

这样的情况称为协变。

#include<iostream>using namespace std;class A {};
class B : public A {};
//这里明显返回类型不同但是结构仍然正常
class Person 
{
public:virtual A* BuyTicket() { cout << "买票->全价" << endl; return nullptr; }
};class Student : public Person
{
public:virtual B* BuyTicket() { cout << "买票->半价" << endl; return nullptr; }
};

很明显派生类与基类的返回值不同（注意一定是：基类返回“基类”，派生类返回“派生类”）：
但是结果确实正常的，依然构成多态，这样的情况就称为协变！！！

3.2 析构函数的重写

析构函数在编译阶段都会转换成：destructor（），所以表面析构函数名字不同，但是实质上是一致的。这样就会构成多态。

来看正常情况下的析构：

 
#include<iostream>
using namespace std;class Person
{
public:~Person() { cout << "~Person()" << endl; }
};class Student : public Person
{
public:~Student() { cout << "~Student()" << endl; }
};
int main()
{Person p;Student s;return 0;
}

这样会正常的调用析构函数（子类析构会自动调用父类析构->先子后父）：
在这里插入图片描述
再来看：

int main()
{//Person p;//Student s;//基类可以指向基类 也可以指向派生类的基类部分Person* p1 = new Person ;//通过切片来指向对应内容Person* p2 = new Student;delete p1;delete p2;return 0;
}

如果是这样呢？
在这里插入图片描述
这样调用的析构不对啊！Student对象没有调用自身的析构函数，而是调用Person的，为什么会出现这样的现象呢？？？

这样就可能会引起一个十分严重的问题：内存泄漏

#include<iostream>using namespace std;class Person
{
public:~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:Student() { int* a = new int[100000000]; }~Student() { cout << "~Student()" << endl; }
};
int main()
{for(int i = 0; i< 100000 ; i++){Person* p2 = new Student;delete p2;}return 0;
}

如果我们在Student中申请一个空间，而析构的时候却不能调用其析构函数俩把申请的空间free这样就导致了内存泄漏！！！
在这里插入图片描述
这就十分危险了！！！
而我们希望的是指向谁就调用谁的析构：指向基类调用基类析构，指向派生类调用派生类析构。
那我们怎么做到呢 ----> 当然就是多态了！！！
那我们来看看现在满不满足多态的条件：

  1. 必须通过基类的指针或者引用调用虚函数（virtual修饰的类成员函数）
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（父子虚函数要求三同）

在编译的时候，析构函数都会变成destructor，这样满足三同！构成重写
那么我们就只需要将析构函数变为虚函数就可以了：

class Person
{
public:virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:virtual ~Student() { cout << "~Student()" << endl; }
};

来运行看看：
在这里插入图片描述
老铁 OK了！！！应该释放的空间全都释放了！！！

所以建议析构函数设置为虚函数，避免出现上述的情况。

3.3 语法细节

  1. 派生类(基类必须写)的对应函数可以不写virtual（这个语法点非常奇怪！建议写上virtual）
  2. “重写”的本质是重新写函数的实现，函数声明（包括缺省参数的值）与基类一致

来看一道面试题：
以下程序输出结果是什么（）

#include<iostream>using namespace std;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;
}

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

答案是：B 为什么呢？

  1. 首先：
    • A类与B类构成继承关系
    • func函数是虚函数（B类是派生类，可以不写virtual），并且AB 中满足三同。构成多态。
    • test函数的参数是基类指针（A* this 成员函数的默认参数），满足多态条件。
  2. 然后：
    • 主函数中调用test函数，因为B是子类，没有test函数，所以会在父类A中寻找。
    • test函数调用 func函数，参数this指向的是B类(指向谁调用谁)，所以就会调用B类的func函数B->
    • 重写的本质是对函数的实现进行重写，函数的结构部分（包括参数，缺省值，函数名，返回值等）与基类一致。所以是 1

所以就可以判断是B选项。
当然实际中不能这么写代码奥！！！会有生命危险（Doge）

3.4 C++11 override 和 final

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

  1. final：
    • 修饰类(最终类)，表示该类不能被继承。（C++98直接粗暴使用private来做到不能继承）
      class car final { };
    • 修饰虚函数，表示该虚函数不能再被继承。
      virtual void func() final { }
  2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class Car {
public:virtual void Drive() {}
};class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

3.5 重写（覆盖） - 重载 - 重定义（隐藏）

我们来区分一下这三个类似的概念：

  1. 重载 ：
    • 两个函数作用在同一作用域
    • 函数名相同，参数不同
  2. 重写（覆盖）：
    • 两个函数分别在基类作用域好派生类作用域
    • 函数名、参数、返回值都一样（协变例外）
    • 两个函数必须是虚函数！
  3. 重定义：
    • 两个函数分别在基类作用域好派生类作用域
    • 仅仅函数名相同
    • 两个基类和派生类的同名函数不是重写就是重定义

在这里插入图片描述
重定义包含重写！！！

4 多态的底层实现

4.1 底层实现

首先我们来看一下具有多态属性的类的大小：


#include<iostream>
using namespace std;class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
private:int _b = 1;char _ch = 'x';
};int main(int argc, char* argv[])
{cout << sizeof(Base) << endl;return 0;
}

Base的大小在x86环境下是12字节。这十二字节是怎么组成的呢？
首先类里面有一个虚函数表指针_vfptr：
在这里插入图片描述
只要有虚函数就会有虚表指针，这个是实现多态的关键！！！
我们来探索一下：
通过VS的调试，我们可以发现：
在这里插入图片描述
那么如何实现传基类调用基类的虚函数，传派生类调用派生类的虚函数？
当然是使用切片了！

1. 首先每个实例化的类（如果有虚函数）会有一个虚函数表。
2. 传基类调用基类的虚函数，就正常在基类虚表中寻找其对应函数
3. 传派生类，因为多态函数时基类的指针，那么就会切片出来一个基类（虚函数表是派生类的），那么就会在派生类虚表调用对应虚函数。

这样就实现了执行谁就调用谁！！！
运行过程中去虚表中找对应的虚函数调用。具体的汇编语言实现还是比较直白的。

注意同类型的虚表是一样的！！！

  • 满足多态，那么运行时汇编指令会去指向对象的虚表中找对应虚函数进行调用！！！
  • 不满足多态，编译链接时直接根据对象类型，确定调用的函数，确定地址！！！

这里需要分辨一下两个概念：虚表与虚基表

  • 虚表：虚函数表，存的是虚函数，用来形成多态！！！
  • 虚基表：存的是距离虚基类的位置的偏移量，用来解决菱形继承的数据冗余和二义性！！！

注意：虚函数不是存在虚表中的 , 虚表中存的是虚函数的指针。那虚函数存在哪里呢？
来验证一下：

class Person
{
public:virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:virtual ~Student() { cout << "~Student()" << endl; }
};int main()
{int i = 0;static int j = 1;int* p1 = new int;const char* p2 = "xxxxxxxx";printf("栈:%p\n", &i);printf("静态区:%p\n", &j);printf("堆:%p\n", p1);printf("常量区:%p\n", p2);Person p;Student s;Person* p3 = &p;Student* p4 = &s;printf("Person虚表地址:%p\n", *(int*)p3);printf("Student虚表地址:%p\n", *(int*)p4);return 0;
}

运行可以看到：
在这里插入图片描述
虚表地址与常量区最接近，那可以推断出虚表储存在常量区！！！

4.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; }
private:int b;
};

梳理一下结构：

  1. Base作为基类 ， Derive作为派生类！
  2. 派生类Derive重写了func1函数，构成多态！
  3. 其余函数均不构成多态。

然后我们来探索一下：

int main()
{Base b;Derive d;return 0;
}

通过监视窗口可以查看一下虚表的内容：
在这里插入图片描述

这是VS调试的一点BUG，导致监视中派生类的虚表不能显示。在内存窗口里存在4个函数指针，接下来我们来验证一下他们是不是对应的虚函数。

虚函数表本质是一个函数指针数组！
那么如何定义一个函数指针和函数指针数组呢？

//这样定义 
//返回值是void 所以写void
void(*p)( //函数里面的参数 );
void(*p[10])( //函数里面的参数 )

当然可以使用typedef来简化（这个typedef也很特别）

typedef void(*VFPTR)();
VFPTR p1;
VFPTR p2[10];

那么如果我们想要打印出虚表，我们可以设置一个函数：

//因为是函数指针数组，所以传参是函数指针的指针（int arr[10] 传入 int*）。
void PrintVFT(VFPTR* vft )
{for(size_t i = 0 ; i < 4 ; i++){printf("%p\n" , vft[i]);}}

这样就可以打印了，那么现在就需要解决如何获取虚表的首地址。虚表首地址是类的头4个字节（x86环境），我们如何取出来了呢?
直接把类强转为int类型不就4个字节了吗！？但是没有联系的类型是不能强转的。那怎么办呢？？？
C/C++中指针可以直接互相强转（BUG级别的操作！！！）,整型与指针也可以互相转换。

VFPTR* p =  (VFPTR*) *( (int*)&d );//这样就变成4个字节了！
  1. &d 是取类的指针
  2. （int*)&d将类指针强转为int*指针！
  3. *( (int*)&d ) 将 int * 解引用为int
  4. (VFPTR*) *( (int*)&d ) 将int转换为VFPTR*,取到虚表首地址！！！

那么我们来验证一下：

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; }
private:int b;
};
typedef void(*VFPTR)();void PrintVFT(VFPTR* vft)
{for (size_t i = 0; i < 4; i++){printf("%p  ->", vft[i]);(*(vft[i]))();}}int main()
{Base b;Derive d;VFPTR* p = (VFPTR*)*((int*)&d);//这样就变成4个字节了！PrintVFT(p);return 0;
}

来看：
在这里插入图片描述
这样就成功获取到了虚标的内容，验证了虚表的内容中存在4个虚函数！！！

5 抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类）

抽象类不能实例化出对象。派生类继承后也不能实例化出对象。只有重写纯虚函数，派生类才能实例化出对象。

纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

//抽象类
class Car
{
public: //纯虚函数virtual void Drive() = 0;
};int main()
{Car c;return 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();
}
int main()
{Test();return 0;
}

抽象类与override关键字的区别：

  1. 抽象类间接强制了派生类必须进行虚函数重写
  2. override是在已经重写的情况下，帮助进行重写的语法检查

6 多继承中的多态

多继承我们讲过，是一种很危险的继承，很容易导致菱形继承，引起数据冗余和二义性。那么我们再来看看多态在多继承中是然如何实现的 。

一般的多继承

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

分析一下继承关系：

  1. 有两个基类：Base1类与Base2类
  2. Derive继承两个基类，对func1函数进行了重写构成多态

来看看Derive类的大小是多大：
我们分析一下:Base1类应该有一个虚表指针和一个int类型数据，所以应该为8字节。Base2同理8字节。
那么Derive由于多继承的缘故会包含两个基类，所以应该为16 + 4 = 20字节：
在这里插入图片描述
运行一下，看来我们的分析没有问题！也就是有两张虚表，func1重写会改变两个虚表（因为两个基类都有func1函数），func3是放在Base1的虚表中的，通过虚表验证：

typedef void(*VFPTR) ();void PrintVTable(VFPTR vTable[])
{cout << " 虚表地址>" << vTable << endl;for (int i = 0; vTable[i] != nullptr; ++i){printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);VFPTR f = vTable[i];f();}cout << endl;
}
int main()
{Derive d;VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);PrintVTable(vTableb1);//通过切片获取Base2 b2 = d;VFPTR* vTableb2 = (VFPTR*)(*(int*)&b2);PrintVTable(vTableb2);return 0;
}

运行看看：
在这里插入图片描述
多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

菱形继承和菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。这里简单叙述一下：
先看菱形继承：

class A
{
public:virtual void func1() { cout << "A::func1" << endl; }int _a;
};class B : public A
{
public:virtual void func2() { cout << "B::func2" << endl; }int _b;
};class C : public A
{
public:virtual void func3() { cout << "C::func3" << endl; }int _c;
};
class D : public B, public C
{
public:virtual void func4() { cout << "D::func4" << endl; }int _d;
};
int main()
{D d;cout<< sizeof(d) << endl;return 0;
}

先来看一下这个类有多大：
在这里插入图片描述

28 字节，这个是怎么得到的，来分析一下：

  1. A类有一个虚函数表指针和一个整型 ，应该是8字节
  2. B类继承于A类 ，包含A类的内容，B的虚函数储存在A的虚表中，所以B类一个为8 + 4 = 12
  3. C类同理
  4. D类继承于B类和C类，那么就包含B类与C类，D类的虚函数储存在B类的虚表中（A的虚表）

在这里插入图片描述
通过内存来验证一下：
在这里插入图片描述
可以看到只有两个虚表指针。所以菱形继承和多继承类似！

再来看菱形虚拟继承：
在这里插入图片描述
这个36字节是怎么得到的？？？

  1. 首先菱形虚拟继承会把共同的基类提取出来（也就是A被提出来了），那么B类就会有一个虚基表指针来指向这个提前出来的A类。所以B类大小为4 (虚表指针) + 4（虚基表指针） + 4（int数据） = 12
  2. C类同理，那么现在就有12 (B类) + 12（C类） + 4（A类的int）+ 4(D类的int) = 32
  3. 啊？？？这才32字节，剩下的4字节是什么？难不成还有一个虚表指针？！是的，A 里面还有一个虚表指针！！！

来看内存：
在这里插入图片描述
很明显，在A类中还有一个虚表指针！！！真滴复杂！
所以应该是：
12 (B类) + 12（C类） + 8（A类的int）+ 4(D类的int) = 36
那为什么A会有一个虚表指针，而不是D类有！？

  1. 首先派生类的成员是不会有虚表指针的，虚表指针都在基类的部分中！！！

  2. 我们这四个类都有自身的虚函数

    • 菱形继承中，B类与C类都继承于A类，所以BC是派生类，就不需要有独立的虚表指针，而是与A类共用。父类有了就与父类共用，父类没有才会独立创建。
    • 菱形虚拟继承中，B类与C类都虚拟继承于A类，A类被单独出去了，那么B类与C类的虚函数就不能放在A类里，因为A类是共享的，放进去就会产出问题！所以BC会独立创建一个虚表指针。

  3. 总结： 子类有虚函数，继承的父类有虚函数就有虚表，子类不需要单独建立虚表！！！如果父类是共享的，无论如何都有创建独立的虚表！！！

注意：虚基表中储存两个值：第一个是距离虚表位置的偏移量，第二个是距离基类位置的偏移量

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

ReactFlow的ReactFlow实例事件传参undefined处理状态切换

ReactFlow的ReactFlow实例事件传参undefined处理状态切换

1.问题 ReactFlow的ReactFlow实例有些事件我们在不同的状态下并不需要&#xff0c;而且有时候传参会出现其它渲染效果&#xff0c;比如只读状态下我们不想要拖拉拽onEdgesChange连线重连或删除的功能。 2.思路 事件名称类型默认值onEdgesChange(changes: EdgeChange[]) >…
阅读更多...
21物联1班常用网络扫描

21物联1班常用网络扫描

网络扫描 1.网络扫描概述2.网络扫描步骤及分类具体步骤 1.网络扫描概述 网络安全扫描技术是一种基于Internet远程检测目标网络或本地主机安全性脆弱点的技术。通过网络安全扫描&#xff0c;系统管理员能够发现所维护的Web服务器的各种TCP/IP端口的分配、开放的服务、Web服务软件…
阅读更多...
Unity 性能优化之UI和模型优化（九）

Unity 性能优化之UI和模型优化（九）

提示&#xff1a;仅供参考&#xff0c;有误之处&#xff0c;麻烦大佬指出&#xff0c;不胜感激&#xff01; 文章目录 前言一、选择UI二、UGUI的优化1.Raycast Target2.UI控件的重叠3.TextMeshPro 二、模型优化1.Model选项卡Mesh CompressionRead/Write Enabled设置Optimize Ga…
阅读更多...
【JVM】内存结构

【JVM】内存结构

内存结构 Java 虚拟机定义了若干种程序运行期间会使用到的运行时数据区&#xff0c;其中有一些会随着虚拟机启动而创建&#xff0c;随着虚拟机退出而销毁。另外一些则是与线程一一对应的&#xff0c;这些与线程一一对应的数据区域会随着线程开始和结束而创建和销毁。 线程私有…
阅读更多...
21物联1班常用网络命令

21物联1班常用网络命令

常用网络命令 ipconfig&#xff08;配置&#xff09;ping(测试)命令1&#xff1a;ping 172.16.0.12&#xff1a;ping ip -t3&#xff1a;ping ip -l 3000&#xff08;注意每个之间都存在空格&#xff09;4&#xff1a;ping ip -n count netstat&#xff08;网络&#xff09;命令…
阅读更多...
技术分享-上海泗博MPI转以太网模块MPI-131实现Node-RED直接访问西门子PLC数据

技术分享-上海泗博MPI转以太网模块MPI-131实现Node-RED直接访问西门子PLC数据

上海泗博自动化MPI-131是一款用于西门子S7系列PLC&#xff08;包括S7-200、S7-300、S7-400&#xff09;以及西门子数控机床&#xff08;如840D、840DSL等&#xff09;的以太网通讯模块&#xff0c;无需编程&#xff0c;即插即用&#xff0c;支持通过模块上下载PLC程序和数据监控…
阅读更多...
【busybox记录】【shell指令】shuf

【busybox记录】【shell指令】shuf

目录 内容来源&#xff1a; 【GUN】【shuf】指令介绍 【busybox】【shuf】指令介绍 【linux】【shuf】指令介绍 使用示例&#xff1a; 打乱内容 - 默认输出 打乱内容 - 最多输出n行 打乱内容 - 将输出写入文件 打乱内容 - 重复输出 打乱内容 - 打乱本条指令的参数 打…
阅读更多...
Django调用MTP服务器给指定邮箱发送邮件

Django调用MTP服务器给指定邮箱发送邮件

Django调用MTP服务器发送邮箱 邮箱的激活链接含有用户数据不能直接发送需要对其进行加密 发送邮箱是借助SMTP服务器进行中转 一. 配置SMTP服务中的邮箱信息以及激活链接 1. 配置邮箱权限 打开网易邮箱设置点击POP3 开启选项 注 : 在打开的过程中会弹出授权密码一点要保存 …
阅读更多...
OpenAI泄密者加入马斯克xAI，技术版图扩张；OpenAI推出可识别DALL·E 3图像的AI检测工具

OpenAI泄密者加入马斯克xAI，技术版图扩张；OpenAI推出可识别DALL·E 3图像的AI检测工具

&#x1f989; AI新闻 &#x1f680; OpenAI泄密者加入马斯克xAI&#xff0c;技术版图扩张 摘要&#xff1a;最近&#xff0c;曾在OpenAI任职并被指控泄露机密的Pavel Izmailov迅速加入了马斯克旗下的xAI团队&#xff0c;成为研究员。在加入之前&#xff0c;Izmailov因涉嫌泄…
阅读更多...
卸载系统自带APP

卸载系统自带APP

Firefly RK3588 android 12自动多个系统软件&#xff0c;无法从UI界面进行手动删除。因此&#xff0c;考虑使用shell指令进行处理。 系统自动APP大多都安装在system/app目录下&#xff0c;且该目录多为只读。因此采用如下步骤&#xff0c; //Shell su adb shell su //重新挂载…
阅读更多...
Android 网络请求 实现

Android 网络请求 实现

Android 网络请求 实现 一、背景 在Android开发中，网络请求是一个非常常见的需求。应用程序可能需要与远程服务器通信来获取数据、上传文件、验证用户身份等等。背景下，Android应用通常会面临以下几个主要情况和挑战： ①数据交互： 许多应用程序需要从服务器获取数据，例…
阅读更多...
fabric搭建生产网络

fabric搭建生产网络

fabric搭建生产网络 一、生成组织结构与身份证书 解包 hyperledger-fabric-linux-amd64-2.5.0.tar.gz 1.1、crypto-config.yaml配置文件 ./bin/cryptogen showtemplate > crypto-config.yaml 将crypto-config.yaml内容修改为&#xff1a; # -------------------------…
阅读更多...
maven-test不通过导致无法打包

maven-test不通过导致无法打包

背景 别人写的一个test包&#xff0c;没有测试通过&#xff0c;导致最后没有打包成功 解决方案 package生命周中不要勾选test
阅读更多...
2024-05-08 精神分析-对损失和挫败的强烈易感性-分析

2024-05-08 精神分析-对损失和挫败的强烈易感性-分析

摘要: 对损失的强烈的易感性&#xff0c;会在遭受损失或者挫败的时候&#xff0c;表现的极其敏感&#xff0c;这个过程主要是在创业的过程中更加强烈的表现并带来巨大的影响。必须要对其进行彻底的分析&#xff0c;并保持对此行为的长期的警惕。 所谓前事不忘后事之师&#x…
阅读更多...
unity基础(二)

unity基础(二)

debug方法 Debug.Log(" 一般日志 ");Debug.LogWarning(" 警告日志 ");Debug.LogError(" 错误日志 ");// Player Informationstring strPlayerName "Peter";int iPlayerHpValue 32500;short shPlayerLevel 10;long lAdvantureExp 1…
阅读更多...
Linux入门攻坚——22、通信安全基础知识及openssl、CA证书

Linux入门攻坚——22、通信安全基础知识及openssl、CA证书

Linux系统常用的加解密工具&#xff1a;OpenSSL&#xff0c;gpg&#xff08;是pgp的实现&#xff09; 加密算法和协议&#xff1a; 对称加密&#xff1a;加解密使用同一个秘钥&#xff1b; DES&#xff1a;Data Encryption Standard&#xff0c;数据加密标准&…
阅读更多...
web 基础之 HTTP 请求

web 基础之 HTTP 请求

web 基础 网上冲浪 就是在互联网(internet)上获取各种信息&#xff0c;进行工作&#xff0c;或者娱乐&#xff0c;他的英文表示surfing the Internet&#xff0c;因 “surfing”d的意思是冲浪&#xff0c;即成为网上冲浪&#xff0c;这是一种形象说法&#xff0c; 也是一个非…
阅读更多...
欧鹏RHCE 第四次作业

欧鹏RHCE 第四次作业

unit4.web服务的部署及高级优化方案 1. 搭建web服务器要求如下&#xff1a; 1.web服务器的主机ip&#xff1a;172.25.254.100 2.web服务器的默认访问目录为/var/www/html 默认发布内容为default‘s page 3.站点news.timinglee.org默认发布目录为/var/www/virtual/timinglee.org…
阅读更多...
文件各种上传，离不开的表单 [html5]

文件各种上传，离不开的表单 [html5]

作为程序员的我们&#xff0c;经常会要用到文件的上传和下载功能。到了需要用的时候&#xff0c;各种查资料。有木有..有木有...。为了方便下次使用&#xff0c;这里来做个总结和备忘。 利用表单实现文件上传 最原始、最简单、最粗暴的文件上传。 前端代码&#xff1a; //方…
阅读更多...
如何更好地使用Kafka? - 故障时解决

如何更好地使用Kafka? - 故障时解决

要确保Kafka在使用过程中的稳定性&#xff0c;需要从kafka在业务中的使用周期进行依次保障。主要可以分为&#xff1a;事先预防&#xff08;通过规范的使用、开发&#xff0c;预防问题产生&#xff09;、运行时监控&#xff08;保障集群稳定&#xff0c;出问题能及时发现&#…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023