【C++】多态深入分析

目录

一,多态的原理

1,虚函数表与虚函数表指针

2,原理调用

3,动态绑定与静态绑定

二,抽象类

三,单继承和多继承关系的虚函数表

1,单继承中的虚函数表

2,多继承中的虚函数表

3,菱形继承、菱形虚拟继承

四,继承和多态常见的经典题型

1,概念逻辑考察

2,问答题


一,多态的原理

1,虚函数表与虚函数表指针

        虚函数表:存放虚函数指针的表,简称虚表。            虚函数表指针:指向虚函数表的指针。

        一个含有虚函数的类中,至少都有一个虚函数表指针__vfptr,因为虚函数的地址要被放到虚函数表中,而虚函数表本质是一个存虚函数指针的指针数组,一般情况这个数组最后面放了一个nullptr。注意:类似于友元函数、静态函数不能为虚函数,因为它们都不属于类,即都不是类的成员函数,无法放到虚函数表中。

        派生类的虚表生成一共有以下步骤:a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数,用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后(注意:在vs监视窗口下可能在虚表中看不到新增的虚函数,但是通过内存窗口下可以观察到)。

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void Fun1() {   //虚函数,地址存放到虚表中
        cout << "Base::Fun1()" << endl;
    }
    virtual void Fun2() {  //虚函数,地址存放到虚表中
        cout << "Base::Fun2()" << endl;
    }
    void Fun3() {  //不是虚函数,地址没有存放到虚表中
        cout << "Base::Fun3()" << endl;
    }
private:
    int _a = 1;
    char _ch = 'a';
};
class Derive : public Base
{
public:
    virtual void Func1() {  //虚函数,与子类后成重写,将子类的Func1覆盖
        cout << "Derive::Func1()" << endl;
    }
private:
    int _d = 2;
};
int main()
{
    Base bb;
    Derive dd;
    return 0;
}

原理图如下:

        我们通过以上知识来计算下基类与派生类的存储大小。观察以下代码:

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void Fun1() {
        cout << "Base::Fun1()" << endl;
    }
    virtual void Fun2() {
        cout << "Base::Fun2()" << endl;
    }
    void Fun3() {
        cout << "Base::Fun3()" << endl;
    }
private:
    int _a = 1;
    char _ch = 'a';
};
class Derive : public Base
{
public:
    virtual void Func1()
    {
        cout << "Derive::Func1()" << endl;
    }
private:
    int _d = 2;
};
int main()
{
    //因为有了虚函数,所以这里多了虚函数表指针。虚表指针也存储在类中
    cout << sizeof(Base) << endl; //输出12

    cout << sizeof(Derive) << endl;  //输出16
    return 0;
}

        这里说明一下,虚表指针存放的位置与平台有关,有些平台可能会放到对象的最后面,有些平台可能会放到对象的最前面。这里的测试是放在对象的前面且是32位机器,也就是说虚表指针占用4字节空间,然后这里再根据空间对齐规则,计算出总空间大小。

        下面,我们研究下虚表存放的区域(注意:这里研究的不是虚表指针存放的区域,即研究虚表指针指向的地址,不是虚表指针本身的地址,这里不要搞错)。这里可以使用对比法来观察。具体做法是先输出各大区域的代表地址,然后输出虚表地址(即虚表指针),通过对比观察与哪个区域代表地址相差最小的就是存储在哪块区域,因为各大区域的地址相差非常大。我们先创造以下类

class Base
{
public:
    virtual void Fun1() {
        cout << "Base::Fun1()" << endl;
    }
    virtual void Fun2() {
        cout << "Base::Fun2()" << endl;
    }
    void Fun3() {
        cout << "Base::Fun3()" << endl;
    }
private:
    int _a = 1;
    char _ch = 'a';
};

内部结构图如下: 

 #include <iostream>
using namespace std;
class Base
{
public:
    virtual void Fun1() {
        cout << "Base::Fun1()" << endl;
    }
    virtual void Fun2() {
        cout << "Base::Fun2()" << endl;
    }
    void Fun3() {
        cout << "Base::Fun3()" << endl;
    }
private:
    int _a = 1;
    char _ch = 'a';
};
int main()
{
    Base bb;
    //创造熟为认知的四大区域的代表
    int a = 0;
    int* b = new int;
    static int c = 1;
    const char* d = "a";
    fprintf(stdout, "栈区: %p\n", &a);
    fprintf(stdout, "堆区: %p\n", b);
    fprintf(stdout, "静态区(数据段): %p\n", &c);
    fprintf(stdout, "常量区(代码段): %p\n", d);
    //因为在32位下,内存中一个地址占用四个字节,所以这里解引用需解出bb对象开头的前四字节内容。这里可转换成int*,一次性可解引用出4个字节
    Base* pb = &bb;
    fprintf(stdout, "虚表存放区域: %p\n", *(int*)pb);  //地址与常量区代表地址最相近,即虚表存放在常量区中
    return 0;
}

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

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

int main(int argc, char* argv[])
{
    A* p = new B;
    p->test();
    //以次输出A->1  B->0  B->1
    return 0;
}

        首先,当new B时先调用父类A的构造函数执行func时,由于此时还处于对象构造阶段,多态机制还没有生效,所以,此时执行的func函数为父类的func函数,输出A->1。构造完父类后执行子类构造函数,又要调用func,同理执行子类的func,输出B->0。当构造函数结束后再次调用,多态机制生成,后面就正常调用。

测试二:

#include <iostream>
using namespace std;
class A
{
public:
    A() 
    : m_iVal(0) { 
        test();
    }
    virtual void func() {
        std::cout << m_iVal << " ";
    }
    void test() {
        func();
    }
public:
    int m_iVal;
};
class B : public A
{
public:
    B() { 
        test();
    }
    virtual void func()
    {
        ++m_iVal;
        std::cout << m_iVal << " ";
    }
};
int main()
{
    //以下输出0 0 1
    A a;
    B b; //当调用完A的构造后,A中的基表就确定了。
    //子类B的虚表是拷贝父类的虚表内容,也就是说子类调用完构造函数之后多态机制就已经生成
    return 0;
}

测试三:

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void Fun1() {
        cout << "Base::Fun1()" << endl;
    }
    virtual void Fun2() {
        cout << "Base::Fun2()" << endl;
    }
    void Fun3() {
        cout << "Base::Fun3()" << endl;
    }
private:
    int _a = 1;
    char _ch = 'a';
};
class Derive : public Base
{
public:
    virtual void Func1()
    {
        cout << "Derive::Func1()" << endl;
    }
private:
    int _d = 2;
};
int main()
{
    Base bb1;
    Base bb2;
    Base bb3;

    Derive dd1;
    Derive dd2;
    Derive dd3;
    return 0;
}

内部结构图:

3,动态绑定与静态绑定

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

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

        以上两个概念只需了解即可。


二,抽象类

        在虚函数的后面写上 =0 ,则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口 类),抽象类不能实例化出对象。派生类继承后也不能实例化出对象,只有重写纯虚函数,派生 类才能实例化出对象。也就是说纯虚函数规范了派生类必须重写。

#include <iostream>
using namespace std;
class Car //抽象类
{
public:
    virtual void Drive() = 0 {  //纯虚函数
        cout << "Car" << endl;
    };
};
class Benz : public Car
{
public:
    virtual void Drive() //重写抽象类的纯虚函数,可以被实例化
    {
        cout << "Benz" << endl;
    }
};
class BMW : public Car
{    };
int main()
{
    //重写纯虚函数,实例化成功
    Benz a;
    a.Drive();
    //没有重写纯虚函数,实例化报错
    BMW b;
    return 0;
}

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


三,单继承和多继承关系的虚函数表

1,单继承中的虚函数表

        之前说过,在vs监视窗口下可能在虚表中看不到新增的虚函数,这里我们实践下,如下:

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

        观察上图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数,也可以认为是它的一个小bug。那么我们如何查看d的虚表呢?下面我们使用代码打印出虚表中的函数。

#include <iostream>
using namespace std;
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) (); //声明函数指针VFPTR
void PrintVTable(VFPTR vTable[]) {
    for (int i = 0; vTable[i] != nullptr; ++i) {  //vs下的虚表最后一个存储单元为nullptr
        cout << "vTable[" << i << "]: " << vTable[i] << endl;
    }    
    cout << endl;
}
int main()
{
    Base b;
    Derive d;
    VFPTR* vTableb = (VFPTR*)(*(int*)&b);  //用函数二级指针来表示函数指针数组
    PrintVTable(vTableb);
    VFPTR* vTabled = (VFPTR*)(*(int*)&d);  //与上同理
    PrintVTable(vTabled);
    return 0;
}

        这里需说明的是这个打印虚表的代码经常会崩溃,因为编译器有时对虚表的处理不干净,虚表最后面没有放nullptr,导致越界,这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案,再编译就好了。

2,多继承中的虚函数表

        在多继承中,要谨记派生类的虚表内容是将基类中的虚表内容拷贝一份到派生类虚表中。从这里不难发现,在多继承中,派生类不止有一个虚表,即继承多少个类就有多少个虚表。当派生类的虚函数往虚表中添加地址时,会往第一个继承基类虚表中添加。当派生类对象/指针/引用赋值给基类时,这里会将基类以及包含基类虚表的那一部分一并切割。

#include <iostream>
using namespace std;
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;
};
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;
    cout << sizeof(Derive) << endl; //输出20,因为继承了两个父类,有两个虚表

    //这里的p1和p2的值不一样,因为这里要发生切片,将父类包含特有的子类切出来
    Base1* p1 = &d;  //切出Base1
    Base2* p2 = &d;  //切出Base2
    
    VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    PrintVTable(vTableb1);
    //这里要先跳转到包含Base2的虚表上,然后找到虚表指针
    VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1))); 
    PrintVTable(vTableb2);
    return 0;
}

        观察下面结构图可以看出:多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

3,菱形继承、菱形虚拟继承

        实际中我们不建议设计出菱形继承及菱形虚拟继承,一方面太复杂容易出问题,另一方面使用这样的模型访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承的虚表我们可不做研究,一般我们也不需要研究清楚,因为实际中很少用。我们只需知道,菱形继承往多继承方向理解,菱形虚拟继承就很复杂了,这里有很多问题,不必深思。


四,继承和多态常见的经典题型

        继承与多态这方面有许多坑,由于内部结构多变,通常可设计出一些逻辑上的运算。这里我们来一一观察这方面的典型问题和经典面试问题。

1,概念逻辑考察

1. 下面哪种面向对象的方法可以让你变得富有( )
        A: 继承 B : 封装 C : 多态 D : 抽象

2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关,
而对方法的调用则可以关联于具体的对象。
        A : 继承 B : 模板 C : 对象的自身引用 D : 动态绑定

3. 面向对象设计中的继承和组合,下面说法错误的是?( 
        A:继承允许我们覆盖重写父类的实现细节,父类的实现对于子类是可见的,是一种静态复
用,也称为白盒复用
        B:组合的对象不需要关心各自的实现细节,之间的关系是在运行时候才确定的,是一种动
态复用,也称为黑盒复用
        C:优先使用继承,而不是组合,是面向对象设计的第二原则
        D:继承可以使子类能自动继承父类的接口,但在设计模式中认为这是一种破坏了父类的封
装性的表现

4. 以下关于纯虚函数的说法, 正确的是( )
        A:声明纯虚函数的类不能实例化对象         B:声明纯虚函数的类是虚基类
        C:子类必须实现基类的纯虚函数         D:纯虚函数必须是空函数

5. 关于虚函数的描述正确的是( )
        A:派生类的虚函数与基类的虚函数具有不同的参数个数和类型                                                        B:内联函数不能是虚函数
        C:派生类必须重新定义基类的虚函数                                                                                                D:虚函数可以是一个static型的函数

6. 关于虚表说法正确的是( D )             
        A:一个类只能有一张虚表
        B:基类中有虚函数,如果子类中没有重写基类的虚函数,此时子类与基类共用同一张虚表
        C:虚表是在运行期间动态生成的
        D:一个类的不同对象共享该类的虚表

7. 假设A类中有虚函数,B继承自A,B重写A中的虚函数,也没有定义任何虚函数,则( D
        A:A类对象的前4个字节存储虚表地址,B类对象前4个字节不是虚表地址
        B:A类对象和B类对象前4个字节存储的都是虚基表的地址
        C:A类对象和B类对象前4个字节存储的虚表地址相同
        D:A类和B类虚表中虚函数个数相同,但A类和B类使用的不是同一张虚表

8. 下面程序输出结果是什么? ( A )         

#include <iostream>
using namespace std;
class A {
public:
    A(const char* s) { cout << s << endl; }
    ~A() {}
};
class B :virtual public A
{
public:
    B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class C :virtual public A
{
public:
    C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class D :public B, public C
{
public:
    D(const char* s1, const char* s2, const char* s3, const char* s4) :B(s1, s2), C(s1, s3), A(s1)
    {
        cout << s4 << endl;
    }
};
int main() {
    D* p = new D("class A", "class B", "class C", "class D");
    delete p;
    return 0;
}     
//菱形虚拟继承由于只有一个A,所以当开始调用D的构造函数时,会首先调用A的析构函数,在B、C中不会调用A的构造函数。

        A:class A class B class C class D         B:class D class B class C class A
        C:class D class C class B class A         D:class A class C class B class D

9. 多继承中指针偏移问题?下面说法正确的是( C )     

class Base1 { public:  int _b1; };
class Base2 { public:  int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main() {
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

        A:p1 == p2 == p3         B:p1 < p2 < p3         C:p1 == p3 != p2         D:p1 != p2 != p3

10. 以下程序输出结果是什么( B

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: 以上都不正确

2,问答题

1. 什么是多态?答:多态分为静态多态和动态多态,静态多态是编译器在编译时就能确定函数调用的是哪个实现,如:函数重载,而动态多态则是在运行时才能确定,如:派生类重写虚函数时的调用。

2. 什么是重载、重写(覆盖)、重定义(隐藏)?答:参考以上图片内容

3. 多态的实现原理?答:多态的实现原理主要依赖于虚函数表和虚函数表指针,通过虚函数表指针找到虚函数,在运行时进行动态绑定,以具体确定调用哪个函数。

4. inline函数可以是虚函数吗?答:可以,不过编译器就忽略inline属性,这个函数就不再是
inline,因为inline修饰后,若编译器看成内联函数,那么此函数是没有地址的,无法存入虚表中,而虚函数是要放到虚表中去。

5. 静态成员可以是虚函数吗?答:不能,因为类中存储的数据一切调用都需通过this指针,包括虚函数表。静态成员函数没有this指针,使用 类型::成员函数 的调用方式无法访问虚函数表,所以静态成员函数无法放进虚函数表。

6. 构造函数可以是虚函数吗?答:不能,因为对象中的虚函数表指针是在构造函数初始化列表
阶段才初始化的。

7. 析构函数可以是虚函数吗?什么场景下析构函数是虚函数?答:可以,并且最好把基类的析
构函数定义成虚函数。因为这里可能存在内存泄漏问题。当使用基类指针指向派生类地址空间时,由于切割,指针指向的是派生类中基类的地址,所以这里结束时默认调用基类析构函数,不会调用派生类析构函数,这将会导致派生类中部分空间没有释放,导致内存泄漏问题。因此,这里需使用虚函数,使其调用派生类的析构函数。

8. 对象访问普通函数快还是虚函数更快?答:首先如果是普通调用,是一样快的。如果是多态调用,则普通函数快,因为多态调用构成多态,运行时调用虚函数需要到虚函数表中去查找指定地址才能调用,而普通函数直接调用。

9. 虚函数表是在什么阶段生成的,存在哪的?答:虚函数表是在编译阶段就生成的,一般情况
下存在代码段(常量区)的。

10. C++菱形继承的问题?虚继承的原理?答:菱形继承有二义性和数据冗余的问题。在继承前加上关键字virtual的继承是虚继承。虚继承是一种解决多重继承中菱形继承问题的方法(注意这里不要把虚函数表和虚基表搞混了。)

11. 什么是抽象类?抽象类的作用?答:包含纯虚函数(即在虚函数的后面写上 =0 )的类叫做抽象类。作用:抽象类强制重写了虚函数,另外抽象类体现出了接口继承关系。

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

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

相关文章

内网搭建mysql8.0并搭建主从复制详细教程!!!

一、安装mysql 1.1 mysql下载链接&#xff1a; https://downloads.mysql.com/archives/community/ 1.2 解压包并创建相应的数据目录 tar -xvf mysql-8.2.0-linux-glibc2.28-x86_64.tar.xz -C /usr/local cd /usr/local/ mv mysql-8.2.0-linux-glibc2.28-x86_64/ mysql mkdir…

Python绘图-9饼图(上)

饼图&#xff08;Pie Chart&#xff09;是一种用于表示数据分类和相对大小的可视化图形。在饼图中&#xff0c;整个圆形代表数据的总和&#xff0c;而圆形内的各个扇形则代表不同的分类或类别&#xff0c;扇形的面积大小表示该类别在整体中所占的比例。饼图通常用于展示数据的分…

Window部署Jaeger

参考&#xff1a;windows安装使用jaeger链路追踪_windows安装jaeger-CSDN博客 下载&#xff1a;Releases jaegertracing/jaeger GitHub Jaeger – Download Jaeger 目录 1、安装nssm 2、安装运行 elasticsearch 3、安装运行 3.1部署JaegerAgent 3.2部署JaegerCollec…

【全志D1-H 哪吒开发板】Debian系统安装调教和点灯指南

全志D1-H开发板【哪吒】使用Deabian系统入门 特别说明&#xff1a; 因为涉及到操作较多&#xff0c;博文可能会导致格式丢失 其中内容&#xff0c;会根据后续使用做优化调整 目录&#xff1a; 参考资料固件烧录启动调教点灯问题 〇、参考资料 官方资料 开发板-D1开发板【…

C++:函数模板整理

函数模板: 找到函数相同的实现思路&#xff0c;区别于函数的参数类型。 使用函数模板使得函数可容纳不同类型的参数实现函数功能&#xff0c;而不是当类型不同时便编译大量类型不同的函数&#xff0c;产生大量重复代码和内存占用 函数模板格式&#xff1a; template<typ…

[Vulnhub]靶场 Red

kali:192.168.56.104 主机发现 arp-scan -l # arp-scan -l Interface: eth0, type: EN10MB, MAC: 00:0c:29:d2:e0:49, IPv4: 192.168.56.104 Starting arp-scan 1.10.0 with 256 hosts (https://github.com/royhills/arp-scan) 192.168.56.1 …

ARM64汇编02 - 寄存器与指令基本格式

最近的文章可能会有较多修改&#xff0c;请关注博客哦 异常级别 ARMv8处理器支持4种异常等级&#xff08;Exception Level&#xff0c;EL&#xff09;。 EL0 为非特权模式&#xff0c;用于运行应用程序&#xff0c;其他资源访问受限&#xff0c;权限不够。 EL1 为特权模式&…

【王道操作系统】ch1计算机系统概述-06虚拟机

文章目录 【王道操作系统】ch1计算机系统概述-06虚拟机01传统计算机02虚拟机的基本概念&#xff08;1&#xff09;第一类虚拟机管理程序&#xff08;2&#xff09; 第二类虚拟机管理程序&#xff08;3&#xff09; 两类虚拟机管理程序的对比 【王道操作系统】ch1计算机系统概述…

效果炸裂、刷爆各大视频网站的EMO到底是怎么做到的?

文章链接&#xff1a;https://arxiv.org/abs/2402.17485 今天分享的工作是刷爆各大视频平台的EMO的背后的工作原理。提出的初衷是着手解决增强发言者的头部特写视频生成中的现实感和表现力的挑战&#xff0c;重点关注音频提示与面部动作之间的动态和微妙关系。传统技术具有局限…

【HarmonyOS】鸿蒙开发之Stage模型-UIAbility的启动模式——第4.4章

UIAbi lity的启动模式简介 一共有四种:singleton,standard,specified,multion。在项目目录的:src/main/module.json5。默认开启模式为singleton(单例模式)。如下图 singleton&#xff08;单实例模式&#xff09;启动模式 每个UIAbility只存在唯一实例。任务列表中只会存在一…

测试管理进阶 | 量力而行:避免成为替罪羊

职场中,我们常常面临是否帮助他人的抉择。尽管善良是美德,但过度的好人卡可能会给自己带来麻烦。本文将探讨如何在职场中量力而行,避免成为替罪羊,以及如何保持高效和合理的职责划分。 我们在工作中常常会遇到一些需要帮助他人的情况,作为团队的一员,我们希望能够积极地协…

六、继承(一)

1 继承的引入 以往我们想分别实现描述学生、老师的类&#xff0c;可能会这样子做&#xff1a; class Student {string _name;string _number;int _tel;int id;string _address;int _age; }; class Teacher {string _name;int _level;int _tel;int id;string _address;int _ag…

【归并排序】 详细解析 动图演示 逐图解析 洛谷P1177【模板】排序 sort【快速排序】

文章目录 归并排序1.归并排序的复杂度分析2.细节解释3.归并排序动图演示3(1) 我们的拆分过程如下↓ 4.code↓ 洛谷P1177【模板】排序数据规模与约定code&#xff08;归并排序&#xff09;↓code&#xff08;sort排序【快速排序】&#xff09; 完结撒花(&#xffe3;▽&#xff…

数据中台:数字中国战略关键技术实施

这里写目录标题 前言为何要建设数据中台数据中台建设痛点数据中台学习资料聚焦前沿&#xff0c;方法论体系更新与时俱进&#xff0c;紧跟时代热点深入6大行业&#xff0c;提炼实践精华大咖推荐&#xff0c;数字化转型必备案头书 前言 在数字中国这一国家战略的牵引下&#xff0…

基于springboot+vue的响应式企业员工绩效考评系统(源码+论文)

文章目录 前言 一、功能设计 1 普通员工功能 2 主管功能 3 系统管理员功能 4 评分标准功能 5 PC端与手机端 6 制图 二、功能实现 普通员工 1普通员工登录 2公告板块 3日志板块 主管 1主管登录 2公告板块 3日志板块 4绩效评分板块 5个人信息板块 系统管理员…

在 Linux 环境下安装 Kibana

目录 一、Kibana 是什么 二、在 Linux 环境下安装 Kibana 1、下载安装包 2、解压 3、修改 Kibana的配置文件 config/kibana.yml 4、启动 5、浏览器登录 Kibana 6、测试查询 一、Kibana 是什么 Kibana 是通向 Elastic 产品集的窗口。 它可以在 Elasticsearch 中对数据进…

品牌推广的两种飞轮:非酋飞轮与欧皇飞轮

在品牌推广的世界里&#xff0c;存在着两种截然不同的飞轮效应&#xff0c;我们称之为“非酋飞轮”与“欧皇飞轮”。这两种飞轮象征着品牌发展的两种不同路径和策略&#xff0c;而迅腾文化则以其独特的“繁”的原则&#xff0c;巧妙地将这两种飞轮结合&#xff0c;助力品牌形成…

Linux安装JumpServer并结合内网穿透实现公网访问本地服务

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…

Kubernetes 学习总结(46)—— Pod 不停重启问题分析与解决

我们在做性能测试的时候&#xff0c;往往会发现我们的pod服务&#xff0c;频繁重启&#xff0c;通过kubectl get pods 命令&#xff0c;我们来逐步定位问题。 现象:running的pod&#xff0c;短时间内重启次数太多。 定位问题方法:查看pod日志 kubectl get event …

1、EmlogCms代码审计

一、SQL注入 1、后台标签删除处存在1处sql注入 漏洞条件 ● 漏洞url: http://emlog6.0.com/admin/tag.php?actiondell_all_tag ● 漏洞参数&#xff1a;tag[xx] ● 是否存在限制&#xff1a;无 ● 是否还有其他条件&#xff1a;actiondell_all_tag,token复现 POST /admin…