继承--C++

文章目录

  • 一、继承的概念及定义
    • 1、继承的概念
  • 二、继承定义
    • 1、定义格式
    • 2、继承基类成员访问方式的变化
    • 3、继承类模板
  • 三、基类和派生类间的转换
  • 1、继承中的作用域
    • 2、隐藏规则：
  • 四、派生类的默认成员函数
    • 1、4个常见默认成员函数
    • 2、实现⼀个不能被继承的类
  • 五、继承与友元
  • 六、继承与静态成员
  • 七、多继承及其菱形继承问题
    • 1、继承模型
    • 2、虚继承
  • 八、继承和组合
    • 1、继承和组合

一、继承的概念及定义

1、继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复⽤的最重要的手段，它允许我们在保持原有类特性的基础上进⾏扩展，增加放法(成员函数)和属性(成员变量)，这样产生新的类，称派生类。继承呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复⽤。

下⾯看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名/地址/电话/年龄等成员变量，都有identity⾝份认证的成员函数，设计到两个类⾥⾯就是冗余的。当然他们也有⼀些不同的成员变量和函数，⽐如⽼师独有成员变量是职称，学⽣的独有成员变量是学号；学⽣的独有成员函数是学习，⽼师的独有成员函数是授课。

class Student
{ 
public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证void identity(){// ...} // 学习void study(){// ...}
protected:string _name = "peter"; // 姓名string _address; // 地址string _tel; // 电话int _age = 18; // 年龄int _stuid; // 学号
};class Teacher
{ 
public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证void identity(){// ...} // 授课void teaching(){//...}
protected:string _name = "张三"; // 姓名int _age = 18; // 年龄string _address; // 地址string _tel; // 电话string _title; // 职称
};int main()
{return 0;
}

下⾯我们公共的成员都放到Person类中，Student和teacher都继承Person，就可以复用这些成员，就不需要重复定义了，省去了很多麻烦。

class Person
{ 
public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证void identity(){cout << "void identity()" <<_name<< endl;}
protected:string _name = "张三"; // 姓名string _address; // 地址string _tel; // 电话int _age = 18; // 年龄
};class Student : public Person
public:// 学习void study(){// ...}
protected:int _stuid; // 学号
};class Teacher : public Person
{ 
public:// 授课void teaching(){//...}
protected:string title; // 职称
};
int main()
{Student s;Teacher t;s.identity();t.identity();return 0;
}

二、继承定义

1、定义格式

下⾯我们看到Person是基类，也称作⽗类。Student是派⽣类，也称作⼦类。(因为翻译的原因，所以既叫基类/派⽣类，也叫⽗类/⼦类)
在这里插入图片描述
在这里插入图片描述

2、继承基类成员访问方式的变化

类成员/继承方式publicprotectedprivate
基类public派生类public派生类protected派生类private
基类protected派生类protected派生类protected派生类private
基类private派生类中不可见派生类中不可见派生类中不可见
  1. 基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。这⾥的不可⻅是指基类的私有成员还是被继承到了派⽣类对象中，但是语法上限制派生类对象不管在类里面还是类外⾯都不能去访问它。
  2. 基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
  3. 实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在派⽣类都是不可⻅。基类的其他成员在派⽣类的访问⽅式 == Min(成员在基类的访问限定符，继承⽅式)，public > protected > private。
  4. 使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最好显示的写出继承方式。
  5. 在实际运用中⼀般使⽤都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派⽣类的类里面使用，实际中扩展维护性不强。
// 实例演⽰三种继承关系下基类成员的各类型成员访问关系的变化
class Person
{
public :void Print(){cout << _name << endl;}
protected:string _name; // 姓名
private:int _age; // 年龄
};
//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected :int _stunum; // 学号
};
int main()
{Student xz;xz.Print();return 0;
}

3、继承类模板

namespace bit
{//template<class T>//class vector//{};// stack和vector的关系，既符合is-a，也符合has-atemplate<class T>class stack : public std::vector<T>{ public:void push(const T& x){// 基类是类模板时，需要指定⼀下类域，// 否则编译报错:error C3861: “push_back”: 找不到标识符// 因为stack<int>实例化时，也实例化vector<int>了// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到vector<T>::push_back(x);//push_back(x);} void pop(){vector<T>::pop_back();} const T& top(){return vector<T>::back();} bool empty(){return vector<T>::empty();}};
} 
int main()
{bit::stack<int> st;st.push(1);st.push(2);st.push(3);while (!st.empty()){cout << st.top() << " ";st.pop();} return 0;
}

三、基类和派生类间的转换

  1. public继承的派生类对象可以赋值给基类的指针 / 基类的引用。这里有个形象的说法叫切⽚或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
  2. 基类对象不能赋值给派生类对象。
  3. 基类的指针或者引⽤可以通过强制类型转换赋值给派生类的指针或者引⽤。但是必须是基类的指针是指向派生类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。
    在这里插入图片描述
class Person
{ 
protected :string _name; // 姓名string _sex; // 性别int _age; // 年龄
};
class Student : public Person
{ 
public :int _No ; // 学号
};
int main()
{Student sobj ;// 1.派⽣类对象可以赋值给基类的指针/引⽤Person* pp = &sobj;Person& rp = sobj;// ⽣类对象可以赋值给基类的对象是通过调⽤基类的拷⻉构造完成的Person pobj = sobj;//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错sobj = pobj;return 0;
}

1、继承中的作用域

2、隐藏规则：

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏(在派生类成员函数中，可以使用基类::基类成员显示访问)。
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆
class Person
{ 
protected :string _name = "⼩李⼦"; // 姓名int _num = 111; // ⾝份证号
};
class Student : public Person
{ 
public:void Print(){cout<<" 姓名:"<<_name<< endl;cout<<" ⾝份证号:"<<Person::_num<< endl;cout<<" 学号:"<<_num<<endl;}
protected:int _num = 999; // 学号
};
int main()
{Student s1;s1.Print();return 0;
}

四、派生类的默认成员函数

1、4个常见默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会变我们自动生成⼀个，那么在派生类中，这几个成员函数是如何生成的呢？

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派⽣类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的operator=隐藏了基类的operator=，所以显示调⽤基类的operator=，需要指定基类作用域
  4. 派生类的析构函数会在被调⽤完成后⾃动调⽤基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派⽣类对象初始化先调⽤基类构造再调派⽣类构造。
  6. 派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。
  7. 因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。
    在这里插入图片描述
    在这里插入图片描述
class Person
{ 
public :Person(const char* name = "peter"): _name(name ){cout<<"Person()" <<endl;} Person(const Person& p): _name(p._name){cout<<"Person(const Person& p)" <<endl;} Person& operator=(const Person& p ){cout<<"Person operator=(const Person& p)"<< endl;if (this != &p)_name = p ._name;return *this ;} ~Person(){cout<<"~Person()" <<endl;}
protected :string _name ; // 姓名
};class Student : public Person
{ 
public :Student(const char* name, int num): Person(name), _num(num ){cout<<"Student()" <<endl;} Student(const Student& s): Person(s), _num(s ._num){cout<<"Student(const Student& s)" <<endl ;} Student& operator = (const Student& s ){cout<<"Student& operator= (const Student& s)"<< endl;if (this != &s){// 构成隐藏，所以需要显⽰调⽤Person::operator =(s);_num = s ._num;} return *this ;} ~Student(){cout<<"~Student()" <<endl;}
protected :int _num ; //学号
};
int main()
{Student s1 ("jack", 18);Student s2 (s1);Student s3 ("rose", 17);s1 = s3 ;return 0;
}

2、实现⼀个不能被继承的类

  1. 基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。
  2. C++11新增了⼀个final关键字，final修改基类，派生类就不能继承了。
// C++11的⽅法
class Base final
{ 
public:void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
private:// C++98的⽅法/*Base(){}*/
};class Derive :public Base
{void func4() { cout << "Derive::func4" << endl; }
protected:int b = 2;
};
int main()
{Base b;Derive d;return 0;
}

五、继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员。

class Student;
class Person
{ 
public:friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};class Student : public Person
{ 
protected:int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl;
} 
int main()
{Person p;Student s;// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员// 解决⽅案：Display也变成Student 的友元即可Display(p, s);return 0;
}

六、继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有⼀个这样的成员。无论派生出多少个派生类，都只有⼀个static成员实例。

class Person
{ 
public:string _name;static int _count;
};
int Person::_count = 0;class Student : public Person
{ 
protected:int _stuNum;
};
int main()
{Person p;Student s;// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份cout << &p._name << endl;cout << &s._name << endl;// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的// 说明派⽣类和基类共⽤同⼀份静态成员cout << &p._count << endl;cout << &s._count << endl;// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员cout << Person::_count << endl;cout << Student::_count << endl;return 0;
}

七、多继承及其菱形继承问题

1、继承模型

单继承：一个派生类只有⼀个直接基类时称这个继承关系为单继承。

多继承：⼀个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面。

菱形继承：菱形继承是多继承的⼀种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。
在这里插入图片描述

class Person
{ 
public:string _name; // 姓名
};class Student : public Person
{ 
protected:int _num; //学号
};class Teacher : public Person
{ 
protected:int _id; // 职⼯编号
};class Assistant : public Student, public Teacher
{ 
protected:string _majorCourse; // 主修课程
};
int main()
{// 编译报错：error C2385: 对“_name”的访问不明确Assistant a;a._name = "peter";// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决a.Student::_name = "xxx";a.Teacher::_name = "yyy";return 0;
}

2、虚继承

很多⼈说C++语法复杂，其实多继承就是⼀个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有⼀些损失，所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之⼀，后来的⼀些编程语言都没有多继承，如Java。

class Person
{ 
public:string _name; // 姓名/*int _tel;int _age;string _gender;string _address;*/// ...
};
// 使⽤虚继承Person类
class Student : virtual public Person
{ 
protected:int _num; //学号
};
// 使⽤虚继承Person类
class Teacher : virtual public Person
{ 
protected:int _id; // 职⼯编号
};
// 教授助理
class Assistant : public Student, public Teacher
{ 
protected:string _majorCourse; // 主修课程
};
int main()
{// 使⽤虚继承，可以解决数据冗余和⼆义性Assistant a;a._name = "peter";return 0;
}

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，无论是使用还是底层都会复杂很多。当然有多继承语法支持，就⼀定存在会设计出菱形继承，像Java是不支持多继承的，就避开了菱形继承。

class Person
{ 
public:Person(const char* name):_name(name){}string _name; // 姓名
};class Student : virtual public Person
{ 
public:Student(const char* name, int num):Person(name),_num(num){}
protected:int _num; //学号
};class Teacher : virtual public Person
{ 
public:Teacher(const char* name, int id):Person(name), _id(id)
{}
protected:int _id; // 职⼯编号
};
// 不要去玩菱形继承
class Assistant : public Student, public Teacher
{ 
public:Assistant(const char* name1, const char* name2, const char* name3):Person(name3),Student(name1, 1),Teacher(name2, 2){}
protected:string _majorCourse; // 主修课程
};
int main()
{// 思考⼀下这⾥a对象中_name是"张三", "李四", "王五"中的哪⼀个？Assistant a("张三", "李四", "王五");return 0;
}

八、继承和组合

1、继承和组合

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

// Tire(轮胎)和Car(⻋)更符合has-a的关系
class Tire 
{
protected:string _brand = "Michelin"; // 品牌size_t _size = 17; // 尺⼨
};class Car 
{
protected:string _colour = "⽩⾊"; // 颜⾊string _num = "陕ABIT00"; // ⻋牌号Tire _t1; // 轮胎Tire _t2; // 轮胎Tire _t3; // 轮胎Tire _t4; // 轮胎
};class BMW : public Car 
{
public:void Drive() { cout << "好开-操控" << endl; }
};
// Car和BMW/Benz更符合is-a的关系
class Benz : public Car 
{
public:void Drive() { cout << "好坐-舒适" << endl; }
};
template<class T>
class vector
{};
// stack和vector的关系，既符合is-a，也符合has-a
template<class T>
class stack : public vector<T>
{};
template<class T>
class stack{ 
public:vector<T> _v;
};
int main()
{return 0;
}

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

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

相关文章

基于s32ds平台指定变量储存位置

基于s32ds平台指定变量储存位置

开启一段ram空间 打开ld文件 配置一段ram空间 开辟一个段 .shareable_data1 : {. ALIGN(4);KEEP(*(.mcal_shared_data1)) . ALIGN(4);} > int_sram_shareable1定义一个变量并将变量指定在段中 volatile uint32 u32SbcmGenState __attribute__((section (".mcal_s…
阅读更多...
Spring MVC：精通JSON数据返回的几种高效方式

Spring MVC：精通JSON数据返回的几种高效方式

前言 在实际开发中&#xff0c;我们在前后端传送数据通常使用Json格式&#xff0c;而在Spring MVC中返回Json格式的方式有多种&#xff0c;接下来我将介绍其中一些。 准备工作 为了演示Json格式的数据&#xff0c;我们准备一个实体类&#xff0c;例如User&#xff0c;这些可以测…
阅读更多...
HUAWEI_HCIA_实验指南_Lib2.1_交换机基础配置

HUAWEI_HCIA_实验指南_Lib2.1_交换机基础配置

1、原理概述 交换机之间通过以太网电接口对接时需要协商一些接口参数&#xff0c;比如速率、双工模式等。交换机的全双工是指交换机在发送数据的同时也能够接收数据&#xff0c;两者同时进行。就如平时打电话一样&#xff0c;说话的同时也能够听到对方的声音。而半双工指在同一…
阅读更多...
Json-Rpc框架（项目设计 —— 服务端客户端 模块功能划分简介）

Json-Rpc框架（项目设计 —— 服务端客户端 模块功能划分简介）

阅读导航 引言一、理解项目功能⭕分布式RPC服务发现/注册/订阅/创建 结构图⭕项目三大核心功能 二、服务端模块划分简介三、客户端模块划分简介 引言 在上一篇文章中&#xff0c;我们深入探讨了Json-Rpc框架中不可或缺的序列化与反序列化利器——JsonCpp库。 在本篇文章中&am…
阅读更多...
Github 2024-10-11 Java开源项目日报 Top9

Github 2024-10-11 Java开源项目日报 Top9

根据Github Trendings的统计，今日(2024-10-11统计)共有9个项目上榜。根据开发语言中项目的数量，汇总情况如下： 开发语言项目数量Java项目9TypeScript项目1Vue项目1C++项目1JeecgBoot 企业级低代码开发平台 创建周期：2062 天开发语言：Java, Vue协议类型：Apache License 2.…
阅读更多...
性能测试流程规范测试准备阶段

性能测试流程规范测试准备阶段

目录 1.目的 2.工作内容 3.材料 1)《性能测试脚本规范》。 2)《性能测试参数文件检查备份指南》。 3)《性能测试资源监控操作指南》。 4)《脚本开发参数化》。 5)《脚本开发异常捕获处理》。 6)测试脚本文件。 7)模拟器代码文件。 8)生产环境参数配置文件。 9)《XX…
阅读更多...
解决 IntelliJ IDEA 运行时 “Command line is too long“ 问题

解决 IntelliJ IDEA 运行时 “Command line is too long“ 问题

文章目录 文章标题&#xff1a;解决 IntelliJ IDEA 运行时 "Command line is too long" 问题简介问题描述解决方案代码示例代码示例1&#xff1a;使用JAR Manifest代码示例2&#xff1a;使用Classpath File代码示例3&#xff1a;优化项目依赖 结论进一步的资源 文章标…
阅读更多...
【C++入门篇 - 1】：C++编程等演示环境介绍

【C++入门篇 - 1】：C++编程等演示环境介绍

文章目录 C编程等演示环境介绍VS2022的下载创建项目运行一个基本程序 Visual Studio中程序的调试方法普通的断点调试调试时查看内存中的内容调试中查看反汇编窗口 开启isual Studio 2019对C最新标准的编译支持 C编程等演示环境介绍 VS2022的下载 官网&#xff1a;VS下载官网 …
阅读更多...
ProtoBuf 安装

ProtoBuf 安装

一、ProtoBuf 在 window 下的安装 1.1、下载 ProtoBuf 编译器 下载地址&#xff1a;https://github.com/protocolbuffers/protobuf/releases 可以不⽤下载最新版本&#xff0c;具体的下载根据电脑情况选择。 下载之后将压缩包解压到本地⽬录下。解压后的⽂件内包含 bin、in…
阅读更多...
利用网络流量分析仪进行网络故障排除：提升IT运维效率的关键工具

利用网络流量分析仪进行网络故障排除：提升IT运维效率的关键工具

目录 一、什么是网络流量分析仪&#xff1f; 主要功能&#xff1a; 二、为什么网络流量分析仪在网络故障排除中如此重要&#xff1f; 三、实际案例&#xff1a;使用网络流量分析仪快速排查网络故障 案例一&#xff1a;流量拥塞导致的带宽不足 案例二&#xff1a;服务器响…
阅读更多...
【Kubernets】容器网络基础二：通讲CNI（Container Network Interface）容器网络接口实现方案

【Kubernets】容器网络基础二：通讲CNI（Container Network Interface）容器网络接口实现方案

文章目录 背景知识Underlay网络Overlay网络一、基本概念二、工作原理三、实现方案四、应用场景 两者对比示意图 CNI实现有哪些&#xff1f;FlannelFlannel 的工作原理Flannel 的主要组件数据传输机制总结 Calico一、架构基础二、核心组件与功能三、路由与数据包转发四、安全策略…
阅读更多...
精华版80页PPT | 智能工厂数字化顶层架构

精华版80页PPT | 智能工厂数字化顶层架构

项目背景及需求理解 随着科技的飞速发展&#xff0c;智能工厂的概念逐渐从理论走向实践&#xff0c;成为制造业转型升级的重要方向。方案对智能工厂数字化顶层架构进行全面介绍。在当前的市场环境下&#xff0c;消费者需求日益多样化、个性化&#xff0c;对产品质量、价格、环…
阅读更多...
PMP--冲刺题--解题--121-130

PMP--冲刺题--解题--121-130

文章目录 9.资源管理--1.规划资源管理--可以直接使用排除法&#xff0c;A和C的做法都是逃避了组织和参与这个会议&#xff0c;D组织多次会议的做法明显不够高效。121、 [单选] 项目经理被指派与技术和运营团队一起负责现有产品新版本的设计。项目经理组织一次联合需求会议&…
阅读更多...
【拥抱AIGC】应该如何衡量AI辅助编程带来的收益

【拥抱AIGC】应该如何衡量AI辅助编程带来的收益

本文主要介绍了如何度量研发效能&#xff0c;以及AI辅助编程是如何影响效能的&#xff0c;进而阐述如何衡量AI辅助编程带来的收益。 理解度量&#xff1a;有效区分度量指标 为了帮助研发团队更好地理解和度量研发效能&#xff0c;可以将指标分为三类&#xff1a;能力和行为指…
阅读更多...
【C++入门篇 - 3】：从C到C++第二篇

【C++入门篇 - 3】：从C到C++第二篇

文章目录 从C到C第二篇new和delete命名空间命名空间的访问 cin和coutstring的基本使用 从C到C第二篇 new和delete 在C中用来向系统申请堆区的内存空间 New的作用相当于C语言中的malloc Delete的作用相当于C语言中的free 注意&#xff1a;在C语言中&#xff0c;如果内存不够…
阅读更多...
【数学分析笔记】第5章第1节 微分中值定理（1）

【数学分析笔记】第5章第1节 微分中值定理（1）

5. 微分中值定理及其应用 5.1 微分中值定理 5.1.1 极值与极值点 【定义5.1.1】 f ( x ) f(x) f(x)定义域为 ( a , b ) (a,b) (a,b)&#xff0c; x 0 ∈ ( a , b ) x_0\in(a,b) x0​∈(a,b)&#xff0c;若 ∃ O ( x 0 , ρ ) ⊂ ( a , b ) \exists O(x_0,\rho)\subset(a,b) ∃…
阅读更多...
web基础-攻防世界

web基础-攻防世界

get-post 一、WP &#xff08;题目本质&#xff1a;get与post传参方法&#xff09; 用 GET 给后端传参的方法是&#xff1a;在?后跟变量名字&#xff0c;不同的变量之间用&隔开。例如&#xff0c;在 url 后添加/&#xff1f;a1 即可发送 get 请求。 利用 hackbar 进行…
阅读更多...
岩石分类检测数据集 4700张 岩石检测 带标注 voc yolo 9类

岩石分类检测数据集 4700张 岩石检测 带标注 voc yolo 9类

岩石分类检测数据集 4700张 岩石检测 带标注 voc yolo 9类 岩石分类检测数据集 (Rock Classification and Detection Dataset) 描述: 本数据集旨在支持对不同类型的岩石进行自动分类和检测&#xff0c;特别适用于地质勘探、矿物识别、环境监测等领域。通过使用该数据集训练的模…
阅读更多...
Python画图|多图共享X轴和Y轴

Python画图|多图共享X轴和Y轴

【1】引言 在python画图的众多场景中&#xff0c;存在多图对应X轴和Y轴可能一致的情形。 为此&#xff0c;尝试找到相关方法&#xff0c;不仅可以将代码写得更简洁&#xff0c;也更节省电脑内存&#xff0c;是提升工作效率的可选之路。 【2】官网教程 点击下方链接&#xf…
阅读更多...
制造已然走出国门，数据如何走向全球？

制造已然走出国门，数据如何走向全球？

1 行业趋势和背景 1.1 海外全球化——由中国制造到中国品牌全球造的全球化布局 为实现资源的最优配置、效率的最大化&#xff0c;现在越来越多的制造业企业&#xff0c;凭借着自己的品牌力和技术能力&#xff0c;进行全球化布局&#xff0c;加速从原来的“中国制造”到“中国…
阅读更多...
最新文章

Copyright @ 2022~2023