再谈c++中的多态

何为多态

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

多态的实现

在继承的体系下

  1. 基类中必须有虚函数(被virtual关键字修饰的成员函数)，在派生类中必须要对基类中的虚函数进行重写
  2. 对于虚函数的调用:必须使用基类的指针或者引用调用虚函数
体现多态性

在代码运行时，基类指针指向哪个类的对象，就调用哪个类的虚函数

class Person
{
public:Person(const string& name,const string& gender,const int age):_name(name), _gender(gender), _age(age){}void BuyTicket(){cout << "全价票" << endl;}
protected:string _name;string _gender;int _age;
};class Studnet :public Person
{
public:Studnet(const string& name, const string& gender, const int age,const int _stuId):Person(name,gender,age), _stuId(_stuId){}void BuyTicket(){cout << "半价票" << endl;}
protected:int _stuId;};class Soldier:public Person
{
public:Soldier(const string& name, const string& gender, const int age, const string& rank):Person(name,gender,age), _rank(rank){}void BuyTicket(){cout << "免费" << endl;}
protected:string _rank;
};void TestBuyTicket(Person& p)
{p.BuyTicket();
}int main()
{Person p("Tom", "男", 18);Studnet st("小帅", "女", 19,1000);Soldier so("威武", "男", 23, "班长");TestBuyTicket(p);TestBuyTicket(st);TestBuyTicket(so);system("pause");return 0;
}

在这里插入图片描述
并没有体现出多态性，如果要让不同的人买到各自的票，我们可以写三个重载函数来实现，但是这样的话，代码的重复性太高，所以这里就要使用多态。

什么是虚函数

虚函数：就是在类的成员函数的前面加virtual关键字

virtual void BuyTicket(){cout << "全价票" << endl;}

什么虚函数的重写？

虚函数的重写：**派生类中有一个跟基类的完全相同虚函数，我们就称子类的虚函数重写了基类的虚函数，完全相同是指：函数名、参数、返回值都相同。**另外虚函数的重写也叫作虚函数的覆盖。
也就是说派生类重写基类中的某个虚函数—>派生类函数必须要与基类中的虚函数原型完全一致

class Person
{
public:virtual void BuyTicket(){cout << "全价票" << endl;}
};
class Studnet :public Person
{
public:virtual void BuyTicket(){cout << "半价票" << endl;}
};

注意事项

  1. 基类中与子类中的同名方法不是虚函数，但是子类中是虚函数，不是多态，是继承中的重定义，同名隐藏。基类同名成员函数前必须加virtual关键字
  2. 子类中把虚函数关键字去掉，但是此函数在基类中是虚函数，此时是多态。所以子类同名成员函数前virtual关键字是否添加都可以
  3. 基类虚函数必须要与派生类虚函数的原型完全相同(返回值类型，函数名字(参数列表))
class Base
{
public:virtual void TestFunc1(){cout << "Base::TestFunc1()" << endl;}virtual void TestFunc2(int ){cout << "Base::TestFunc2()" << endl;}void TestFunc3(){cout << "Base::TestFunc3()" << endl;}virtual void TestFunc4(){cout << "Base::TestFunc4()" << endl;}
};class Derived :public Base
{
public:virtual void TestFunc1(){cout << "Derived::Testfun1()" << endl;}virtual void TestFunc2(){cout << "Derived::TestFunc2()" << endl;}virtual void TestFunc3(){cout << "Derived::TestFunc3()" << endl;}void TestFunc4(){cout << "Derived::TestFunc4()" << endl;}
};void TestVirtualFunc(Base* pb)
{pb->TestFunc1();pb->TestFunc2(10);pb->TestFunc3();pb->TestFunc4(); 
}
int main()
{Base b;Derived d;TestVirtualFunc(&b);TestVirtualFunc(&d);system("pause");return 0;
}

在这里插入图片描述
我们定义一个函数，形参为基类的指针，然后在主函数中分别创建基类对象，子类对象，然后将他们传进去，第一个传的是基类对象，所以是基类的指针指向了基类的对象，所以调的全部都是基类的函数。第二个传的是子类的对象，就是基类指针指向子类对象，但是因为Func2函数与基类中的原型不一致，Func3()函数基类中没有加virtual关键字，所以这两个函数并没有实现多态，都调用的是基类的函数，而1和4调用的是子类的函数，实现了多态。

虚函数重写的例外:协变

基类中虚函数**返回基类（基类1）**的引用(指针)，子类的虚函数返回子类1（只要继承于基类1）的引用(指针)基类和子类虚函数的返回值类型不同

class A{};//基类
class B : public A {}; //子类
class Person {//基类1
public:virtual A* f() {return new A;}//返回值的是基类，不是基类1
};
class Student : public Person {//子类1继承于基类1
public:virtual B* f() {return new B;}//返回值是子类，不是子类1的
};

虚函数重写的例外:虚函数

函数名字不同，但是可以构成重写。编译器对析构函数的名称做了特殊处理，编译后
析构函数的名称统一处理成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;
}

针对于上面的代码，如果基类和子类都不写成虚函数。
在这里插入图片描述
基类不是虚函数，但是子类是。程序会出内存泄露
在这里插入图片描述
正常的结果
在这里插入图片描述

接口继承和实现继承

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

重载，重写(覆盖),重定义(隐藏)

重载重写(覆盖)重定义(隐藏)
两个函数在同一作用域两个函数分别在基类和派生类的作用域两个函数分别在基类和派生类的作用域
函数名/参数相同函数名/参数/返回值都必须是相同的(协变例外)函数名相同
两个函数必须是虚函数两个基类和派生类的同名函数不构成重写就是重定义

按值传参与按指针/引用传参的区别

void TestBuyTicket(Person *p)
{p->~Person();
}
  • 在编译阶段，编译器无法确认基类的指针到底指向哪个类的对象，因为函数在执行期间才会传参，因此在编译期间无法确认虚函数的行为。只能在代码运行时，才可以确定该基类指针指向哪个类的对象。
void TestBuyTicket(Person p)
{p.~Person();//在调用期间，不论传递哪个类的对象，该函数调用的都是基类的
}
  • 编译期间，因为该函数按照值的方式传参，参数已经确认。因此在编译阶段，就会生成基类的临时对象，因此该函数在编译期间可以确定虚函数行为，已经确定调用哪个类的函数。

C++11 override 和 final

override:只能修饰派生类的虚函数
作用:检测派生类中的某个虚函数是否重写了哪个虚函数，防止函数名有时候写错，没有构成重写。
final:可以修饰类—表示该类不能被继承，修饰虚函数—虚函数不能被继承

// 1.final 修饰基类的虚函数不能被派生类重写
class Car
{
public:virtual void Drive() final {}
};
class Benz :public Car
{
public:virtual void Drive() {cout << "Benz-舒适" << endl;}
};

抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class WC
{
public:void GoToManRoom(){cout << "go to left"<<endl;}void GoToWoManRoom() {cout << "go to right"<<endl;}
};
//作用:规范后续的接口
class Person
{//不能实例化对象，但可以创建该类的指针
public://纯虚函数virtual void GoToWc(WC& wc) = 0;string _name;int _age;
};class Man :public Person
{
public:void GoToWc( WC& wc){wc.GoToManRoom();}
};
class WoMan :public Person
{
public:void GoToWc(WC& wc){wc.GoToWoManRoom();}
};
#include<Windows.h>
#include<time.h>
//Monster 也是抽象类，因为该类没有重写基类中的纯虚函数
class Monster :public Person
{};
void TestWC(int n)
{WC wc;srand(time(nullptr));for (int i = 0; i < n; ++i){Person* pGuard;if (rand() % 2 == 0)pGuard = new Man;elsepGuard = new WoMan;pGuard->GoToWc(wc);delete pGuard;Sleep(1000);}
}
int main()
{//Person* p;TestWC(10);system("pause");return 0;
}

在这里插入图片描述

多态的原理

无继承

class Base
{
public:Base(){}virtual void TestFunc3(){cout << "Base::TestFunc2()" << endl;}virtual void TestFunc1(){cout << "Base::TestFunc1()" << endl;}virtual void TestFunc2(){cout << "Base::TestFunc2()" << endl;}int _b;
};
  • 一个类中包含有虚函数，会给该类的对象多增加四个字节，该4字节中的内容是在构造函数中填充的。
  • 如果类没有显示定义构造函数，编译器会给该类生成一个默认的构造函数，作用：给对象的前4个字节赋值
  • 如果类显示定义了自己的构造函数，编译器将会对构造函数进行修改，多增加一条语句，给对象的前4个字节赋值

在这里插入图片描述

出现继承

class Base
{
public:Base(){}virtual void TestFunc3(){cout << "Base::TestFunc2()" << endl;}virtual void TestFunc1(){cout << "Base::TestFunc1()" << endl;}virtual void TestFunc2(){cout << "Base::TestFunc2()" << endl;}int _b;
};
class Derived :public Base
{};

虚表指针不一样，派生类和基类用的不是同一张虚表
在这里插入图片描述

基类虚表构建过程

将虚函数按照其在类中的声明次序依次放到虚表中。

class Base
{
public:Base(){}virtual void TestFunc3(){cout << "Base::TestFunc2()" << endl;}virtual void TestFunc1(){cout << "Base::TestFunc1()" << endl;}virtual void TestFunc2(){cout << "Base::TestFunc2()" << endl;}int _b;
};
class Derived :public Base
{
public:virtual void TestFunc1(){cout << "Derived::TestFunc1()" << endl;}virtual void TestFunc3(){cout << "Derived::TestFunc2()" << endl;}int _d;
};

派生类虚表的构建过程

  1. 将基类虚表中内容拷贝一份放到子类的虚表中
  2. 如果派生类重写了基类的某个虚函数，用派生类自己的虚函数地址替换虚表中相同偏移量位置的基类虚函数。
  3. 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
    在这里插入图片描述

调用原理

class Base
{
public:Base(){}virtual void TestFunc1(){cout << "Base::TestFunc1()" << endl;}virtual void TestFunc2(){cout << "Base::TestFunc2()" << endl;}virtual void TestFunc3(){cout << "Base::TestFunc3()" << endl;}void TestFunc4(){cout << "Base::TestFunc4()" << endl;}int _b;
};
class Derived :public Base
{
public:virtual void TestFunc1(){cout << "Derived::TestFunc1()" << endl;}virtual void TestFunc2(){cout << "Base::TestFunc2()" << endl;}virtual void TestFunc3(){cout << "Derived::TestFunc3()" << endl;}int _d;
};
//虚函数的调用:通过基类的指针或者引用调用虚函数
void TestVirtual(Base *pb)
{pb->TestFunc1();pb->TestFunc2();pb->TestFunc3();pb->TestFunc4();
}

01104BC3  mov         eax,dword ptr [pb]  
01104BC6  mov         edx,dword ptr [eax]  //前两步，从对象前4个字节取虚表的地址
01104BC8  mov         esi,esp  
01104BCA  mov         ecx,dword ptr [pb]  	//传递this指针
01104BCD  mov         eax,dword ptr [edx+4]  //从虚表中找对应的虚函数
01104BD0  call        eax  //调用虚函数

//重新解析d对象的内存空间，
//将d对象的内存空间按照基类对象方式进行解析
//这个过程并没有创建新的对象，所以还是调用派生类的函数
Base* pb = (Base*)&d;
pb->TestFunc1();
return 0;

打印虚函数表

单继承

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 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();//调用虚函数，f=vTable[i] vTable[i]等于一个虚函数入口地址}cout << endl;
}
int main()
{Base b;Derive d;
// 思路：取出b、d对象的头4比特，就是虚表的指针，虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr
// 1.先取b的地址，强转成一个int*的指针
// 2.再解引用取值，就取到了b对象头4比特的值，这个值就是指向虚表的指针
// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
// 4.虚表指针传递给PrintVTable进行打印虚表
// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有
//放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再编译就好了。VFPTR* vTableb = (VFPTR*)(*(int*)&b);PrintVTable(vTableb);VFPTR* vTabled = (VFPTR*)(*(int*)&d);PrintVTable(vTabled);system("pause");return 0;
}

在这里插入图片描述

多继承

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;VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);PrintVTable(vTableb1);VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));PrintVTable(vTableb2);system("pause");return 0;
}

在这里插入图片描述
在这里插入图片描述
多继承派生类虚表的构建过程

  1. 与单继承中派生类构建过程相同的
  2. 对于派生类新增加的虚函数按照其在类中的声明次序增加到第一个虚表的最后。

总结

  1. 同一个类的不同对象，在底层共享一张虚表
  2. 派生类除了继承基类的东西，如果自己没有加任何的新东西，虽然派生类的虚表内容和基类的内容是一样的，但是不是同一张虚表，因为虚表指针不一样。派生类不会和基类共用同一张虚表派生类也有自己的虚表。
  3. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
  4. 虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
  5. 虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？vs下是存在代码段

问题

什么是多态？

概念

同一个事物在不同场景下可以表现出的多种形态，例如迪迦奥特曼的三种形态。

多态的分类

静态多态(静态绑定/早绑定)动态多态(动态绑定/晚绑定)
在编译时，可确定具体哪个函数在编译阶段无法确定函数具体调用哪个函数，必须在代码运行时才能确定，无法确定基类指针或者引用到底指向哪个类的对象
函数重载/模板虚函数+继承

多态的实现条件

  1. 必须在继承体系中
  2. 在基类中必须要有虚函数(被virtual关键字修饰的成员函数)，派生类必须对基类的虚函数进行重写
  3. 关于虚函数的调用:必须通过基类的指针或者引用调用虚函数

inline函数可以是虚函数吗？

不能，因为inline函数没有地址，无法把地址放到虚函数表中。inline在编译时期展开，多态发生在运行时。

静态成员可以是虚函数吗？

不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

构造函数可以是虚函数吗？

不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
构造函数的作用:

  1. 初始化类中的成员变量
  2. 将虚表指针放在对象的前4个字节---->编译器自己完成。

析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

可以，并且最好把基类的析构函数定义成虚函数。析构函数可以为虚函数---->重写的一种特例，因为派生类重写基类中的虚析构函数，名字不一样。

class Base
{
public:Base(int b):_b(b){cout << "Base::Base()" << endl;}virtual ~Base(){cout << "Base::~Base()" << endl;}int _b;
};
class Derived :public Base
{
public:Derived(int b):Base(b){_p = new int[10];}~Derived(){delete[]_p;}
private:int *_p;
};
int main()
{//静态类型:声明变量时的类型----在编译期间起作用//动态类型:实际引用(指向)的类型----在运行时确定调用哪个类的虚函数Base* pb = new Derived(10);delete pb;//看析构函数是不是虚函数，如果不是用静态类型,//delete:1.调用析构函数释放对象中的资源//		 2.调用operator delete()释放对象的空间system("pause");return 0;
}

如果派生类中涉及到动态资源的管理(比如:子类从堆上申请空间)，建议:基类中的析构函数最好设置为虚函数，否则可能存在内存泄露

对象访问普通函数快还是虚函数更快？

首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

普通函数(指非虚函数)调用虚函数调用(没有完全实现多态条件)虚函数调用(多态实现条件完全满足)
传参(如果有参数)跟普通函数调用一样从对象的前4个字节中取虚表地址
通过指令call调用该函数(call 函数入口地址)传参(包括this指针)
从虚表中获取函数地址
调用函数

多态的缺陷:降低程序运行的速度

虚函数表是在什么阶段生成的，存在哪的？

虚函数是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

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

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

相关文章

再谈c++中的继承

再谈c++中的继承

继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段&#xff0c;它允许程序员在保持原有类特性的基础上进行扩展&#xff0c;增加功能&#xff0c;这样产生新的类&#xff0c;称派生类。继承呈现了面向对象程序设计的层次结构&#xff0c;体现了…
阅读更多...
红黑树概念及其相关操作的实现

红黑树概念及其相关操作的实现

红黑树的概念 红黑树&#xff0c;是一种二叉搜索树&#xff0c;但它并不像AVL树一样&#xff0c;每个结点绑定一个平衡因子。但在每个结点上增加一个存储位表示结点的颜色&#xff0c;可以是Red或Black。 通过 对任何一条从根到叶子的路径上各个结点着色方式的限制&#xff0c…
阅读更多...
模拟实现STL中map和set容器

模拟实现STL中map和set容器

红黑树的迭代器 //红黑树的迭代器 template<class T> struct RBTreeIterator {typedef RBTreeNode<T>Node;typedef RBTreeIterator<T> Self; public:RBTreeIterator(Node* pNode nullptr):_pNode(pNode){}//具有指针操作T& operator*(){return _pNode-…
阅读更多...
排序上---(排序概念，常见排序算法，直接插入，希尔排序，直接选择排序，堆排序)

排序上---(排序概念，常见排序算法，直接插入，希尔排序，直接选择排序，堆排序)

排序的概念 排序&#xff1a;所谓排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的操作。稳定性&#xff1a;假定在待排序的记录序列中&#xff0c;存在多个具有相同的关键字的记录&#xff0c;若经过排序&…
阅读更多...
排序下---(冒泡排序，快速排序，快速排序优化，快速排序非递归，归并排序，计数排序)

排序下---(冒泡排序，快速排序，快速排序优化，快速排序非递归，归并排序，计数排序)

排序上 排序上 交换类排序 基本思想&#xff1a;所谓交换&#xff0c;就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置&#xff0c;交换排序的特点是&#xff1a;将键值较大的记录向序列的尾部移动&#xff0c;键值较小的记录向序列的前部移动。 冒泡…
阅读更多...
哈希的概念及其操作

哈希的概念及其操作

哈希概念 顺序结构以及平衡树中&#xff0c;元素关键码与其存储位置之间没有对应的关系&#xff0c;因此在查找一个元素时&#xff0c;必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)&#xff0c;平衡树中为树的高度&#xff0c;即O( Log2N)&#xff0c;搜索的效率取决…
阅读更多...
软件工程---1.概述

软件工程---1.概述

软件的特征 抽象&#xff1a; 不可触摸&#xff0c;逻辑实体&#xff0c;可记录&#xff0c;但看不到复制成本低&#xff1a;不受物质材料的限制&#xff0c;不受物理定律或加工过程的制约&#xff0c;与开发成本相比&#xff0c;复制成本很低无折旧、受硬件制约、未完全摆脱手…
阅读更多...
软件工程---2.软件过程

软件工程---2.软件过程

三个模型 瀑布模型增量模型集成和配置模型 没有适用于所有不同类型软件开发的过程模型。 瀑布模型 需求定义系统和软件的设计实现与单元测试集成与系统测试运行与维护 瀑布模型的特征 从上一项活动中接受该项活动的工作成果&#xff08;工作产品&#xff09;&#xff0c;作…
阅读更多...
软件工程---4.需求工程

软件工程---4.需求工程

需求工程定义 找出、分析、文档化并且检查需求的过程被称为需求工程 需求的两个描述层次 用户需求&#xff0c;指高层的抽象需求。使用自然语言、图形描述需求。系统需求&#xff0c;指底层的详细需求。使用系统需求文档&#xff08;有时被称为功能规格说明&#xff09;应该…
阅读更多...
软件工程---5.系统建模

软件工程---5.系统建模

从不同视角对系统建模 外部视角&#xff0c;上下文模型&#xff0c;对系统上下文或环境建模交互视角&#xff0c;交互模型&#xff08;功能模型&#xff09;&#xff0c;对系统与参与者或系统内构件之间的交互建模结构视角&#xff0c;结构模型&#xff08;静态模型&#xff0…
阅读更多...
软件工程---6.体系结构设计

软件工程---6.体系结构设计

体系结构模型是什么&#xff1f; 体系结构模型&#xff0c;该模型描述系统如何被组织为一组相互通信的构件 体系结构分类 小体系结构关注单个程序的体系结构。在这个层次上&#xff0c;我们关注单个的程序是如何补分解为构件的。大体系结构关注包括其他系统、程序和程序构件…
阅读更多...
【剑指offer】_07 矩形覆盖

【剑指offer】_07 矩形覆盖

题目描述 我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形&#xff0c;总共有多少种方法&#xff1f; 解题思路 依旧是斐波那契数列 2n的大矩形&#xff0c;和n个21的小矩形 其中target*2为大矩阵的大小 有以下几种情形…
阅读更多...
软件工程---07.设计与实现

软件工程---07.设计与实现

软件设计和软件实现 软件设计是一个创造性的活动&#xff0c;在此活动中需要基于客户需求识别软件构件及其关系。软件实现是将设计实现为一个程序的过程 为开发一个系统设计&#xff0c;你需要 理解并定义上下文模型以及系统的外部交互设计系统体系结构识别系统中的主要对象…
阅读更多...
软件工程---15.软件复用

软件工程---15.软件复用

复用的图(牢记) 软件复用的好处 开发加速有效的专家利用提高可依赖性降低开发成本降低过程风险符合标准 软件复用的缺点 创建&#xff0c;维护以及使用一个构件库查找&#xff0c;理解以及适配可复用构件维护成本增加缺少工具支持“不是在这里发明的”综合症 应用框架 现在…
阅读更多...
软件工程---16.基于构件的软件工程

软件工程---16.基于构件的软件工程

CBSE CBSE是定义、实现、集成或组装松散耦合的独立构件成为系统的过程。 基于构件的软件工程的要素有: 完全由接口进行规格说明的独立构件。构件标准使构件集成变得更为容易。中间件为构件集成提供软件支持。开发过程适合基于构件的软件工程。 CBSE的设计原则 构件是独立的…
阅读更多...
软件工程---17.分布式软件工程

软件工程---17.分布式软件工程

分布式系统的5个优点 资源共享开放性并发性可伸缩性容错性 分布式计算中必须考虑的设计问题 透明性&#xff1a;隐藏底层分布 开放性 可伸缩性 三个维度 规模&#xff1a;又分为增强扩展(单挑)&#xff0c;增加扩展(群殴)分布可靠性 信息安全性 主要防止以下类型的攻击 拦…
阅读更多...
软件工程---18.面向服务的软件工程

软件工程---18.面向服务的软件工程

什么是Web服务 一个松耦合、可复用的软件构件&#xff0c;封装了离散的功能&#xff0c;该功能是分布式的并且可以被程序访问。Web服务是通过标准互联网和基于XML的协议被访问的服务。 服务和软件构件之间的一个重要的区别是 服务应该总是独立的和松耦合的Web 服务没有“请求…
阅读更多...
【剑指offer】_09二叉搜索树的后序遍历序列

【剑指offer】_09二叉搜索树的后序遍历序列

题目描述 输入一个整数数组&#xff0c;判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 解题思路 比如下面的这棵二叉搜索树 它的后序遍历为0214369875&#xff1b; 我们设当前根节点为root; 第一次…
阅读更多...
【剑指offer】_12 数组中的逆序对

【剑指offer】_12 数组中的逆序对

题目描述 在数组中的两个数字&#xff0c;如果前面一个数字大于后面的数字&#xff0c;则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007 解题思路 剑指offer的解法 看到这个题目&#xff0…
阅读更多...
详解Linux下通过yum安装Mariadb/MySQL数据库(腾讯云也适用)

详解Linux下通过yum安装Mariadb/MySQL数据库(腾讯云也适用)

1. 安装Mariadb 安装命令 yum -y install mariadb mariadb-server安装完成MariaDB&#xff0c;首先启动MariaDB systemctl start mariadb设置开机启动 systemctl enable mariadbMariaDB的相关简单配置 此命令进入到配置相关界面 mysql_secure_installation首先是设置密码…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023