【c++随笔12】继承

news2024/11/15 21:31:13

【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 有影响。

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

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

相关文章

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

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

本地测试&#xff1a;需要运行 ASP专业调试工具&#xff08;自己搜索下载&#xff09; 默认登陆口令&#xff1a;admin 修改口令&#xff1a;打开index.asp找到第3行把admin"admin"改成其他&#xff0c;如admin"abc123" 程序功能齐全&#xff0c;代码精简…
阅读更多...
CLIP：用文本作为监督信号训练可迁移的视觉模型

CLIP：用文本作为监督信号训练可迁移的视觉模型

Radford A, Kim J W, Hallacy C, et al. Learning transferable visual models from natural language supervision[C]//International conference on machine learning. PMLR, 2021: 8748-8763. CLIP 是 OpenAI 在 2021 年初的工作&#xff0c;文章发表在 ICML-2021&#xff0…
阅读更多...
并发安全问题之--事物失效问题

并发安全问题之--事物失效问题

并发安全问题之–事物失效问题 事物失效常见的6种原因&#xff1a; 1、事物方法非public修饰 2、非事物方法调用事物方法 3、事物方法抛出的异常被捕获了 4、事物方法抛出的异常类型不对 5、事物传播行为不对&#xff08;事物发生嵌套时有事物传播&#xff09; 6、事物锁属类没…
阅读更多...
IP多播需要使用两种协议（IGMP和多播路由选择协议）

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

目录 IGMP 多播路由选择协议 组播协议包括组成员管理协议和组播路由协议: 组成员管理协议用于管理组播组成员的加入和离开(IGMP) 组播路由协议负责在路由器之间交互信息来建立组播树(多播路由选择协议) IGMP 图中标有 IP 地址的四台主机都参加了一个多播组&#xff0c;其…
阅读更多...
逻辑回归-癌症病预测与不均衡样本评估

逻辑回归-癌症病预测与不均衡样本评估

1.注册相关库(在命令行输入&#xff09; pip install scikit-learn pip install pandas pip install numpy 2.导入相关库 import pandas as pd import numpy as np from sklearn.metrics import classification_report from sklearn.model_selection import train_test_split…
阅读更多...
初始MySQL(三)(合计函数,分组函数,字符串相关函数,数字相关函数,时间日期函数,加密函数,流程控制函数)

初始MySQL(三)(合计函数,分组函数,字符串相关函数,数字相关函数,时间日期函数,加密函数,流程控制函数)

目录 合计/统计函数 count 返回行的总数 sum 合计函数 - avg group by 字符串相关函数 数学相关函数 时间日期相关函数 加密函数 流程控制函数 合计/统计函数 count 返回行的总数 Select count(*) | count (列名) from tablename [WHERE where_definition] #演…
阅读更多...
国际阿里云：Windows实例中数据恢复教程！！！

国际阿里云：Windows实例中数据恢复教程！！！

在处理磁盘相关问题时&#xff0c;您可能会碰到操作系统中数据盘分区丢失的情况。本文介绍了Windows系统下常见的数据盘分区丢失的问题以及对应的处理方法&#xff0c;同时提供了使用云盘的常见误区以及最佳实践&#xff0c;避免可能的数据丢失风险。 前提条件 已注册阿里云账…
阅读更多...
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;将其中个位数…
阅读更多...
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)从序列中…
阅读更多...
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…
阅读更多...
Anolis 8.6 安装 Drawio

Anolis 8.6 安装 Drawio

Anolis 8.6 安装 Drawio 22.1.0 一.RPM版&#xff08;不建议&#xff09;二.WAR 包部署 一.RPM版&#xff08;不建议&#xff09; Draw RPM 包下载链接 RPM 包直接基于Linux图形化能力部署&#xff0c;服务器类型的Linux系统启动RPM包安装的Draw可能比较复杂 系统版本 ## 1.…
阅读更多...
Leetcode刷题详解—— 有效的数独

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

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

Spark Job优化

1 Map端优化 1.1 Map端聚合 map-side预聚合&#xff0c;就是在每个节点本地对相同的key进行一次聚合操作&#xff0c;类似于MapReduce中的本地combiner。map-side预聚合之后&#xff0c;每个节点本地就只会有一条相同的key&#xff0c;因为多条相同的key都被聚合起来了。其他节…
阅读更多...
Day28力扣打卡

Day28力扣打卡

打卡记录 给小朋友们分糖果 II&#xff08;容斥原理&#xff09; 链接 大佬的题解 def c2(n: int) -> int:return n * (n - 1) // 2 if n > 1 else 0class Solution:def distributeCandies(self, n: int, limit: int) -> int:return c2(n 2) - 3 * c2(n - limit …
阅读更多...
Codeforces Round 788 (Div. 2) E. Hemose on the Tree（树上构造）

Codeforces Round 788 (Div. 2) E. Hemose on the Tree（树上构造）

题目 t(t<5e4)组样例&#xff0c;每次给定一个数p&#xff0c; 表示一棵节点数为的树&#xff0c; 以下n-1条边&#xff0c;读入树边 对于n个点和n-1条边&#xff0c;每个点需要赋权&#xff0c;每条边需要赋权&#xff0c; 权值需要恰好构成[1,2n-1]的排列 并且当你赋…
阅读更多...
基于springboot实现沁园健身房预约管理系统【项目源码】计算机毕业设计

基于springboot实现沁园健身房预约管理系统【项目源码】计算机毕业设计

基于springboot实现沁园健身房预约管理系统演示 B/S架构 B/S结构是目前使用最多的结构模式&#xff0c;它可以使得系统的开发更加的简单&#xff0c;好操作&#xff0c;而且还可以对其进行维护。使用该结构时只需要在计算机中安装数据库&#xff0c;和一些很常用的浏览器就可以…
阅读更多...
Jenkins简介及Docker Compose部署

Jenkins简介及Docker Compose部署

Jenkins是一个开源的自动化服务器&#xff0c;用于自动化构建、测试和部署软件项目。它提供了丰富的插件生态系统&#xff0c;支持各种编程语言和工具&#xff0c;使得软件开发流程更加高效和可靠。在本文中&#xff0c;我们将介绍Jenkins的基本概念&#xff0c;并展示如何使用…
阅读更多...
[.NET]启明星电子文档管理系统edoc v33.0

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

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

pta 装箱问题 Python3

假设有N项物品&#xff0c;大小分别为s1​、s2​、…、si​、…、sN​&#xff0c;其中si​为满足1≤si​≤100的整数。要把这些物品装入到容量为100的一批箱子&#xff08;序号1-N&#xff09;中。装箱方法是&#xff1a;对每项物品, 顺序扫描箱子&#xff0c;把该物品放入足以…
阅读更多...
mini-vue 的设计

mini-vue 的设计

mini-vue 的设计 mini-vue 使用流程与结果预览&#xff1a; <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta http-equiv"X-UA-Compatible" content"IEedge" /><meta name&qu…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023