【c++随笔12】继承

【c++随笔12】继承

  • 一、继承
    • 1、继承的概念
    • 2、3种继承方式
    • 3、父类和子类对象赋值转换
    • 4、继承中的作用域——隐藏
    • 5、继承与友元
    • 6、继承与静态成员
  • 二、继承和子类默认成员函数
    • 1、子类构造函数
  • 二、子类拷贝构造函数
    • 3、子类的赋值重载
    • 4、子类析构函数
  • 三、单继承、多继承、菱形继承
    • 1、单继承：一个子类只有一个直接父类，我们称这种继承关系为单继承。
    • 2、多继承：一个子类有两个或以上直接父类，我们称这种继承关系为多继承。
    • 3、菱形继承（Diamond Inheritance）是指在类继承关系中，存在一个派生类同时继承自两个直接或间接基类，并且这两个基类又共同继承自一个共同的基类，从而形成了菱形状的继承结构。
      • 3.1、菱形继承可能引发以下问题：
      • 3.2、为了解决菱形继承带来的问题，可以采用以下方法：
    • 4、继承和组合

原创作者：郑同学的笔记
原创地址：https://zhengjunxue.blog.csdn.net/article/details/131795289
qq技术交流群：921273910

C++ 是基于面向对象的程序，面向对象有三大特性 —— 封装、继承、多态。

一、继承

1、继承的概念

  • 继承（inheritance）机制是面向对象程序设计，使代码可以复用的最重要的手段。
  • 它允许程序员在保持原有类特性的基础上进行扩展，以增加功能。这样产生新的类，称为派生类。
  • 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
  • 以前我们接触的复用都是函数复用，而继承是类设计层次的复用。
#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
    string m_stuID;  // 学号
};

/* Teacher 公有继承了 Person */
class Teacher : public Person {
    string m_employeeID;  // 工号
};

int main() 
{
    Person p;
    p.print();

    Student su;
    su.print();

    Teacher t;
    t.print();

    return 0;
}

输出

在这里插入图片描述

  • 继承的定义格式
    Student 是 子类，我们也称之为派生类。Person 是父类，我们也称之为 基类。
class 派生类名:［继承方式］ 基类名{
    派生类新增加的成员
};

2、3种继承方式

  • 访问限定符：public / protected / private

下表汇总了不同继承方式对不同属性的成员的影响结果

继承方式/基类成员public成员protected成员private成员
public继承publicprotected不可见
protected继承protectedprotected不可见
private继承privateprivate不可见

由于 private 和 protected 继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中我们一般使用 public。

3、父类和子类对象赋值转换

  • 子类对象可以赋值给父类的对象、父类的指针、父类的引用：
#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
    string m_stuID;  // 学号
};

int main() 
{

    Student s;
   
    Person p = s;

    Person* pointer_p = &s;

    Person& ref_p = s;

    p.print();
    pointer_p->print();
    ref_p.print();

    return 0;
}

输出

在这里插入图片描述

注意事项：

  • ① 父类对象不能赋值给子类对象
Student s;  // 子类
Person p;   // 父类
 
s = p; ❌
  • ② 父类的指针可以通过强转赋值给子类的指针，但是必须是父类的指针是指向子类对象时才是安全的。

这里父类如果是多态类型，可以使用 RTTI（Run-Time Type Information，即运行时类型识别）的 dynamic_cast 来进行识别后进行安全转换。

#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
public:
    string m_stuID;  // 学号
};

int main() 
{

    Student s;
    // 父类的指针可以通过强制类型转换赋值给子类的指针
    Person* pointer_p = &s;
    Student* pointer_s = (Student*)pointer_p;
    pointer_s->m_stuID;

    Person p;
    // 这种情况虽然可以，但是会存在越界访问问题
    Person* pointer_p2 = &p;
    Student* pointer_s2 = (Student*)pointer_p2;
    pointer_s->m_stuID;

    return 0;
}

4、继承中的作用域——隐藏

  • 继承体系中的父类和子类都有独立的作用域，如果子类和父类有同名成员，
  • 此时子类成员会屏蔽父类对同名成员的直接访问，这种情况叫做 “隐藏” （有文章把它叫重定义，其实我不建议这种叫法，因为重定义指的是同一个作用域重复定义）。

在子类成员函数中，可以使用如下方式进行显式访问：
基类::基类成员
–
例如：在Student类中
Person::print()

#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
public:
    void print()
    {
        cout << "name = " << m_name << "\nage = " << m_age <<"\nstuID = "<< m_stuID << endl;
    }
    string m_stuID;  // 学号
};

int main() 
{

    Student s;
    s.print();

    return 0;
}

5、继承与友元

  • 友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员！
#include <iostream>
#include<string>
using namespace std;


class Student;
class Person {
public:
    friend void Display(const Person& p, const Student& s);
    /* 共有的信息 */

protected:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {

protected:
    void print()
    {
        cout << "name = " << m_name << "\nage = " << m_age <<"\nstuID = "<< m_stuID << endl;
    }
    string m_stuID = "110";  // 学号
};

void Display(const Person& p, const Student& s)
{
    cout << p.m_name << endl;
    cout << s.m_stuID << endl;
}

int main() 
{
    Person p;
    Student s;
    Display(p, s);

    return 0;
}

报错
“Student::m_stuID”: 无法访问 protected 成员(在“Student”类中声明)

6、继承与静态成员

  • 父类定义了 static 静态成员，则整个继承体系里面中有一个这样的成员。

可以理解为共享，父类的静态成员可以在子类共享，父类和子类都能去访问它。
无论派生出多少个子类，都只有一个 static 成员实例：

#include <iostream>
#include<string>
using namespace std;


class Person {
public:
    Person() {
        ++m_count;
    }
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
protected:
    string m_name;
    int m_age;
public:
    static int m_count;
};

int Person::m_count = 0;
/* Student 公有继承了 Person */
class Student : public Person 
{
protected:
    string m_stuID = "110";  // 学号
};


int main() 
{
	Student s1;
	Student s2;
	Student s3;
	Person s;

	cout << "大家都可以访问" << endl;
	cout << "人数 : " << Person::m_count << endl;
	cout << "人数 : " << Student::m_count << endl;

	cout << "大家也都可以变动" << endl;
	s3.m_count = 0;
	cout << "人数 : " << Person::m_count << endl;

	cout << "并且他们的地址也都是一样的，因为所有继承体系中只有一个" << endl;
	cout << "人数 : " << &Person::m_count << endl;
	cout << "人数 : " << &Student::m_count << endl;


    return 0;
}

输出

在这里插入图片描述

二、继承和子类默认成员函数

1、子类构造函数

  • 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。

如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。(如下面的demo)

  • 子类对象初始化先调用父类构造再调子类构造。
#include <iostream>
#include<string>
using namespace std;


class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
	Student(const char* name, int stuID) 
		:Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
		m_stuID(stuID)
	{
        cout << "构造 Student \n";
	}
protected:
    int m_stuID;  // 学号
};

int main() 
{
	Student s1("",18);


    return 0;
}

思考：如何设计一个不能被继承的类？

  • 将父类的构造函数私有化：
class A 
{
private:
    A() {}
};

父类的构造函数私有化后，在父类的外部，父类自己也没法初始化了？

（单例模式可以这么做，如下）


class A {
public:
    static A CreateObject() {  // 提供一个获取对象的方式
        return A();
    }
private:
    A() {}
};
 
class B : public A {};
 
int main(void) 
{
    A a = A::CreateObject();
 
    return 0;
}

二、子类拷贝构造函数

  • 子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
#include <iostream>
#include<string>
using namespace std;


class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }

    Person(const Person& p)
        :m_name(p.m_name)
    {
        cout << "拷贝构造 Person \n";
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
	Student(const char* name, int stuID) 
		:Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
		m_stuID(stuID)
	{
        cout << "构造 Student \n";
	}

    Student(const Student& s)
        :Person(s), //子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
        m_stuID(s.m_stuID)
    {
        cout << "拷贝构造 Student \n";
    }
protected:
    int m_stuID;  // 学号
};


int main() 
{
	Student s1("haha",18);
    Student s2(s1);

    return 0;
}

输出

在这里插入图片描述

3、子类的赋值重载

  • 子类的 operator= 必须要调用父类的 operator= 完成父类的复制。
#include <iostream>
#include<string>
using namespace std;

class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }

    Person& operator=(const Person& p)
    {
        cout << "赋值重载 Person \n";
        if(this != &p)
        {
            m_name = p.m_name;
        }
        return *this;
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
    Student(const char* name, int stuID)
        :Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
        m_stuID(stuID)
    {
        cout << "构造 Student \n";
    }

    Student& operator=(const Student& s)
    {
        cout << "赋值重载 Student \n";
        if (this != &s)
        {
            Person::operator=(s); //子类的 operator= 必须要调用父类的 operator= 完成父类的复制。
            m_stuID = s.m_stuID;
        }
        return *this;
    }
protected:
    int m_stuID;  // 学号
};

int main() 
{
	Student s1("小白",18);
    Student s2("小黑", 18);
    s1 = s2;

    return 0;

输出

在这里插入图片描述

4、子类析构函数

  • 为了保证子类对象先清理子类成员再清理父类成员的顺序，先子后父。

子类析构先子后父，子类对象的析构清理是先调用子类析构再调父类析构。

  • 子类析构函数完成后会自动调用父亲的析构函数，所以不需要我们显式调用。
#include <iostream>
#include<string>
using namespace std;

class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }

    ~Person()
    {
        cout << "析构 Person \n";
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
    Student(const char* name, int stuID)
        :Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
        m_stuID(stuID)
    {
        cout << "构造 Student \n";
    }

    ~Student()
    {
        cout << "析构 Student \n";
    }
protected:
    int m_stuID;  // 学号
};

int main() 
{
	Student s1("小白",18);

    return 0;
}

输出

在这里插入图片描述

三、单继承、多继承、菱形继承

1、单继承：一个子类只有一个直接父类，我们称这种继承关系为单继承。

2、多继承：一个子类有两个或以上直接父类，我们称这种继承关系为多继承。

3、菱形继承（Diamond Inheritance）是指在类继承关系中，存在一个派生类同时继承自两个直接或间接基类，并且这两个基类又共同继承自一个共同的基类，从而形成了菱形状的继承结构。

下面是一个示例代码来说明菱形继承的概念：

class Animal {
public:
    void eat() {
        cout << "Animal eats." << endl;
    }
};

class Mammal : public Animal {
public:
    void run() {
        cout << "Mammal runs." << endl;
    }
};

class Bird : public Animal {
public:
    void fly() {
        cout << "Bird flies." << endl;
    }
};

class Bat : public Mammal, public Bird {
public:
    void sleep() {
        cout << "Bat sleeps." << endl;
    }
};

在上述代码中，Animal 是基类，Mammal 和 Bird 是直接派生类，而 Bat 是通过多重继承同时派生自 Mammal 和 Bird 的派生类。注意到 Mammal 和 Bird 都继承自 Animal，这就形成了菱形继承结构。

3.1、菱形继承可能引发以下问题：

  • 二义性（Ambiguity）：由于 Bat 同时继承自 Mammal 和 Bird，如果两个基类都定义了相同的成员函数或变量，编译器就无法确定该使用哪个版本，从而导致二义性错误。
  • 冗余数据：由于两个基类都继承自同一个基类 Animal，当 Bat 对象被创建时，会在内存中存在两份相同的 Animal 的数据。

3.2、为了解决菱形继承带来的问题，可以采用以下方法：

  • 使用虚拟继承（Virtual Inheritance）：在 Mammal 和 Bird 继承 Animal 时，使用 virtual 关键字表示虚拟继承，这样就可以消除冗余数据和二义性问题。
class Mammal : virtual public Animal {
    // ...
};

class Bird : virtual public Animal {
    // ...
};
  • 使用间接继承：在 Bat 类中只直接继承 Mammal 或 Bird 的一个，而间接继承另一个基类的成员函数或变量。
class Bat : public Mammal {
private:
    Bird bird;
public:
    // 使用 bird 对象来访问 Bird 类中的成员
};

菱形继承是多重继承中的一种特殊情况，需要谨慎使用，并采取适当的解决方案来避免引发问题。

4、继承和组合

  • 继承和组合 public继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。
  • 组合是一种 has-a 的关系。假设B组合了A，每个B对象中都有一个A对象。
  • 优先使用对象组合，而不是类继承 。
  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用 （white-box reuse）。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。 继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关 系很强，耦合度高。
  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对 象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（black-box reuse）， 因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系， 耦合度低。优先使用对象组合有助于你保持每个类被封装。
  • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适 合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

class A {
	// ...
};
 
// 继承
class B : public A {};
 
class C {
	// ...
};
 
// 组合
class D {
	C _c;
};

继承就是团体出行，A 任何成员的修改都有可能影响 B 的实现。
组合就是自由出行，C 只要不修改公有，就不会对 D 有影响。

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

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

相关文章

MyBatis研究

MyBatis研究

入门级使用 参照MyBatis官网的简介与入门部分&#xff0c;尝试使用MyBatis&#xff0c;可创建新的Maven项目&#xff0c;引入以下依赖&#xff1a; <dependencies> <dependency><groupId>org.mybatis</groupId><artifactId>mybatis</…
阅读更多...
Spark 资源调优

Spark 资源调优

1 资源规划 1.1 资源设定考虑 1、总体原则 以单台服务器128G内存&#xff0c;32线程为例。 先设定单个Executor核数&#xff0c;根据Yarn配置得出每个节点最多的Executor数量&#xff0c;每个节点的yarn内存/每个节点数量单个节点的数量 总的executor数单节点数量*节点数。 2、…
阅读更多...
C/C++满足条件的数累加 2021年9月电子学会青少年软件编程（C/C++）等级考试一级真题答案解析

C/C++满足条件的数累加 2021年9月电子学会青少年软件编程（C/C++）等级考试一级真题答案解析

目录 C/C满足条件的数累加 一、题目要求 1、编程实现 2、输入输出 二、算法分析 三、程序编写 四、程序说明 五、运行结果 六、考点分析 C/C满足条件的数累加 2021年9月 C/C编程等级考试一级编程题 一、题目要求 1、编程实现 现有n个整数&#xff0c;将其中个位数…
阅读更多...
react 组件进阶

react 组件进阶

目标&#xff1a;1.能够使用props接收数据 2.能够实现父子组建之间的通讯 3.能够实现兄弟组建之间的通讯 4.能够给组建添加props校验 5.能够说出生命周期常用的钩子函数 6.能够知道高阶组件的作用 一&#xff0c;组件通讯介绍 组件是独立且封闭的单元&#xff0c;默认情况下&a…
阅读更多...
U-Mail邮件中继，让海外邮件沟通更顺畅

U-Mail邮件中继，让海外邮件沟通更顺畅

在海外&#xff0c;电子邮件是人们主要的通信工具&#xff0c;尤其是商务往来沟通&#xff0c;企业邮箱是标配。这主要是因为西方国家互联网发展较早&#xff0c;在互联网早期&#xff0c;电子邮件技术较为成熟&#xff0c;大家都用电子邮件交流&#xff0c;于是这成了一种潮流…
阅读更多...
2022年03月 Python（五级）真题解析#中国电子学会#全国青少年软件编程等级考试

2022年03月 Python（五级）真题解析#中国电子学会#全国青少年软件编程等级考试

Python等级考试（1~6级）全部真题・点这里 一、单选题（共25题，每题2分，共50分） 第1题 下面有关random的常用方法，描述错误的是? A: random.random()生成一个[0.0,1.0)之间的随机小数 B: random.randint(a,b)生成一个[a,b]之间的随机整数 C: random.choice(seq)从序列中…
阅读更多...
SpringBoot2.X整合集成Dubbo

SpringBoot2.X整合集成Dubbo

环境安装 Dubbo使用zookeeper作为注册中心&#xff0c;首先要安装zookeeper。 Windows安装zookeeper如下&#xff1a; https://blog.csdn.net/qq_33316784/article/details/88563482 Linux安装zookeeper如下&#xff1a; https://www.cnblogs.com/expiator/p/9853378.html Sp…
阅读更多...
高防CDN：护航网络安全的卓越之选

高防CDN：护航网络安全的卓越之选

在当今数字化时代&#xff0c;网络攻击与日俱增&#xff0c;为了确保网站和应用程序的稳定运行&#xff0c;高防CDN&#xff08;高防御内容分发网络&#xff09;应运而生。选择高防CDN的理由不仅源于其强大的防护性能&#xff0c;还体现了其与硬件防火墙异曲同工的奥妙。 选择高…
阅读更多...
wordpress是什么？快速搭网站经验分享

wordpress是什么？快速搭网站经验分享

​作者主页 &#x1f4da;lovewold少个r博客主页 ⚠️本文重点&#xff1a;c入门第一个程序和基本知识讲解 &#x1f449;【C-C入门系列专栏】&#xff1a;博客文章专栏传送门 &#x1f604;每日一言&#xff1a;宁静是一片强大而治愈的神奇海洋&#xff01; 目录 前言 wordp…
阅读更多...
[ASP]数据库编辑与管理V1.0

[ASP]数据库编辑与管理V1.0

本地测试&#xff1a;需要运行 ASP专业调试工具&#xff08;自己搜索下载&#xff09; 默认登陆口令&#xff1a;admin 修改口令&#xff1a;打开index.asp找到第3行把admin"admin"改成其他&#xff0c;如admin"abc123" 程序功能齐全&#xff0c;代码精简…
阅读更多...
[.NET]启明星电子文档管理系统edoc v33.0

[.NET]启明星电子文档管理系统edoc v33.0

启明星电子文档库是一个简单、实用的企业文档在线存储工具。系统采用ASP.NETMSSQL2008 Express开发&#xff0c;所有文档数据都以二进制方式存储在数据库里方便备份。 系统的特点包括&#xff1a; &#xff08;1&#xff09;支持文档在线预览&#xff0c;可以在线预览word&…
阅读更多...
SolidWorks绘制花瓶教程

SolidWorks绘制花瓶教程

这个花瓶是我学习solidworks画图以来用时最长的一个图形了&#xff0c;特此记录一下&#xff0c;用了我足足两个早晨才把他给画出来&#xff0c;我这是跟着哔站里的隔壁老王学习的&#xff0c;下面是视频地址&#xff1a;点击我一下看视频教程 下面是我的绘图过程&#xff0c;…
阅读更多...
Spring源码系列-Spring AOP

Spring源码系列-Spring AOP

AOP 要实现的是在我们原来写的代码的基础上&#xff0c;进行一定的包装&#xff0c;如在方法执行前、方法返回后、方法抛出异常后等地方进行一定的拦截处理或者叫增强处理。 AOP 的实现并不是因为 Java 提供了什么神奇的钩子&#xff0c;可以把方法的几个生命周期告诉我们&…
阅读更多...
Leetcode刷题详解—— 有效的数独

Leetcode刷题详解—— 有效的数独

1. 题目链接&#xff1a;36. 有效的数独 2. 题目描述&#xff1a; 请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 &#xff0c;验证已经填入的数字是否有效即可。 数字 1-9 在每一行只能出现一次。数字 1-9 在每一列只能出现一次。数字 1-9 在每一个以粗实线分隔的…
阅读更多...
11/12总结

11/12总结

项目进度&#xff1a; 界面画了搜索机票&#xff0c;预定机票&#xff0c;搜索酒店&#xff0c;预定酒店&#xff0c; 然后是开始写这些功能的后端逻辑
阅读更多...
RT-DTER 引入用于低分辨率图像和小物体的新 CNN 模块 SPD-Conv

RT-DTER 引入用于低分辨率图像和小物体的新 CNN 模块 SPD-Conv

论文地址：https://arxiv.org/pdf/2208.03641v1.pdf 代码地址：https://github.com/labsaint/spd-conv 卷积神经网络(CNN)在图像分类、目标检测等计算机视觉任务中取得了巨大的成功。然而，在图像分辨率较低或对象较小的更困难的任务中，它们的性能会迅速下降。 这源于现有CNN…
阅读更多...
终端安全/SOC安全/汽车信息安全大课来袭-共计204节课

终端安全/SOC安全/汽车信息安全大课来袭-共计204节课

在近两年的时间里&#xff0c;我投入了大量的心血和精力&#xff0c;不仅创作了数千篇精美的图片&#xff0c;还编写了超过1000篇文章&#xff0c;以及数百篇内容丰富的PPT。经过这番努力我终于成功地构建出两套系统化的学习课程&#xff0c;它们分别是“Trustzone/TEE/安全从入…
阅读更多...
Spring基础——初探

Spring基础——初探

Spring是一个开源的Java应用程序开发框架&#xff0c;它提供了一个综合的编程和配置模型&#xff0c;用于构建现代化的企业级应用程序。Spring的目标是简化Java开发&#xff0c;并提供了许多功能和特性&#xff0c;以提供开发效率、降低开发复杂性。 特别 主要功能 IoC容器 …
阅读更多...
IP多播需要使用两种协议（IGMP和多播路由选择协议）

IP多播需要使用两种协议（IGMP和多播路由选择协议）

目录 IGMP 多播路由选择协议 组播协议包括组成员管理协议和组播路由协议: 组成员管理协议用于管理组播组成员的加入和离开(IGMP) 组播路由协议负责在路由器之间交互信息来建立组播树(多播路由选择协议) IGMP 图中标有 IP 地址的四台主机都参加了一个多播组&#xff0c;其…
阅读更多...
HCIP-双点双向重发布

HCIP-双点双向重发布

实验拓扑 要求&#xff1a;全网没有次优路径、且尽量负载均衡。 设备配置 R1 [V200R003C00] #sysname R1 #snmp-agent local-engineid 800007DB03000000000000snmp-agent #clock timezone China-Standard-Time minus 08:00:00 # portal local-server load flash:/portalpage.…
阅读更多...
最新文章

Copyright @ 2022~2023