13.继承（基类、派生类、同名函数、同名变量、虚拟继承、虚拟继承的原理、继承关系和访问限定符）

1.继承的概念及定义

1.1继承的概念

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

// Person称为父类或者基类
class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}protected:string _name = "peter"; // 姓名private:int _age = 18;  // 年龄
};

// Student继承了Person （Student称为派生类或者子类）
class Student : public Person
{
protected:int _stuid; // 学号
};// Teacher继承了Person （Teacher称为派生类或者子类）
class Teacher : public Person
{
protected:int _jobid; // 工号
};int main()
{Student s;Teacher t;// 对基类成员函数和成员变量的复用s.Print();t.Print();return 0;
}
// 打印结果为：
// name: peter
// age : 18
// name: peter
// age : 18

  • Student继承父类后，父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。

  • Student被称为子类

  • Teacher继承父类后，父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。

  • Teacher被称为子类

  • 这里体现出了Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。(变量的复用)。

  • 调用Print可以看到成员函数的复用。（成员函数的复用）

  • 对成员变量的复用

image-20230418161337900

1.2 继承定义

1.2.1 定义格式

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。

image-20240416204735884

1.2.2继承关系和访问限定符

!image-20230418162039096

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

image-20230418162046732

总结：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。（被protected修饰的成员变量，只能够再类里面被访问，不可以在类外面被访问，但是派生类的内部是可以访问继承的基类的被protected的成员变量/成员函数）

  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(基类或者子类限制小的那一个，大小顺序为public > protected > private)。

  4. （如果我们的子类继承父类时，没有写继承的访问限定符）那么你的类使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/ private 继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

  • 实例演示三种继承关系下基类成员的各类型成员访问关系的变化
  • 场景一：私有继承
// 1.Person是基类
class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}protected:string _name = "peter"; // 姓名
private:int _age = 18; // 年龄
};
  • 私有继承
  • 类成员不可见（也就是成员被继承了，但是并不可以在子类中访问成员）
  • 基类中的成员变量_age为基类的私有成员变量，因此在派生类中是不可见的（不论哪种继承方式）
  • _name是基类被protected修饰的成员变量（因此是私有继承，所以在派生类中是私有成员变量）
  • Print()是基类被Public修饰的成员函数（因此是私有继承，所以在派生类中是私有成员函数）
    因为派生类的继承方式是private，因此成员变量和成员函数在基类中都是私有的
class Student : private Person
{
public:void Func(){// 此时print()为派生类Student的私有成员，因此只可以在类的内部调用// 如果我们想要在类的外部调用，可以通过Func()来调用// Func()函数是在类的内部调用的Print()函数Print();// _name被继承后，变为私有成员变量，因此是可以在类的内部进行访问的cout << "name:" << _name << endl;}protected:int _stunum; // 学号
};int main()
{Student s;return 0;
}
// 可以自己调试/打印查看
  • 场景二：保护继承（ protected）
  • 基类中的成员变量_age为基类的私有成员变量，因此在派生类中是不可见的（不论哪种继承方式）
  • _name是基类被protected修饰的成员变量（因此是保护继承，所以在派生类中是保护成员变量，只能在类内访问）
  • Print()是基类被Public修饰的成员函数（因此是保护继承，所以在派生类中是保护成员函数，只能在类内访问）
class Student : protected Person
{
public:void Func(){// _name被继承后，是子类的保护成员变量，因此只能够在子类的内部进行访问cout << "name:" << _name << endl;}protected:int _stunum; // 学号
};
  • 场景三：公有继承(pubilc)
    • 基类中的成员变量_age为基类的私有成员变量，因此在派生类中是不可见的（不论哪种继承方式）
    • _name是基类被protected修饰的成员变量（因此是公有继承，所以在派生类中是保护成员变量，只能在类内访问）
    • Print()是基类被Public修饰的成员函数（因此是公有继承，所以在派生类中是公有成员函数，类外也可以被访问）
class Student : public Person
{
public:void Func(){//_name依旧是保护成员，只能够在派生类的内部访问cout << "name:" << _name << endl;}protected:int _stunum; // 学号
};
  • 场景四： 如果我们没有显示写基类的继承方式，那么class默认是私有继承
class Student :  Person
{
public:void Func(){cout << "name:" << _name << endl;}protected:int _stunum; // 学号
};
  • 场景五： 如果我们没有显示写子类的继承方式，那么struct默认是公有继承
struct Student :  Person
{
public:void Func(){cout << "name:" << _name << endl;}protected:int _stunum; // 学号
};

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

  • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

  • 基类对象不能赋值给派生类对象。

  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：这个我们后面再介绍，这里先了解一下）

    image-20230418181713240

// 基类赋值给派生类的切片演示// 基类
class Person
{
protected:string _name; // 姓名string _sex;  // 性别
public:int	_age = 18;	 // 年龄
};// Person的派生类（公有继承）
class Student : public Person
{
public:int _No; // 学号
};

int main()
{// 两种不同的内置类型的赋值转换int i = 1;double d = 2.2;// d想要赋值给i，由于类型的不同，会生成一个临时变量，会将d强转为int类型，放入临时变量，再将临时变量赋值给i，又因为临时变量具有常性，因此如果要引用，就必须加const来修饰i = d;const int& ri = d;return 0;
}    

int main()
{// 派生类赋值给基类Person p;    // 基类Student s;   // 派生类// 派生类是包含有基类的类成员变量和类成员函数// 因此，当派生类对象赋值给基类对象时，中间不存在类型转换（也就是不需要临时变量）// s的类型是Student，是Person的继承（将派生类赋值给基类，会发生切片，会将派生类类中和基类共有的成员进行赋值）p = s;// 引用// 基类引用，引用的是派生类类对象中，属于基类的部分Person& rp = s;  // 通过打印来验证rp._age = 1;cout << rp._age << endl;cout << s._age << endl;// 打印结果都为：1// 指针// 基类的指针变量存放派生类的地址，指针指向的是派生类对象中，属于基类的部分Person* ptrp = &s;  // 通过打印来验证ptrp->_age++;cout << rp._age << endl;cout << s._age << endl;// 打印结果都为：2// 派生类中继承的基类成员的改变，并不会影响基类对象中成员变量的值cout << p._age << endl;// 打印结果为：18return 0;
}

3.继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。

  2. 派生类和基类中有同名成员，基类成员将屏蔽派生类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（但是在派生类成员函数中，可以使用 基类::基类成员 显示访问基类成员）

  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏（也就是成员函数传递的参数不需要相同）。

  4. 注意在实际中在继承体系里面最好不要定义同名的成员。

3.1 同名成员变量

// 基类Person
class Person
{
protected:// 姓名string _name = "小李子"; // 身份证号int _num = 111; 	  
};// 派生类（公有继承）
class Student : public Person
{
public:void Print(){cout << " 姓名:" << _name << endl;// 直接使用基类和派生类的同名成员变量，默认访问Stuent派生类作用域的成员_numcout << " 学号:" << _num<< endl;    // 如果想要使用基类的成员变量（同名的成员变量），那么必须使用 基类::基类成员 显示访问基类成员cout << " 身份证号:" << Person::_num << endl; }protected:int _num = 999; // 学号
};int main()
{Student s;s.print();return 0;
}

3.2 同名函数

  • 在下面的两个类中，基类中的func()，和派生类中的func()，两个func()函数是什么关系？
  • 有四个选项：重载 ， 重写， 重定义/隐藏， 编译报错
class A
{
public:void fun(){cout << "A::func()" << endl;}
};class B : public A
{
public:void fun(int i){cout << "B::func(int i)->" << i << endl;}
};void Test()
{B b;// 访问的是派生类B的成员函数func(int i)b.fun(10);// 访问的是基类A的成员函数fun()b.A::fun();
};int main()
{Test();
}
  • 正确选项 -> 重定义/隐藏
  • 基类和派生类类的同名成员函数，函数名相同就构成隐藏
// 下面的程序： 会编译报错
class A
{
public:void fun(){cout << "A::func()" << endl;}
};class B : public A
{
public:void fun(int i){cout << "B::func(int i)->" << i << endl;}
};void Test()
{B b;// 编译报错，这种是错误的写法// 如果想要访问基类的成员函数，应该这样使用 -> b.A::fun();// 如果想要访问派生类的成员函数fun(),应该这样使用 -> b.fun(10) , 这里的函数，必须传递一个参数b.fun();};int main()
{Test();return 0;
}

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

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

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

  5. 派生类对象初始化先调用基类构造再调派生类构造。

  6. 派生类对象析构清理先调用派生类析构再调基类的析构。

  7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。

image-20230418184739153

  • 基类
class Person
{
public:// 基类的构造函数Person(const char* name): _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:// 派生类的构造函数// Person为基类，因此必须调用基类Person的构造函数来对基类初始化  -> Person(name) // 如果基类构造函数为默认构造函数，则不需要专门调用基类的构造函数，编译器会默认初始化// 此处的基类Person的构造函数是自定义的构造函数，因此我们需要调用基类的构造函数，来对派生类中基类的那部分来进行初始化Student(const char*name, int num):Person(name)     , _num(num){}// 派生类的拷贝构造函数// 因为基类Person的拷贝构造函数是自定义的拷贝构造函数，因此想要拷贝派生类对象中属于基类的那一部分，就必须调用基类的拷贝构造函数来拷贝// Person(s) --> 传递的虽然是派生类的对象s，但是基类的拷贝构造的参数是Person类型的，// 因此Person类型的引用，引用的只是派生类对象中，属于基类的那一部分// (Person& p = s 引用的是派生类对象中属于基类的部分)Student(const Student& s):Person(s)        , _num(s._num){}// 派生类的赋值重载函数Student& operator=(const Student& s){if (this != &s){// 调用基类的赋值重载来完成派生类中属于基类的那一部分的赋值重载，// 传递参数对象s，也是切割派生类中属于基类部分进行传递// 派生类和基类的赋值重载，函数名相同(不需要看参数和返回值)，因此构成了重定义/隐藏// 因此必须加上基类的指定作用域，不然会默认调用派生类类的 operator=() 函数Person::operator=(s);// 属于派生类部分的赋值_num = s._num;}return *this;}// 第一怪：1、派生类析构函数和基类析构函数构成隐藏关系。//（由于多态关系需求，所有析构函数都会特殊处理成destructor函数名）// 第二怪：派生类类先析构，基类再析构。派生类类析构函数不需要显示调用基类析构函数，派生类析构后会自动调用基类析构~Student(){// 此处不需要显示调用基类的析构函数// 由于派生类析构后会调用基类的析构函数，如果我们再显示调用，就会造成多次析构，对同一块空间多次析构，编译器就会报错// Person::~Person();cout << "~Student()" << endl;}protected:int _num; //学号
};

int main()
{// 调用构造函数Student s1("张三", 18);//  调用拷贝构造函数Student s2(s1);Student s3("李四", 20);// 调用赋值重载函数s1 = s3;// 结束时，会自动调用析构函数return 0;
}

5.继承与友元

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

// 基类
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)
{// 因为基类里面有Display()的友元，因此可以访问基类的私有成员/保护成员cout << p._name << endl;   // 因为基类的友元并不可以被派生类继承，因此不可以访问派生类类的私有成员// 此处会报错，因为友元无法继承，因此不能够访问保护成员变量_stuNumcout << s._stuNum << endl; 
}int main()
{Person p;Student s;Display(p, s);return 0;
}

6. 继承与静态成员

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

// 基类
class Person
{
public:// 构造函数Person() { ++_count; }void Print(){cout << this << endl;              cout << _name << endl;          cout << _count << endl;}string _name; // 姓名
public:// 静态成员变量static int _count; // 统计人的个数。
};// 静态成员是全局的，因此在类外进行初始化
// 对静态成员变量_count 初始化
int Person::_count = 0;// 派生类
class Student : public Person
{
protected:int _stuNum; // 学号
};
  • 静态成员属于整个类和创建的所有对象。同时也属于所有派生类及创建的所有派生类对象
int main()
{Person p;Student s;// 以下的两个_name并不是同一个_name// 此处的_name是基类对象p的_namep._name = "张三";  // 此处的_name是派生类对象s的_name（派生类Student 继承了基类Person的成员变量_name）s._name = "李四";  // 因为_count 是静态成员变量，是存放在静态区的，因此基类和派生类调用的都是静态区的实例成员_countp._count++;s._count++;cout << p._count << endl;cout << s._count << endl;cout << &p._count << endl;cout << &s._count << endl;cout << Person::_count << endl;  // 也可以通过限定作用域去访问_countcout << Student::_count << endl;// 打印结果都是对应相同的// 此处会报错，因为ptr是指向空指针的，所以并没有存放_name的对象Person* ptr = nullptr;cout << ptr->_name << endl;  // Print()并没有存放在对象中，而是存放在代码段，(ptr-> 是用来指明类域的)因此可以正常运行ptr->Print();                // _count并没有存放在对象中，而是存放在静态区，(ptr-> 是用来指明类域的)因此可以正常运行cout << ptr->_count << endl; // 以下都可以正常运行，原因同上// (*ptr).Print() 和 ptr->_count是一样的效果(*ptr).Print();             cout << (*ptr)._count << endl; return 0;
}

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

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

image-20230429202129024

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

image-20240416214031317

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

image-20230429202213027

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

image-20240416214330490

// 基类
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()
{// 这样会有二义性无法明确知道访问的派生类Assitant的哪一个基类的_name// 因此，此处直接调用，编译器会报错Assistant a;a._name = "peter";// 需要显示指定访问哪个基类的成员可以解决二义性问题，但是数据冗余问题无法彻底解决a.Student::_name = "xxx";a.Teacher::_name = "yyy";
}

虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。

需要注意的是，虚拟继承不要在其他地方去使用。

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()
{// 使用虚拟继承之后，两个_name可以看做是一个_nameAssistant a;a._name = "peter";
}

虚拟继承的原理

  • 为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。
  • 没有使用虚拟继承
class A
{
public:int _a;
};class B : public A
{
public:int _b;
};class C : public A
{
public:int _c;
};class D : public B, public C
{
public:int _d;
};int main()
{D d;d._b = 1;d._c = 2;d._d = 3;// 此处必须指定类域，不然编译器无法判断访问的是B还是C的成员变量_ad.B::_a = 4;d.C::_a = 5;return 0;
}// 下图查看的是取对象d的地址的内存
// B继承了A,C也继承了A，因此B和C中都有4个字节的内存空间来存放其继承的A的成员
// 这样，也就导致继承B和C的D，无法判断访问的是B或者还是C的A的成员了

image-20230429204313712

  • 使用虚拟继承
class A
{
public:int _a;
};class B : virtual public A
{
public:int _b;
};class C : virtual public A
{
public:int _c;
};class D : public B, public C
{
public:int _d;
};int main()
{// 第一部分D d;d._b = 1;d._c = 2;d._d = 3;// 指定对应的类域进行赋值d.B::_a = 4;d.C::_a = 5;// 直接对基类的成员变量_a进行赋值d._a = 6;return 0;// 第二部分B b;b._a = 1;b._b = 2;B* ptr = &b;ptr->_a = 10;ptr->_b = 11;// 第三部分，将d切片，赋值给bptr = &d;ptr->_a = 20;ptr->_b = 21;return 0;
}
  • 第一部分
  • 14 eb 88 00 就是虚基表的地址
  • 这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。

image-20230429205930885

  • 第二部分
  • 2c dd d4 00 就是虚基表的地址

image-20230429210028764

  • 第三部分
  • ptr是B类的指针，因此将D类的地址赋值非ptr，会进行切片(并不会发生类型转换)

image-20230429213119296

下面是上面的Person关系菱形虚拟继承的原理解释：

image-20240416215856220

8.继承的总结和反思

继承

/*
继承
白箱复用
假如在类X中，共有100个成员，其中80个是保护成员，20个是共有成员，则任何一个成员的调整都有可能影响类Y 
耦合度高public继承是一种`is-a`的关系。也就是说每个派生类对象都有一个基类对象。
*/
class X
{int _x;
};class Y : public X
{int _y;
};

组合

/*
组合
黑箱复用
假如在类M中，共有100个成员，其中80个是保护成员，20个是共有成员，则只有20个共有成员可能影响类N 
因为保护成员N是无法通过组合的方式访问M的保护成员的
耦合度低
组合是一种`has-a`的关系。假设B组合了A，每个B对象中都有一个A对象。
*/
class M
{int _m;
};class N
{M _mm;int _n;
};

  • 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

  • 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java。

  • 继承和组合

    • public继承是一种is-a的关系。也就是说每个派生类对象都有一个基类对象。

    • 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

    • 优先使用对象组合，而不是类继承。

  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用（white-box reuse）。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对派生类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（black-box reuse），因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

  • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

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

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

相关文章

VMware 虚拟机中的 Ubuntu 16.04 设置 USB 连接

VMware 虚拟机中的 Ubuntu 16.04 设置 USB 连接

VMware 虚拟机中的 Ubuntu 16.04 设置 USB 连接 1. VMware USB Arbitration Service2. 可移动设备 USB 口连接主机3. 虚拟机 -> 可移动设备 -> 连接 (断开与主机的连接)4. 状态栏 -> 断开连接 (连接主机)References 1. VMware USB Arbitration Service 计算机 -> …
阅读更多...
JS 千分位格式化

JS 千分位格式化

1 js实现 function formatNumber(number) {let [int,dec] number.toString().split(.);const splitFn (num,isInt true) > {if(num ) return ;if(isInt) num num.split().reverse();let str [];for(let i 0; i < num.length; i){if(i ! 0 && i % 3 0) s…
阅读更多...
四.吊打面试官系列-数据库优化-Mysql锁和事务原理

四.吊打面试官系列-数据库优化-Mysql锁和事务原理

前言 本篇文章主要讲解两块内容&#xff1a;Mysql中的锁和ACID原理&#xff0c;这2个部分是面试的时候被问的蛮多的看完本篇文章之后相信你对Mysql事务会有更深层次的理解&#xff0c;如果文章对你有所帮助请记得好评 一.Mysql中的锁 1.锁的分类 在Mysql中锁也分为很多种&a…
阅读更多...
第四百五十四回

第四百五十四回

文章目录 1. 问题描述2. 优化方法2.1 缩小范围2.2 替代方法 3. 示例代码4. 内容总结 我们在上一章回中介绍了"如何获取AppBar的高度"相关的内容&#xff0c;本章回中将介绍关于MediaQuery的优化.闲话休提&#xff0c;让我们一起Talk Flutter吧。 1. 问题描述 我们在…
阅读更多...
单位优秀信息宣传员告诉你向媒体投稿你不知道的好方法

单位优秀信息宣传员告诉你向媒体投稿你不知道的好方法

作为基层社区信息宣传工作队伍中的一员,我刚开始接手单位的信息宣传投稿任务时,真的是一片茫然。没有任何媒体编辑的熟人朋友,我只能硬着头皮,一家家地去联系媒体,沟通投稿的事宜。这个过程真的是既费事又费力,每次投稿都像是在茫茫大海中寻找那一丝被认可的机会。 因为媒体对稿…
阅读更多...
腾讯云优惠券种类介绍及领取教程

腾讯云优惠券种类介绍及领取教程

腾讯云优惠券是腾讯云推出的一种优惠活动&#xff0c;主要包括代金券和折扣券两种形式。这些优惠券在支付订单时可以抵扣或打折&#xff0c;是腾讯云用户享受优惠的重要凭证。以下是关于腾讯云优惠券种类和领取教程的详细介绍。 一、腾讯云优惠券种类介绍 1、代金券&#xff1…
阅读更多...
Spring Cloud 集成 Redis 发布订阅

Spring Cloud 集成 Redis 发布订阅

目录 前言步骤引入相关maven依赖添加相关配置 使用方法发布订阅发布一个消息 注意总结 前言 在当今的软件开发领域&#xff0c;分布式系统已经成为一种主流的架构模式&#xff0c;尤其是在处理大规模、高并发、高可用的业务场景时。然而&#xff0c;随着系统复杂性的增加&…
阅读更多...
Java反序列化基础-类的动态加载

Java反序列化基础-类的动态加载

类加载器&双亲委派 什么是类加载器 类加载器是一个负责加载器类的对象&#xff0c;用于实现类加载的过程中的加载这一步。每个Java类都有一个引用指向加载它的ClassLoader。而数组类是由JVM直接生成的&#xff08;数组类没有对应的二进制字节流&#xff09; 类加载器有哪…
阅读更多...
JMeter控制器数据库获取一组数据后遍历输出

JMeter控制器数据库获取一组数据后遍历输出

目录 1、测试计划中添加Mysql Jar包 2、添加线程组 3、添加 jdbc connection configuration 4、添加JDBC Request&#xff0c;从数据库中获取数据 5.获取数据列表&#xff0c;提取所有goodsName信息 6.通过添加控制器遍历一组数据 6.1 方式一&#xff1a;循环控制器方式 …
阅读更多...
TiDB存储引擎TiKV揭秘

TiDB存储引擎TiKV揭秘

目录 一、TiKV 介绍 二、RocksDB 三、TiKV 与 RocksDB 架构 3.1 用户数据保存 3.2 TiKV 中 Region 一、TiKV 介绍 TiKV 是一个分布式事务型的键值数据库&#xff0c;提供了满足 ACID 约束的分布式事务接口&#xff0c;并且通过 Raft 协议保证了多副本数据一致性以及高可用。…
阅读更多...
APP看广告变现，实现躺赚！！

APP看广告变现，实现躺赚！！

想实现躺赚吗&#xff1f;开发一款APP&#xff0c;轻松对接广告联盟&#xff0c;收益丰厚&#xff01; 朋友们&#xff0c;你们是否想过如何让自己的手机变得更有价值&#xff1f;现在&#xff0c;有一款APP能让你轻松实现躺赚&#xff01;只需简单注册企业级营业执照和开通对…
阅读更多...
Vue3项目中快速引入ElementUI框架

Vue3项目中快速引入ElementUI框架

ElementUI介绍 ElementUI是一个强大的PC端UI组件框架&#xff0c;它不依赖于vue&#xff0c;但是却是当前和vue配合做项目开发的一个比较好的ui框架&#xff0c;其包含了布局&#xff08;layout)&#xff0c;容器&#xff08;container&#xff09;等各类组件&#xff0c;基本上…
阅读更多...
算法学习——LeetCode力扣补充篇9（912. 排序数组、21. 合并两个有序链表、33. 搜索旋转排序数组、103. 二叉树的锯齿形层序遍历）

算法学习——LeetCode力扣补充篇9（912. 排序数组、21. 合并两个有序链表、33. 搜索旋转排序数组、103. 二叉树的锯齿形层序遍历）

算法学习——LeetCode力扣补充篇9 912. 排序数组 912. 排序数组 - 力扣&#xff08;LeetCode&#xff09; 描述 给你一个整数数组 nums&#xff0c;请你将该数组升序排列。 示例 示例 1&#xff1a; 输入&#xff1a;nums [5,2,3,1] 输出&#xff1a;[1,2,3,5] 示例 2&…
阅读更多...
基于ubuntu22.04系统安装nvidia A100驱动与NVLink启用

基于ubuntu22.04系统安装nvidia A100驱动与NVLink启用

1、官方仓库 针对驱动包下载认准nvidia官网 dpkg -i nvidia-driver-local-repo-ubuntu2204-550.54.15_1.0-1_amd64.deb apt update apt search nvidia-driver-5502、安装 根据步骤1apt search nvidia-driver-550查出版本&#xff1a;此驱动包封在nvidia-driver-local-repo-ub…
阅读更多...
Qt | 事件第二节

Qt | 事件第二节

Qt | 事件第一节书接上回 四、事件的接受和忽略 1、事件可以被接受或忽略，被接受的事件不会再传递给其他对象，被忽略的事件会被传递给其他对象处理，或者该事件被丢弃(即没有对象处理该事件) 2、使用 QEvent::accept()函数表示接受一个事件，使用 QEvent::ignore()函数表示…
阅读更多...
快速排序题目SelectK问题

快速排序题目SelectK问题

力扣75.颜色分类 给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums &#xff0c;原地对它们进行排序&#xff0c;使得相同颜色的元素相邻&#xff0c;并按照红色、白色、蓝色顺序排列。 我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。 必须在不使用库内置的 sor…
阅读更多...
普发Pfeiffer TPG252 TPG256A SingleGaugeTPG261-262使用说明手侧

普发Pfeiffer TPG252 TPG256A SingleGaugeTPG261-262使用说明手侧

普发Pfeiffer TPG252 TPG256A SingleGaugeTPG261-262使用说明手侧
阅读更多...
卷积神经网络的结构组成与解释（详细介绍）

卷积神经网络的结构组成与解释（详细介绍）

文章目录 前言 1、卷积层 2、激活层 3、BN层 4、池化层 5、FC层&#xff08;全连接层&#xff09; 6、损失层 7、Dropout层 8、优化器 9、学习率 10、卷积神经网络的常见结构 前言 卷积神经网络是以卷积层为主的深层网络结构&#xff0c;网络结构包括有卷积层、激活层、BN层、…
阅读更多...
模板初阶的学习

模板初阶的学习

目录&#xff1a; 一&#xff1a;泛型模板 二&#xff1a;函数模板 三&#xff1a;类模板 1&#xff1a;泛型模板 泛型编程&#xff1a;编写与类型无关的通用代码&#xff0c;是代码复用的一种手段。模板是泛型编程的基础。 以交换函数为列进行讲解&#xff1a; void Swap(…
阅读更多...
微服务中的重要模块

微服务中的重要模块

为什么要有微服务&#xff1f; 微服务提高开发效能&#xff0c;避免业务的重复理解&#xff0c;代码重复开发&#xff0c;增加开发效能和代码复用性。 在实际的工作中许多不同的业务有着共同的功能需求&#xff0c;如果我们每遇到一次这种需求就重新去理解构建一次的话会花费大…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023