【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.mfbz.cn/a/469182.html

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

相关文章

（2024，EBGAN，扩散，变分近似）通过扩散过程改进基于能量的对抗模型

（2024，EBGAN，扩散，变分近似）通过扩散过程改进基于能量的对抗模型

Improving Adversarial Energy-Based Model via Diffusion Process 公和众和号&#xff1a;EDPJ&#xff08;进 Q 交流群&#xff1a;922230617 或加 VX&#xff1a;CV_EDPJ 进 V 交流群&#xff09; 目录 0. 摘要 2. 相关工作 3. 去噪扩散对抗 EBM 3.1. 具有去噪扩散过程…
阅读更多...
JavaScript中a++和++a的区别是什么？

JavaScript中a++和++a的区别是什么？

在JS中&#xff0c;a 和 a 都是对变量 a进行自增操作&#xff0c;但是他们在执行的行为和结果上有些不同&#xff1a; a (前缀自增)&#xff1a; 首先是将a的值增加1&#xff0c;然后返回 a 增加后的值。这意味着&#xff0c;表达式的其余部分使用 a的时候&#xff0c; a 的值…
阅读更多...
人大金仓携手中国大地保险上线核心超A系统

人大金仓携手中国大地保险上线核心超A系统

2023年底 中国大地保险 卡园三路59号办公室里 一群技术精英们正忙碌着 他们的眼中闪烁着对即将到来的胜利的期待 这是大地保险超A系统 项目上线的关键时刻 也是通过科技创新 引领行业服务新趋势的一场征程 项目现场 一次颠覆&#xff1a;改变传统保险服务模式 超A平…
阅读更多...
微信小程序项目实战遇到的问题

微信小程序项目实战遇到的问题

我们以学生成绩平台来作为例子。这是我们想得到的效果。 以下是完整代码&#xff1a; index.js // index.js Page({//页面的初始数据data: {hello: 欢迎进入微信小程序的编程世界,score: 80,userArray: [{name: 张三,score: [66, 77, 86, 70, 90]},{name: 李四,score: [88, 7…
阅读更多...
中国传统游戏-幻方-c/c++实现

中国传统游戏-幻方-c/c++实现

幻方&#xff08;Magic Square&#xff09;是一种将数字安排在正方形格子中&#xff0c;使每行、列和对角线上的数字和都相等的方法。 幻方也是一种中国传统游戏。旧时在官府、学堂多见。它是将从一到若干个数的自然数排成纵横各为若干个数的正方形&#xff0c;使在同一行、同…
阅读更多...
由浅到深认识Java语言（2）：Java语言概述

由浅到深认识Java语言（2）：Java语言概述

该文章Github地址&#xff1a;https://github.com/AntonyCheng/java-notes 在此介绍一下作者开源的SpringBoot项目初始化模板&#xff08;Github仓库地址&#xff1a;https://github.com/AntonyCheng/spring-boot-init-template & CSDN文章地址&#xff1a;https://blog.c…
阅读更多...
CSS案例-4.padding导航栏练习

CSS案例-4.padding导航栏练习

效果 相关数据： 上边框：3px，颜色#ff8500 下边框：1px，颜色#edeef0 背景颜色：#fcfcfc 高度：41px 内边距20px 字体颜色#4c4c4c 知识点 盒子边框border 属性 作用 border-width 定义边框粗细，单位px border-style 边框的样式 border-color 边框颜色 边框样式
阅读更多...
拿捏指针（三）

拿捏指针（三）

✨✨欢迎&#x1f44d;&#x1f44d;点赞☕️☕️收藏✍✍评论 个人主页&#xff1a;秋邱博客 所属栏目&#xff1a;C语言 &#xff08;感谢您的光临&#xff0c;您的光临蓬荜生辉&#xff09; 前言 在这之前我们学习了《拿捏指针&#xff08;一&#xff09;》&#xff0c;《拿…
阅读更多...
Ansible基本介绍与模块使用

Ansible基本介绍与模块使用

目录 引言 一、Ansible简介 &#xff08;一&#xff09;基本概述 &#xff08;二&#xff09;主要特点 二、Ansible安装及基本组件 &#xff08;一&#xff09;yum安装 &#xff08;二&#xff09;编译安装 &#xff08;三&#xff09;基本配置信息 1.主配置文件 2.主…
阅读更多...
【Linux】自动化构建工具-make/Makefile

【Linux】自动化构建工具-make/Makefile

个人主页 &#xff1a; zxctscl 如有转载请先通知 文章目录 1. 前言2. 认识make/Makefile3. 了解make/Makefile原理3.1 依赖关系和依赖方法3.2 make检测的顺序3.3 PHONY:XXX 4. makefile内置符号 1. 前言 在上一篇中已经了解了【Linux】编译器-gcc/g使用&#xff0c;这次来一起…
阅读更多...
01｜模型IO：输入提示、调用模型、解析输出

01｜模型IO：输入提示、调用模型、解析输出

Model I/O 可以把对模型的使用过程拆解成三块&#xff0c;分别是输入提示&#xff08;对应图中的Format&#xff09;、调用模型&#xff08;对应图中的Predict&#xff09;和输出解析&#xff08;对应图中的Parse&#xff09;。这三块形成了一个整体&#xff0c;因此在LangCha…
阅读更多...
idea将非UTF-8的properties修改为UTF-8编码的文件

idea将非UTF-8的properties修改为UTF-8编码的文件

需求背景 由于项目初始化时&#xff0c;properties文件的编码格式为ASCII编码格式&#xff0c;此时用idea打开该文件会默认展示UTF-8的编码内容&#xff0c;其中汉字可以正常展示&#xff0c;但是使用notepad打开却依旧时ASCII编码格式 idea配置 打开idea-setting-editor-f…
阅读更多...
TCP - 传输控制协议

TCP - 传输控制协议

TCP - 传输控制协议 是一种面向连接的可靠传输协议。 特点&#xff1a; TCP是面向连接&#xff08;虚连接&#xff09;的传输层协议。 每一条TCP连接有且只能有两个端点。 可靠、有序、无丢弃和不重复。 TCP协议提供全双工通讯。 发送缓存 存放发送方TCP准备发送的数据。T…
阅读更多...
Springboot笔记-01

Springboot笔记-01

简化spring应用开发&#xff0c;约定大于配置 简化Spring应用开发的一个框架&#xff1b; 整个Spring技术栈的一个大整合&#xff1b; J2EE开发的一站式解决方案&#xff1b; 优点&#xff1a; 快速创建独立运行的spring项目以及于主流框架集成 使用嵌入式的Servlet容器&#x…
阅读更多...
Reactor线程模型

Reactor线程模型

线程模型 一、背景1.socket网络通信2.IO模型与线程模型3.线程模型分类3.1 阻塞模型3.2 Reactor模型3.3 Proactor模式 二、阻塞模型1.代码示例 三、Reactor模型1.单Reactor单线程1.1 处理过程1.2 优缺点1.3 代码示例 2.单Reactor多线程2.1 处理机制2.2 优缺点 3.主从Reactor3.1 …
阅读更多...
深度学习_卷积

深度学习_卷积

卷积 卷积&#xff08;Convolution&#xff09;是数学和计算机科学中的一个重要概念&#xff0c;特别在信号处理和图像处理中应用广泛。在信号处理领域&#xff0c;卷积是两个函数之间的一种数学操作&#xff0c;它表示两个函数的重叠部分的积分量。 在图像处理中&#xff0c…
阅读更多...
JavaScript数组排序sort自定义函数不生效

JavaScript数组排序sort自定义函数不生效

背景 刷LeetCode时&#xff0c;遇到一道简单的数组排序题&#xff1a; 问题 想着直接用js的数组sort自定义排序即可&#xff0c;奈何测试用例运行总是不通过&#xff0c;返回的一直都是原数组。 代码排查 复制代码到Firefox浏览器控制台运行&#xff0c;结果输出的是正确结果&a…
阅读更多...
搭建Hadoop集群(完全分布式运行模式)

搭建Hadoop集群(完全分布式运行模式)

目录 一、准备模板机(最小化安装)二、配置一台纯净的模板机修改主机名固定IP地址通过yum安装方式安装必要的软件关闭防火墙且禁止自启修改hosts映射文件创建普通用户 并让他能用sudo命令在/opt下创建software和module完成 三、搭建完全分布式运行模式3.1克隆第一台机器hadoop10…
阅读更多...
基于PCA（主成分分析）的人面识别，Matlab实现

基于PCA（主成分分析）的人面识别，Matlab实现

博主简介&#xff1a; 专注、专一于Matlab图像处理学习、交流&#xff0c;matlab图像代码代做/项目合作可以联系&#xff08;QQ:3249726188&#xff09; 个人主页&#xff1a;Matlab_ImagePro-CSDN博客 原则&#xff1a;代码均由本人编写完成&#xff0c;非中介&#xff0c;提供…
阅读更多...
Vue学习日记 Day7 —— json-server工具、基于VueCli自定义创建项目、postcss插件

Vue学习日记 Day7 —— json-server工具、基于VueCli自定义创建项目、postcss插件

一、前一天Vuex总结 1、state作用&#xff1a;存放数据定义&#xff1a;state:{//数据 }使用&#xff1a;//放在data下(1)根节点直接访问this.$store.state.数据名(2)模块直接访问this.$store.state.模块名.数据名(3)根节点辅助函数mapState([所需要的数据])(4)模块辅助…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站