【C++庖丁解牛】继承的概念及定义 | 继承中的作用域 | 继承与友元继承与静态成员 | 复杂的菱形继承及菱形虚拟继承

🍁你好，我是 RO-BERRY
📗 致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识
🎄感谢你的陪伴与支持 ，故事既有了开头，就要画上一个完美的句号，让我们一起加油

在这里插入图片描述

目录

  • 1.继承的概念及定义
    • 1.1继承的概念
    • 1.2 继承定义
      • 1.2.1定义格式
      • 1.2.2继承关系和
      • 1.2.3继承基类成员访问方式的变化
  • 2.基类和派生类对象赋值转换
  • 3.继承中的作用域
  • 4.派生类的默认成员函数
  • 5.继承与友元
  • 6. 继承与静态成员
  • 7.复杂的菱形继承及菱形虚拟继承
    • 虚拟继承
    • 虚拟继承解决数据冗余和二义性的原理
  • 8.继承的总结和反思

1.继承的概念及定义

1.1继承的概念

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

继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。.

#include<iostream>
using namespace std;
class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}
protected:string _name = "peter"; // 姓名int _age = 18;   //年龄
};
class Student : public Person
{
protected:int _stuid; // 学号
};
class Teacher : public Person
{
protected:int _jobid; // 工号
};
int main()
{Student s;Teacher t;s.Print();t.Print();return 0;
}

在这里插入图片描述

1.2 继承定义

1.2.1定义格式

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类
在这里插入图片描述

1.2.2继承关系和

在这里插入图片描述

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

类成员/继承方式public继承protected继承private继承
基类的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继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

2.基类和派生类对象赋值转换

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time TypeInformation)的dynamic_cast 来进行识别后进行安全转换。（ps：这个我们后面再讲解，这里先了解一下）

在这里插入图片描述


class Person
{
protected:string _name; // 姓名string _sex; // 性别int _age; // 年龄
};
class Student : public Person
{
public:int _No; // 学号
};
void Test()
{Student sobj;// 1.子类对象可以赋值给父类对象/指针/引用Person pobj = sobj;Person* pp = &sobj;Person& rp = sobj;//2.基类对象不能赋值给派生类对象sobj = pobj;// 3.基类的指针可以通过强制类型转换赋值给派生类的指针pp = &sobj;Student * ps1 = (Student*)pp; // 这种情况转换时可以的。ps1->_No = 10;pp = &pobj;Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题ps2->_No = 10;}

3.继承中的作用域

  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; // 学号
};
void Test()
{Student s1;s1.Print();
};

这里有一个经典题目
A类的fun函数与A类的fun函数是什么关系？
A.没有关系
B.重载
C.重写
D.隐藏

class A
{
public:void fun(){cout << "func()" << endl;}
};
class B : public A
{
public:void fun(int i){A::fun();cout << "func(int i)->" << i << endl;}
};int main()
{A a;B b;b.fun();return 0;
}

在这里我们调用的是父类的函数fun还是子类的函数fun呢？
在这里插入图片描述
我们想运行却出现了错误提示

隐藏：：子类会隐藏父类同名成员
如果是成员函数：函数名相同就构成隐藏（返回值和参数可以不同）

我们想运行A的fun函数需要加上作用域：

class A
{
public:void fun(){cout << "func()" << endl;}
};
class B : public A
{
public:void fun(int i){A::fun();cout << "func(int i)->" << i << endl;}
};
int main()
{A a;B b;b.fun(1);b.A::fun();return 0;
}

在这里插入图片描述

4.派生类的默认成员函数

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

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派生类对象初始化先调用基类构造再调派生类构造。
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。
  7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加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; //学号
};
void Test()
{Student s1("jack", 18);cout << endl;Student s2(s1);cout << endl;Student s3("rose", 17);cout << endl;s1 = s3;cout << endl;}int main()
{Test();return 0;
}

运行结果：
在这里插入图片描述

构造函数： 先父后子
析构函数： 先子后父，如果析构函数先父后子，是存在安全隐患的，可能父类资源已经清理释放了，子类析构函数又去调用访问，存在野指针等风险

5.继承与友元

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

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;Display(p, s);return 0;
}

在这里Display是父类的友元函数，所以我们在类外定义的时候，Display是可以访问到父类成员_name的，但是这个友元函数是不可以继承的，所以在类外定义的时候Display无法访问到子类成员_stuNum，所以在这里会报错。如果我们也想访问子类成员，就需要在子类重新定义友元函数Display

class Student;
class Person
{
public:friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};
class Student : public Person
{
public:friend void Display(const Person& p, const Student& s);
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;Display(p, s);return 0;
}

父类的友元并不是子类的友元，通俗的将父亲的朋友不会是你的朋友，你需要自己去交朋友

6. 继承与静态成员

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

我们来观察下面实例：

class Person
{
public:Person() { ++_count; }
protected:string _name; // 姓名
public:static int _count; // 统计人的个数。
};int Person::_count = 0;class Student : public Person
{
protected:int _stuNum; // 学号
};class Graduate : public Student
{
protected:string _seminarCourse; // 研究科目
};
void TestPerson()
{Student s1;Student s2;Student s3;Graduate s4;cout << " 人数 :" << Person::_count << endl;cout << " 人数 :" << Student::_count << endl;cout << " 人数 :" << Graduate::_count << endl;Student::_count = 0;cout << " 人数 :" << Person::_count << endl;
cout << " 人数 :" << Student::_count << endl;cout << " 人数 :" << Graduate::_count << endl;
}int main()
{TestPerson();return 0;
}

在这里插入图片描述

由输出结果可以看到，静态成员是继承下来了的，因为我们访问三个不同类的静态成员均可以访问到，但是静态成员无论怎么继承都只会有一个，因此他们访问到的是同一个静态成员，并且我们对静态成员进行修改，发现三个类的静态成员均被修改

7.复杂的菱形继承及菱形虚拟继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

在这里插入图片描述

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

在这里插入图片描述

菱形继承：菱形继承是多继承的一种特殊情况。

在这里插入图片描述

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
在Assistant的对象中Person成员会有两份。

在这里插入图片描述
我们来看如下代码：

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; // 主修课程
};
void Test()
{Assistant a;a._name = "peter";      //编译器检查报错a.Student::_name = "xxx";a.Teacher::_name = "yyy";
}
int main()
{Test();return 0;
}

这里的a._name编译器无法识别，这样会有二义性无法明确知道访问的是哪一个，需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决

在这里插入图片描述

虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

虚拟继承是C++中的一种特殊的继承方式，它用于解决多继承时可能出现的菱形继承问题。在菱形继承中，如果一个派生类同时继承了两个基类，而这两个基类又共同继承自同一个基类，就会导致派生类中存在两份来自同一个基类的成员，从而引发二义性问题。

虚拟继承通过在派生类对共同基类的继承前加上关键字"virtual"来解决这个问题。使用虚拟继承后，派生类只会包含一份共同基类的成员，从而消除了二义性。

虚拟继承的使用方法如下：

class Person
{
public:string _name; // 姓名
};class Student : virtual public Person
{
protected:int _num; //学号
};class Teacher : virtual public Person
{
protected:int _id; // 职工编号
};class Assistant : public Student, public Teacher
{
protected:string _majorCourse; // 主修课程
};void Test()
{Assistant a;a._name = "peter";
}int main()
{Test();return 0;
}

在上述代码中，Student 和Teacher 都使用了虚拟继承来继承Person类。而Assistant 则同时继承了Student 和Teacher 。这样，无论通过Assistant 访问Person类的成员还是通过Student 或Teacher 访问，都只会有一份Person类的成员。

虚拟继承的情况下，无论基类被继承多少次，只会存在一个实体。 虚拟继承基类的子类中，子类会增加某种形式的指针，或者指向虚基类子对象，或者指向一个相关的表格；表格中存放的不是虚基类子对象的地址，就是其偏移量，此类指针被称为bptr。

虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成
员的模型。

class A
{
public:int _a;
};
// class B : public A
class B : virtual public A
{
public:int _b;
};
// class C : public A
class C : virtual public A
{
public:int _c;
};
class D : public B, public C
{
public:int _d;
};
int main()
{D d;d.B::_a = 1;d.C::_a = 2;d._b = 3;d._c = 4;d._d = 5;return 0;
}

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余（没有用虚拟继承）
这一整块表是d，d里面前两个地址为B，B里面有A的成员，为第一个地址存放；三四个地址为C，C里面有A的成员，为第三个地址存放；最后一个地址为D的成员，很显然有两个A，又数据冗余

在这里插入图片描述

下图是菱形虚拟继承的内存对象成员模型：
这一整块表是d

  1. 前两个地址为B，B里面第一个地址原存放A成员的地方,这里为一个指针，我们将其打开可以看到，其中存着的是0和一个偏移量，我们可以发现我们使用B的地址加上这个偏移量，其指向的地址就是A成员的地址；
  2. 三四个地址为C，C里面第一个地址原存放A成员的地方,这里为一个指针，我们将其打开可以看到，其中存着的是0和一个偏移量，我们可以发现我们使用C的地址加上这个偏移量，其指向的地址就是A成员的地址；
  3. 倒数第二个地址为D的成员，A成员放在最后一个地址，在这里可以看到，A成员被单独存放，而不是BC两个各有一份。

分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。

在这里插入图片描述
有童鞋会有疑问为什么D中B和C部分要去找属于自己的A？那么大家看看当下面的赋值发生时，d是不是要去找出B/C成员中的A才能赋值过去？

D d;
B b = d;
C c = d;

下面是上面的Person关系菱形虚拟继承的原理解释：
在这里插入图片描述

8.继承的总结和反思

  1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
  2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。
  3. 继承和组合：public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
  4. 优先使用对象组合，而不是类继承 。
  5. 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
  6. 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
  7. 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
// Car和BMW Car和Benz构成is-a的关系
class Car {
protected:string _colour = "白色"; // 颜色string _num = "陕ABIT00"; // 车牌号
};class BMW : public Car {
public:void Drive() { cout << "好开-操控" << endl; }
};class Benz : public Car {
public:void Drive() { cout << "好坐-舒适" << endl; }
};// Tire和Car构成has-a的关系class Tire {
protected:string _brand = "Michelin";  // 品牌size_t _size = 17;         // 尺寸};class Car {
protected:string _colour = "白色"; // 颜色string _num = "陕ABIT00"; // 车牌号Tire _t; // 轮胎
};

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

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

相关文章

【漏洞复现】用友U8Cloud base64 SQL注入漏洞

【漏洞复现】用友U8Cloud base64 SQL注入漏洞

0x01 产品简介 用友U8 Cloud是用友推出的新一代云ERP&#xff0c;主要聚焦成长型、创新型企业&#xff0c;提供企业级云ERP整体解决方案。 0x02 漏洞概述 用友U8 Cloud 存在SQL注入漏洞&#xff0c;未授权的攻击者可通过此漏洞获取数据库权限&#xff0c;从而盗取用户数据&a…
阅读更多...
KVM安装-kvm彻底卸载-docker安装Webvirtmgr

KVM安装-kvm彻底卸载-docker安装Webvirtmgr

KVM安装和使用 一、安装 检测硬件是否支持KVM需要硬件的支持，使用命令查看硬件是否支持KVM。如果结果中有vmx（Intel）或svm(AMD)字样，就说明CPU的支持的 egrep ‘(vmx|svm)’ /proc/cpuinfo关闭selinux将 /etc/sysconfig/selinux 中的 SELinux=enforcing 修改为 SELinux=d…
阅读更多...
AI预测福彩3D第13弹【2024年3月19日预测--第3套算法重新开始计算第2次测试】

AI预测福彩3D第13弹【2024年3月19日预测--第3套算法重新开始计算第2次测试】

今天咱们继续对第3套算法进行第2次测试&#xff0c;第3套算法加入了012路的权重。废话不多说了&#xff0c;直接上结果吧~ 最终&#xff0c;经过研判分析&#xff0c;2024年3月19日福彩3D的七码预测结果如下&#xff1a; 百位&#xff1a;0 1 3 4 2 7 9&#xff08;6换9&#x…
阅读更多...
LCR144翻转二叉树（力扣简单题，Java，递归+非递归）

LCR144翻转二叉树（力扣简单题，Java，递归+非递归）

目录 题目描述&#xff1a; 递归代码1&#xff1a; 递归代码2&#xff1a; 非递归代码&#xff08;层次遍历&#xff09;&#xff1a; 题目描述&#xff1a; 给定一棵二叉树的根节点 root&#xff0c;请左右翻转这棵二叉树&#xff0c;并返回其根节点。 示例 1&#xff1a;…
阅读更多...
如何在iOS系统抓取log

如何在iOS系统抓取log

前言&#xff1a;因为作者目前工作领域和苹果智能家居有关&#xff0c;然后发现一些bug其实是apple sdk原生code的问题&#xff0c;所以需要给apple提radar单&#xff0c;就需要抓ios端Log充当证据给apple看&#xff0c;其实ios抓log非常简单&#xff0c;大家感兴趣可以学习下哦…
阅读更多...
VS2022 配置QT5.9.9

VS2022 配置QT5.9.9

QT安装 下载地址&#xff1a;https://download.qt.io/archive/qt/ 下载安装后进行配置 无法运行 rc.exe 下载VS2022 官网下载 配置 1.扩展-管理扩展-下载Qt Visual Studio Tools 安装 2.安装完成后&#xff0c;打开vs2022,点击扩展&#xff0c;会发现多出了QT VS Tools,点…
阅读更多...
爱恩斯坦棋小游戏使用C语言+ege/easyx实现

爱恩斯坦棋小游戏使用C语言+ege/easyx实现

目录 1、游戏介绍和规则 2、需要用到的头文件 3、这里我也配上一个ege和easyx的下载链接吧&#xff0c;应该下一个就可以 4、运行结果部分展示 5、需要用到的图片要放在代码同一文件夹下 6、代码地址&#xff08;里面有需要用到的图片&#xff09; 1、游戏介绍和规则 规则如…
阅读更多...
简单介绍注册波兰公司的基本条件

简单介绍注册波兰公司的基本条件

波兰&#xff0c;一个位于中欧的国家&#xff0c;具有丰富的历史文化和资源&#xff0c;同时也拥有稳定的政治和经济环境。在这里&#xff0c;注册公司不仅有助于您拓展业务&#xff0c;还能享受到优惠的税收政策和良好的投资环境。下面&#xff0c;我们将详细介绍注册波兰公司…
阅读更多...
Footprint Analytics 强势入局 AI 推出全新投研工具

Footprint Analytics 强势入局 AI 推出全新投研工具

作者&#xff1a;lesleyfootprint.network 3 月 15 日&#xff0c;链上数据平台 Footprint Analytics 宣布入局 AI&#xff0c;推出了旗下首款 AI 投研工具—— Pea.AI。 作为专门服务于区块链行业的 AI 平台&#xff0c;Pea.AI 旨在提升加密资产投资领域的数据流动性和知识…
阅读更多...
镭速，企业传输大文件都在用的udp文件传输工具

镭速，企业传输大文件都在用的udp文件传输工具

在当今快速变化的数字世界中&#xff0c;文件传输工具已成为企业运营不可或缺的一部分。尤其是面对大文件传输的需求&#xff0c;传统的TCP协议由于其设计上的局限性&#xff0c;往往无法满足企业对高速、稳定传输的需求。这时&#xff0c;UDP文件传输工具以其独特的优势走进了…
阅读更多...
你知道吗？腾讯云服务器61元一年，2024又降价了

你知道吗？腾讯云服务器61元一年，2024又降价了

腾讯云服务器多少钱一年&#xff1f;61元一年起。2024年最新腾讯云服务器优惠价格表&#xff0c;腾讯云轻量2核2G3M服务器61元一年、2核2G4M服务器99元一年可买三年、2核4G5M服务器165元一年、3年756元、轻量4核8M12M服务器646元15个月、4核16G10M配置32元1个月、312元一年、8核…
阅读更多...
自注意力机制的理解

自注意力机制的理解

一、自注意力要解决什么问题 循环神经网络由于信息传递的容量以及梯度消失问题&#xff0c;只能建立短距离依赖关系。为了建立长距离的依赖关系&#xff0c;可以增加网络的层数或者使用全连接网络。但是全连接网络无法处理变长的输入序列&#xff0c;另外&#xff0c;不同的输…
阅读更多...
MySQL最实用面试题（2024-3-14持续更新中）

MySQL最实用面试题（2024-3-14持续更新中）

MySQL篇面试题 一、介绍 ​ 这是由小龙同学自己总结领悟的mysql面试题的解析&#xff0c;也是面试宝典 二、题目 1.数据库三大范式&#xff1a; –作用&#xff1a; ​ 使表结构清晰&#xff0c;减少数据冗余&#xff08;简单讲就是重复&#xff09;&#xff0c;提高查询…
阅读更多...
朋友圈运营小秘诀，让你事半功倍！

朋友圈运营小秘诀，让你事半功倍！

朋友圈已成为了现代社交的重要平台&#xff0c;如何在朋友圈中进行有效的运营&#xff0c;吸引更多的关注和互动&#xff0c;成为了许多人关注的焦点。 今天&#xff0c;我将分享一些朋友圈运营的小秘诀&#xff0c;帮助你事半功倍&#xff0c;让你的朋友圈更具吸引力&#xf…
阅读更多...
Qt学习--多态（虚函数）

Qt学习--多态（虚函数）

这次来分享多态的概念&#xff0c;这是比较重要的知识点 面向对象的三大特征&#xff1a;封装、继承、多态 首先&#xff1a;来点官方术语&#xff1a; 多态&#xff0c;通俗来讲就是多种形态&#xff0c;具体点就是去完成某个行为&#xff0c;当不同的对象去完成时会产生出…
阅读更多...
【鸿蒙系统】 ---Harmony 鸿蒙编译构建指导（一）

【鸿蒙系统】 ---Harmony 鸿蒙编译构建指导（一）

&#x1f48c; 所属专栏&#xff1a;【鸿蒙系统】 &#x1f600; 作  者&#xff1a;我是夜阑的狗&#x1f436; &#x1f680; 个人简介&#xff1a;一个正在努力学技术的CV工程师&#xff0c;专注基础和实战分享 &#xff0c;欢迎咨询&#xff01; &#x1f496; 欢…
阅读更多...
实践致知第10享：将微信中的Excel保存到本地并编辑、修改

实践致知第10享：将微信中的Excel保存到本地并编辑、修改

一、背景需求 小姑打电话问&#xff1a;学校在微信上发来的Excel表格&#xff0c;要求家长填报相关信息&#xff0c;不知道该怎么处理&#xff0c;于是我写了下面的操作步骤。 二、解决方案 1、在电脑上打开微信&#xff0c;选中Excel表格&#xff0c;右键选择“另存为”功能…
阅读更多...
jQuery 常用API

jQuery 常用API

一、jQuery 选择器 1.1 jQuery 基础选择器 原生 JS 获取元素方式很多&#xff0c;很杂&#xff0c;而且兼容性情况不一致&#xff0c;因此 jQuery 给我们做了封装&#xff0c;使获取元素统一标准。 1.2 jQuery 层级选择器 jQuery 设置样式 1.3 隐式迭代&#xff08;重要&…
阅读更多...
魔搭×函数计算：一键部署，缩短大模型选型到生产的距离

魔搭×函数计算：一键部署，缩短大模型选型到生产的距离

引言 面对魔搭 ModelScope 社区提供的海量模型&#xff0c;用户希望快速进行选型并生产使用起来&#xff0c;但在此之前&#xff0c;却一定会面临算力管理难、模型部署难等一系列问题&#xff0c;那么能否实现快速把选定的模型部署在云端功能强大的 GPU 上&#xff0c;由云端负…
阅读更多...
详析中间人问题

详析中间人问题

详析中间人问题 正常情况 中间人 如何解决呢&#xff1f; 加证书 证书也有公钥和私钥 具体步骤如下&#xff1a; 1.服务器生成非对称密钥对 私钥和公钥的生成&#xff1a;服务器使用非对称加密算法&#xff08;如RSA、ECDSA&#xff09;生成一对密钥&#xff0c;包括一个私钥…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023