【浅尝C++】继承机制=＞虚基表/菱形虚继承/继承的概念、定义/基类与派生类对象赋值转换/派生类的默认成员函数等详解

在这里插入图片描述

🏠专栏介绍：浅尝C++专栏是用于记录C++语法基础、STL及内存剖析等。
🎯每日格言：每日努力一点点，技术变化看得见。

文章目录

  • 继承的概念及定义
    • 继承的概念
    • 继承的定义
      • 定义格式
      • 继承关系与访问限定符
  • 基类和派生类对象赋值转换
  • 继承中的作用域
  • 派生类的默认成员函数
  • 继承与友元
  • 继承与静态成员
  • 复杂的菱形继承及菱形虚拟继承

继承的概念及定义

继承的概念

我们生活中也有继承的例子，例如：小明继承了孙老师傅做拉面的手艺。继承就是一种延续、复用的方式。C++为了提高代码的可复用性，引入了继承机制，概念如下↓↓↓

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

继承的定义

定义格式

下图演示的继承的格式，其中Person是父类，也称作基类；Student是子类，也称作派生类。
在这里插入图片描述

下面给出代码示例（下面代码中，Student类继承父类Person）↓↓↓

#include <iostream>
using namespace std;

class Person
{
public:
	void Show()
	{
		cout <<  _name << " " << _age << endl;
	}
protected:
	string _name = "jammingpro";	//姓名
	int _age = 18;					//年龄
};

class Student : public Person
{
private:
	int _stuId;
};

int main()
{
	Person p;
	Student s;
	p.Show();
	s.Show();
	return 0;
}

在这里插入图片描述
上面代码中，Student继承父类Person的成员（成员函数+成员变量）后，这些成员都变成了子类的一部分。这里的Student复用了Person的成员。通过监视窗口可以看到，Student中也有自己的_name、_age成员变量。
在这里插入图片描述

继承关系与访问限定符

在C++的继承机制中，包含3种继承方式及3种类访问限定符（如下图所示），下面将分别介绍它们。
在这里插入图片描述

我们在学习类和对象时，就已经接触过访问限定符。其中public成员可以在类外访问，而protected与private成员不能在类外访问。但这里的protected和private在继承时是有区别的：
●如果父类愿意让自己的成员被外界访问并愿意让子类继承，则定义为public的；
●如果父类希望自己的成员不被外界访问而愿意让子类继承，则需要定义为protected；
●如果父类不希望自己的成员被外界访问、被继承，则需要定义为private的。

在这里插入图片描述

父类中的访问限定符表示父类愿不愿意让子类继承，而继承方式则可以让子类缩小父类成员的访问权限，但不能放大父类成员的访问权限。

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

针对于总结中的第一点，父类private成员实际上还是被子类继承了，只是子类无法访问，下面使用代码验证↓↓↓

#include <iostream>
using namespace std;

class Base
{
private:
	int _base;
};

class Son : public Base
{}

int main()
{
	Son s;
	return 0;
}

在这里插入图片描述

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

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

在这里插入图片描述
下面给出代码示例↓↓↓

#include <iostream>
using namespace std;

class Person
{
public:
	Person()
	{}
	Person(const string& name, const char& sex, const int& age)
		:_name(name)
		,_sex(sex)
		,_age(age)
	{}
protected:
	string _name;
	char _sex;
	int _age;
};

class Student : public Person
{
public:
	Student(const string& name, const char& sex, const int& age, const int& stuId)
		:Person(name, sex, age)
		,_stuId(stuId)
	{}
private:
	int _stuId;
};

int main()
{
	Student s("Jammingpro", 'M', 18, 123456);
	Person p;
	p=s;
	return 0;
}

从监视窗口可以看到，Person对象保存了Student对象的父类成员部分，而舍弃了子类自有成员，这就是切片。
在这里插入图片描述

●基类对象不能赋值给派生类对象。（基类对象无法用于构造派生类对象，也无法使用派生类对象的拷贝赋值函数；但可以显示提供派生类赋值给基类的operator=实现）

★ps：由于派生类中的成员函数、成员对象一般情况下都会多于基类，如果基类直接赋值给派生类会导致部分成员数值不确定。因此，C++默认不提供基类赋值给派生类。

●基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针指向派生类对象时才是安全的。

下面代码演示了基类赋值给派生类指针，派生类赋值给基类指针↓↓↓

#include <iostream>
using namespace std;

class Person
{
public:
	Person()
	{}
	Person(const string& name, const char& sex, const int& age)
		:_name(name)
		, _sex(sex)
		, _age(age)
	{}
	string _name;
	char _sex;
	int _age;
};

class Student : public Person
{
public:
	Student(const string& name, const char& sex, const int& age, const int& stuId)
		:Person(name, sex, age)
		, _stuId(stuId)
	{}
	int _stuId;
};

int main()
{
	Student s("Jammingpro", 'M', 18, 123456);
	Person p("xiaoming", 'M', 20);
	
	Person* p_s = &s;//安全
	Student* s_p = (Student*) & p;//不安全

	cout << s_p->_stuId << endl;

	return 0;
}

为什么说，Student* s_p = (Student*) & p;是不安全的呢？由于Person对象中没有申请_stuId的空间，但在Student*类型看来，它认为它指向的对象有_stuId成员。如果用户访问了s_p->_stuId可能会因为内存非法访问而报错。
在这里插入图片描述

继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏（而不需要返回值相同，或是参数列表相同）。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。

下面给出派生类成员变量与基类成员变量同名的例子↓↓↓
下面代码中，由于Son类中的成员变量与Base类中的成员变量重名，构成了隐藏。如果使用Son s; cout << s._name << endl;，则只能访问到Son对象中的成员变量，而无法访问到父类中的_name成员变量。若需要访问父类的_name成员变量，则可以使用类型+类作用域符号::来访问，即s.Base::_name。

#include <iostream>
using namespace std;

class Base
{
public:
	string _name = "Jammingpro";
};

class Son : public Base
{
public:
	string _name = "xiaoming";
};

int main()
{
	Son s;
	cout << s._name << endl;
	cout << s.Base::_name << endl;
	return 0;
}

在这里插入图片描述
下面给出派生类成员函数与基类成员函数同名的例子↓↓↓这里与成员变量同名的情况相同，同名成员函数也会构成隐藏关系，如果需要访问父类的同名成员函数，需要使用类名+类作用域运算符::。

#include <iostream>
using namespace std;

class Base
{
public:
	void Show()
	{
		cout << "I am _Base" << endl;
	}
};

class Son : public Base
{
public:
	void Show()
	{
		cout << "I am _Son" << endl;
	}
};

int main()
{
	Son s;
	s.Show();
	s.Base::Show();
	return 0;
}

在这里插入图片描述
★( ఠൠఠ )ﾉtest：下面的两个同名函数（函数名相同，参数列表不同）分别属于基类和派生类，它们构成的关系是隐藏还是函数重载呢？

#include <iostream>
using namespace std;

class Base
{
public:
	void print(char ch)
	{
		cout << "Base->" << ch << endl;
	}
};

class Son : public Base
{
public:
	void print(int num)
	{
		cout << "Son->" << num << endl;
	}
};

int main()
{
	Son s;
	s.print('A');
	return 0;
}

在这里插入图片描述
Base中的成员函数比Son中的成员函数更匹配（不需要隐式类型转换），而这里还是调用Son中的成员函数，说明两者构成的关系是隐藏，而不是函数重载。这里要注意：在继承关系中，派生类与基类只要存在同名函数（不管参数列表、返回值是否相同），都是隐藏关系。

派生类的默认成员函数

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

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

基类提供默认构造函数的情况
派生类在构造时，会自动调用基类的构造函数↓↓↓

#include <iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout << "Base() is called" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son() is called" << endl;
	}
};

int main()
{
	Son s;
	return 0;
}

在这里插入图片描述
基类没有提供默认构造函数的情况
基类没有提供默认构造时，子类必须在初始化参数列表中显示调用基类的构造函数，否则会报错。

#include <iostream>
using namespace std;

class Base
{
public:
	Base(int b)
		:_b(b)
	{
		cout << "Base(int b) is called" << endl;
	}
private:
	int _b
};

class Son : public Base
{
public:
	Son(int b)
		:Base(b)
	{
		cout << "Son() is called" << endl;
	}
};

int main()
{
	Son s(5);
	return 0;
}

在这里插入图片描述

  1. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
#include <iostream>
using namespace std;

class Base
{
public:
	Base(int b)
		:_b(b)
	{}
	Base(const Base& b)
	{
		_b = b._b;
		cout << "Base(const Base& b) is called" << endl;
	}
private:
	int _b;
};

class Son : public Base
{
public:
	Son(int s, int b)
		:_s(s)
		,Base(b)
	{}
	Son(const Son& s)
		:Base(s)
	{
		_s = s._s;
		cout << "Son(const Son& s) is called" << endl;
	}
private:
	int _s;
};

int main()
{
	Son s(55, 66);
	Son s2(s);
	return 0;
}

在这里插入图片描述
如果我们将上面代码中显示调用基类构造函数的代码去掉，则会出现如下报错↓↓↓
在这里插入图片描述
★ps：对于上面的报错，虽然可以通过给基类提供默认构造函数解决，但却无法完成子类中的基类成员的拷贝操作。

  1. 派生类的operator=可以调用基类的operator=完成基类的复制，这样可以避免代码冗余（这里派生类调用基类的operator=不是必须的，只是因为基类已经实现了该操作，派生类不必再重复编写相同内容）。

下面代码演示了派生类调用基类operator=函数带来的代码简化↓↓↓

#define _CRT_SECURE_NO_WARNINGS 1

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

class Person
{
public:
	Person(const string& name, const int& age, const char& gender)
		:_name(name)
		,_age(age)
		,_gender(gender)
	{}
	Person& operator=(const Person& p)
	{
		_name = p._name;
		_age = p._age;
		_gender = p._gender;
		return *this;
	}
	void Show()
	{
		cout << "My name is " << _name << ", I am " << _age << " years old, I am a " 
		<< (_gender == 'M' ? " boy " : "girl") << endl;
	}
private:
	string _name;
	int _age;
	char _gender;
};

class Student : public Person
{
public:
	Student(const string& name, const int& age, const char& gender, const char* detail)
		:Person(name, age, gender)
	{
		_detail = new char[strlen(detail) + 1];
		strcpy(_detail, detail);
	}
	Student& operator=(const Student& s)
	{
		Person::operator=(s);
		char* detail = new char[strlen(s._detail)];
		return *this;
	}
	void Show()
	{
		Person::Show();
		cout << "My detail infomation is " << _detail << endl;
	}
	~Student()
	{
		delete[] _detail;
	}
private:
	char* _detail;
};

int main()
{
	Student s("Jammingpro", 18, 'M', "He is good at coding");
	Student copy = s;
	s.Show();
}

在这里插入图片描述

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

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

下面代码演示了基类与派生类的构造与析构顺序↓↓↓

#include <iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout << "Base() is called" << endl;
	}
	~Base()
	{
		cout << "~Base() is deleted obj" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son is called" << endl;
	}
	~Son()
	{
		cout << "~Son() is deleted obj" << endl;
	}
};

int main()
{
	Son s;
	return 0;
}

在这里插入图片描述

  1. 编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

★ps：关于virtual关键字将于多态中讲解

继承与友元

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

下面代码演示了友元关系无法继承↓↓↓

#include <iostream>
using namespace std;

class Base
{
	friend void print();
private:
	int _base = 88;
};

class Son : Base
{
private:
	int _son = 66;
};

void print()
{
	Base b;
	cout << b._base << endl;
	Son s;
	cout << s._son << endl;
}

int main()
{
	print();
	return 0;
}

在这里插入图片描述

继承与静态成员

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

#include <iostream>
using namespace std;

class Base
{
public:
	static int val;
};

//静态非const成员变量需要在类外初始化
int Base::val = 66;

class Son : public Base
{
};

class GrandSon : Son
{
};

int main()
{
	cout << &Base::val << endl;
	cout << &Son::val << endl;
	cout << &GrandSon::val << endl;
	return 0;
}

在这里插入图片描述

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

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
下面是一份单继承的代码↓↓↓

#include <iostream>
using namespace std;

class Base
{
public:
	void base_func()
	{}
	int _base;
};

class Son : public Base
{
public:
	void son_func()
	{}
	int _son;
};

class GrandSon : public Son
{
public:
	void gs_func()
	{}
	int _gs;
};

int main()
{
	GrandSon gs;
	cout << &gs << endl;
	gs._base = 1;
	cout << &gs._base << endl;
	gs._son = 2;
	cout << &gs._son << endl;
	gs._gs = 3;
	cout << &gs._gs << endl;

	cout << "===================================" << endl;

	Son s;
	cout << &s << endl;
	s._base = 1;
	cout << &s._base << endl;
	s._son = 2;
	cout << &s._son << endl;

	return 0;
}

在这里插入图片描述

上述代码调试时，通过监视窗口查看结果如下图所示。我们可以发现，GrandSon对象保存了其祖先类Son、Base的成员变量。Son对象保存了其基类成员变量。
在这里插入图片描述
下图为GrandSon对象的存储情况↓↓↓
在这里插入图片描述
通过分析上面的执行结果，可以得出如下结论：再单继承中，某个类的成员变量放置于类空间最后，该成员变量前放置的是直接父类，再往上是爷爷类，以此类推。类对象的地址，与最顶层的祖先的成员变量地址相同。

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
在这里插入图片描述
下面给出多继承的演示代码↓↓↓

#include <iostream>
using namespace std;

class Base1
{
public:
	void base1_func()
	{}
	int _base1;
};

class Base2
{
public:
	void base2_func()
	{}
	int _base2;
};

class Son : public Base1, public Base2
{
public:
	void son_func()
	{}
	int _son;
};

int main()
{
	Son s;
	cout << &s << endl;
	s._base1 = 1;
	cout << &s._base1 << endl;
	s._base2 = 2;
	cout << &s._base2 << endl;
	s._son = 3;
	cout << &s._son << endl;
	return 0;
}

在这里插入图片描述
如果Son先继承Base1再继承Base2，则会将Base1的成员变量放在前面，后继承的Base2的成员变量放在后面。
在这里插入图片描述
如果将Son先继承Base2，再继承Base1呢？
在这里插入图片描述

由上面的执行结果可知，先继承的基类的成员变量放置于类对象的前面位置，后即成的基类的成员变量放置于类对象的后面位置，类自身的成员变量放置于最后。

菱形继承：菱形继承是多继承的一种特殊情况
在这里插入图片描述
下面给出多继承的演示代码↓↓↓

#include <iostream>
using namespace std;

class Share
{
public:
	void share_func()
	{}
	int _share;
};

class Base1 : Share
{
public:
	void base1_func()
	{}
	int _base1;
};

class Base2 : Share
{
public:
	void base2_func()
	{}
	int _base2;
};

class Son : public Base1, public Base2
{
public:
	void son_func()
	{}
	int _son;
};

int main()
{
	Son s;
	s._base1 = 1;
	s._base2 = 2;
	s._son = 3;
	return 0;
}

在上述代码的监视窗口可以看出菱形继承有数据冗余和二义性的问题。s中继承了两份Share类的成员变量_share。
在这里插入图片描述
C++中为了避免菱形继承导致的数据冗余和二义性，它引入了虚拟继承。虚拟继承可以解决菱形继承的二义性和数据冗余的问题。下面给出修改后的代码（引入虚拟继承的代码）↓↓↓

#include <iostream>
using namespace std;

class Share
{
public:
	void share_func()
	{}
	int _share;
};

class Base1 : virtual public Share
{
public:
	void base1_func()
	{}
	int _base1;
};

class Base2 : virtual public Share
{
public:
	void base2_func()
	{}
	int _base2;
};

class Son : public Base1, public Base2
{
public:
	void son_func()
	{}
	int _son;
};

int main()
{
	Son s;
	cout << &s << endl;
	s._share = 0;
	cout << &s._share << endl;
	s._base1 = 1;
	cout << &s._base1 << endl;
	s._base2 = 2;
	cout << &s._base2 << endl;
	s._son = 3;
	cout << &s._son << endl;
	return 0;
}

在这里插入图片描述

在这里插入图片描述

这里是通过了两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的Share。

🎈欢迎进入浅尝C++专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d

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

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

相关文章

如果你正在投简历，一定要试试这款AI工具！

如果你正在投简历，一定要试试这款AI工具！

今天给大家分享一款AI简历神器 - BitBitFly AI 简历助手&#xff0c;这个工具可以帮助大家快速、精准投简历&#xff0c;并且提供职位匹配度分析报告&#xff0c;提供专业优化简历建议提高简历和职位匹配度&#xff0c;轻松拿下offer。 如果你在找工作的时候遇到以下问题&…
阅读更多...
主流验证码对比及选型

主流验证码对比及选型

目录 一、什么是验证码二、验证码的作用三、验证码的类型四、验证码厂商1、 [腾讯云验证码](https://cloud.tencent.com/document/product/1110)1.1 验证方式1.2 费用 2、[阿里云验证码](https://www.aliyun.com/activity/security/wafcaptcha)2.1 验证方式2.2 费用 3、[顶象验…
阅读更多...
计算机网络——35什么是网络安全

计算机网络——35什么是网络安全

什么是网络安全 机密性&#xff1a;只有发送方和预订的接收方能否理解传输的报文内容 发送方加密报文接收方解密报文 认证&#xff1a;发送方和接收方需要确认对方的身份报文完整性&#xff1a;发送方、接收方需要确认的报文在传输的过程中或者事后没有被改变访问控制和服务的…
阅读更多...
android11 SystemUI入門之KeyguardPatternView解析

android11 SystemUI入門之KeyguardPatternView解析

view层级树为&#xff1a; 被包含在 keyguard_host_view.xml中 。 <?xml version"1.0" encoding"utf-8"?> <!-- This is the host view that generally contains two sub views: the widget viewand the security view. --> <com.andro…
阅读更多...
麻了，别再为难软件测试员了

麻了，别再为难软件测试员了

前言 有不少技术友在测试群里讨论&#xff0c;近期的面试越来越难了&#xff0c;要背的八股文越来越多了,考察得越来越细&#xff0c;越来越底层&#xff0c;明摆着就是想让我们徒手造航母嘛&#xff01;实在是太为难我们这些测试工程师了。 这不&#xff0c;为了帮大家节约时…
阅读更多...
RAG知识分享

RAG知识分享

文章目录 1.为什么要做RAG1.1. 解决幻觉问题1.1.1 直接输入问题1.1.2. 问题 相关知识 2. 什么是RAG2.1. 基本概念2.2. 基本RAG方法2.2.1. 知识预处理2.2.2. 知识检索2.2.3. 答案生成 3. RAG 与 Long Context3.1. Long Context3.2. RAG 与Long Context3.3 RAG对比Long Context的…
阅读更多...
（2024，超分辨率，膨胀卷积和低通滤波，SD）FouriScale：免训练高分辨率图像合成的频率视角

（2024，超分辨率，膨胀卷积和低通滤波，SD）FouriScale：免训练高分辨率图像合成的频率视角

FouriScale: A Frequency Perspective on Training-Free High-Resolution Image Synthesis 公和众和号&#xff1a;EDPJ&#xff08;进 Q 交流群&#xff1a;922230617 或加 VX&#xff1a;CV_EDPJ 进 V 交流群&#xff09; 目录 0. 摘要 2. 相关工作 2.2 通过扩散模型进行…
阅读更多...
【攻防世界】ics-05

【攻防世界】ics-05

php://filter 伪协议查看源码 preg_replace 函数漏洞 1.获取网页源代码。多点点界面&#xff0c;发现点云平台设备维护中心时&#xff0c;页面发生变化。 /?pageindex 输入什么显示什么&#xff0c;有回显。 用php://filter读取网页源代码 ?pagephp://filter/readconvert.…
阅读更多...
PC版复古珠宝饰品网站模板 基于pbootcms的首饰类源码下载

PC版复古珠宝饰品网站模板 基于pbootcms的首饰类源码下载

PbootCMS复古珠宝饰品网站模板&#xff1a;PCWAP双端同步&#xff0c;数据即时共享&#xff0c;轻松打造专业饰品首饰平台 本模板基于PbootCMS内核开发&#xff0c;专为饰品首饰网站、复古珠宝饰品网站等企业量身定制。同时&#xff0c;其他行业同样适用&#xff0c;只需替换文…
阅读更多...
【PostgreSQL】技术传承：使用Docker快速部署PostgreSQL数据库

【PostgreSQL】技术传承：使用Docker快速部署PostgreSQL数据库

前言 PostgreSQL的重要贡献者Simon Riggs因一起坠机事故不幸离世。Simon Riggs是英国著名的软件与服务领导者&#xff0c;也是PostgreSQL的主要开发者和贡献者。事故发生在英国当地时间3月26日13:41分&#xff0c;当时他驾驶的私人通用航空Cirrus SR22飞机在英国达克斯福德机场…
阅读更多...
SpringBoot整合Netty整合WebSocket-带参认证

SpringBoot整合Netty整合WebSocket-带参认证

文章目录 一. VectorNettyApplication启动类配置二.WebSocketServerBoot初始化服务端Netty三. WebsocketServerChannelInitializer初始化服务端Netty读写处理器四.initParamHandler处理器-去参websocket识别五.MessageHandler核心业务处理类-采用工厂策略模式5.1 策略上下文 六…
阅读更多...
Thinkphp5萤火商城B2C小程序源码

Thinkphp5萤火商城B2C小程序源码

源码介绍 Thinkphp5萤火商城B2C小程序源码&#xff0c;是一款开源的电商系统&#xff0c;为中小企业提供最佳的新零售解决方案。采用稳定的MVC框架开发&#xff0c;执行效率、扩展性、稳定性值得信赖。 环境要求 Nginx/Apache/IIS PHP5.4 MySQL5.1 建议使用环境&#xff…
阅读更多...
代码随想录第三十天 | 回溯问题P6 | ● 332● 51● 37● 总结

代码随想录第三十天 | 回溯问题P6 | ● 332● 51● 37● 总结

332.重新安排行程 给你一份航线列表 tickets &#xff0c;其中 tickets[i] [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。 所有这些机票都属于一个从 JFK&#xff08;肯尼迪国际机场&#xff09;出发的先生&#xff0c;所以该行程必须从 JFK…
阅读更多...
docker从入门到熟悉

docker从入门到熟悉

一、什么是docker&#xff1f; Docker是一个用于开发&#xff0c;交付和运行应用程序的开放平台。Docker使您能够将应用程序与基础架构分开&#xff0c;从而可以快速交付软件。借助Docker&#xff0c;您可以以与管理应用程序相同的方式来管理基础架构。通过利用Docker的快速交付…
阅读更多...
11-1(2)-CSS 背景+CSS 精灵图

11-1(2)-CSS 背景+CSS 精灵图

个人主页&#xff1a;学习前端的小z 个人专栏&#xff1a;HTML5和CSS3悦读 本专栏旨在分享记录每日学习的前端知识和学习笔记的归纳总结&#xff0c;欢迎大家在评论区交流讨论&#xff01; 文章目录 一、CSS 背景1 背景颜色2 背景色半透明3 背景图片4 背景平铺5 背景图片位置6 …
阅读更多...
LCD屏幕mmap显示

LCD屏幕mmap显示

目录 前言 一.LCD显示 二.LCD颜色显示 2.1 直接显示 2.2 mmap映射显示 前言 mmap是一种内存映射文件的方法&#xff0c;它允许将文件或其它对象映射到进程的地址空间。 使用mmap映射函数进行映射显示&#xff0c;与屏幕普通直接显示相比有很大的优势 一.LCD显示基础 像素、分辨…
阅读更多...
2. 如何让mybatis-plus的逻辑删除注解@TableLogic临时失效

2. 如何让mybatis-plus的逻辑删除注解@TableLogic临时失效

文章目录 如何让mybatis-plus的逻辑删除注解TableLogic临时失效1. 场景复现1.1 controller代码1.2 service层代码1.3 entity代码 2. 问题分析3. 解决方案3.1 说明3.2 核心代码3.3 service方法对应修改为3.4 运行结果 如何让mybatis-plus的逻辑删除注解TableLogic临时失效 1. 场…
阅读更多...
数学矩阵GCD和lCM（详解）

数学矩阵GCD和lCM（详解）

矩阵乘法 知阵乘法是《线性代数》中的基础内容&#xff0c;但在考察数学的算法题中也会出现。 本节我们学习基础的矩阵乘法规则。 每个矩阵会有一个行数和一个列数&#xff0c;只有当相乘的两个矩阵的左矩阵的列数等于右矩阵的行数 时&#xff0c;才能相乘&#xff0c;否则不允…
阅读更多...
移动Web学习05-移动端适配Less预处理器

移动Web学习05-移动端适配Less预处理器

7、移动端适配 7.1、什么是适配&#xff1f; 简单理解就是、同一个网页&#xff0c;在不同屏幕分辨率的设备下、显示还是一样的&#xff0c;你可以理解为、网页当中的图片&#xff0c;盒子之间的距离、文字的大小、随着屏幕分辨率的变化而变化 前面我们学习了flex布局的方式…
阅读更多...
关系型数据库与非关系型数据库、Redis数据库

关系型数据库与非关系型数据库、Redis数据库

相比于其他的内存/缓存数据库&#xff0c;redis可以方便的实现持久化的功能&#xff08;保存至磁盘中&#xff09; 一、关系数据库与非关系型数据库 1.1 关系型数据库 一个结构化的数据库&#xff0c;创建在关系模型基础上一般面向于记录 SQL语句 (标准数据查询语言) 就是一种…
阅读更多...
最新文章

Copyright @ 2022~2023