C++ 继承：代码传承的魔法棒，开启奇幻编程之旅

文章目录

  • 一.继承的概念及定义
    • 1.1继承的概念
    • 1.2继承类
      • 1.2.1继承方法
    • 1.3继承模板
  • 二.基类和派生类的转换
  • 三.继承中的作用域
  • 四.派生类的默认成员函数
    • 4.1默认成员函数的行为
    • 4.2实现一个无法被继承的类
  • 五.继承与友元
  • 六.继承与静态成员
  • 七.多继承和菱形继承
    • 7.1多继承和菱形继承
    • 7.2虚继承
  • 八.总结

一.继承的概念及定义

1.1继承的概念

继承是面向对象语言特性之一，它允许一个类（派生类）从另一个类（基类）中，继承其属性和方法。这样做的好处是，提供了可以重用的代码，避免在写一个类时，它的一部分功能已经在另一个类中实现了，我们还需要在这个类中重新写一遍。

例如：目前写了一个person类，我们可以继承这个类实现，teacher类、student类、president类等等。这些类继承了person，在自己的类中就不需要花费功夫造轮子。

继承还可以这样理解，未来你总会要继承父母的家业、继承公司财产、继承百亩良田，这样继承下来的家业远远比自己白手起家好很多。

1.2继承类

定义格式：

在这里插入图片描述

class person
{
public:
	//……
protected:
	string _name;//姓名
	int _age;//年龄
	int _tel;//电环
	string _address;//地址
};

//其中person称为基类，又称为父类，student称为派生类，又称为子类。冒号后边跟上的publi称为继承方法
//在student类中就不需要实现关于人的成员变量、函数，复用了person类的成员
class student : public person
{
public:
	//
private:
	int _id;//学号
};

//还需要自己定义，自己实现相关的成员变量，成员函数，变得比较麻烦
class student
{
public:
	//
private:
	string _name;//姓名
	int _age;//年龄
	int _tel;//电环
	string _address;//地址

	int _id;//学号
};

student类通过public的方式继承了person类。在student中，就不需要重定义，省去了许多麻烦

1.2.1继承方法

继承方法，是通过不同的继承方法，可以指定基类的成员继承到派生类中后的访问方式，是pbulic公共的成员、还是private私有的成员、还是protected被保护的成员。

类成员/继承方式public继承protected继承private继承
基类的public成员派生类中public成员派生类中protected成员派生类中private成员
基类的protected成员派生类中protected成员派生类中protected成员派生类中private成员
基类的private成员派生类中无法访问派生类中无法访问派生类中无法访问
  • 基类的private成员无论以何种方式继承到在派生类中是无法被访问，它呢，由于语法的限制，无论是在类中还是在类外面都无法访问。

在这里插入图片描述

  • 需要在类外无法被访问，类之间可以被访问的时候，可以使用protected访问限定符。protected修饰后的成员，在通过public或者protected方法继承到派生类中，是可以自由访问，而出了派生类的作用域就无法被访问了。

在这里插入图片描述

通过观察表格不难发现，三种继承方法在访问限制上的约束：public < protectde < private，通过public继承基类的成员到派生类中，它们访问的方式是不会发生变化的；通过protected继承基类的成员，访问方式都被限制为protected；通过private继承基类的成员，访问方式都被限制为了private。

在日常使用中，最常见的是使用public方式继承，使用protected、private继承后的成员只能在派生类中使用，无法扩展到类外，使用性并不好。

  • 若没有显示写继承方式，class中默认的继承方式为private，在struct中默认的继承方式为public

1.3继承模板

在这里插入图片描述

继承模板允许一个模板继承另一个模板

需要注意的是继承基类后，基类还没有被实例化，当调用一个成员函数时，编译器会先在自己的类域中查找，若是调用基类的成员函数没有指定类域的话，编译器将会报错，因为基类并没有实例化，编译器也就不会进入基类中查找。指定基类类域，编译器才会进入基类中查早

没有被实例化的模板是无法寻找的，在编译后，编译器提示找不到print这个标识符，原因是基类是一个类模板，模板只是声明并没有被实例化，直接调用会报错。

#include <iostream>
#include <vector>
using namespace std;

template<class T>
class Stack : public vector<T>//继承模板
{
public:
	void push(const T& x)
	{
		//push_back(x); 
		vector<T>::push_back(x);//指定类域
	}
};

在这里插入图片描述

指定print的类域后，正常运行。

知识补充

下列的场景中，实现了一个函数模板，试图用于对任意类型的容器进行打印

#include <iostream>
#include <vector>
using namespace std;

template<class T>
class Stack : public vector<T>//继承模板
{
public:
	void push_back(const T& x)
	{
        //在通过继承模板实现的栈类中，当 `Stack<int>`  实例化后 `vector<int>`也会进行实例化，但模板是按需实例化的，即你需要使用那部分的函数，编译器帮你实例化那部分，当调用基类中的成员函数时，它并未实例化，编译器并不会认识它。当指定类域后，编译器就会来指定的类域中实例化这个成员函数。
         push_back(x);
		vector<T>::push_back(x);//指定类域
	}
	const T& top()
	{
		vector<T>::back();
	}
	void pop()
	{
		vector<T>::pop_back();
	}
	bool empty()
	{
		return vector<T>::empty();
	}
};

template<class container>
void print(const container& c)
{
   	container::const_iterator it = c.begin();
	typename container::const_iterator it = c.begin();//使用typename指定，container::const_iterator是一个类型

	while (it != c.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}
int main()
{
	Stack<int> st1;
	st1.push_back(1);
	st1.push_back(2);
	st1.push_back(3);
	st1.push_back(4);
	st1.push_back(5);
	
	print(st1);
	return 0;
}

在print模板函数中，it这个类型，依赖于模板参数，在这个过程中，我们不告诉编译器，container::const_iterator是一个类型的话，编译器可能会误解它是一个成员函数，成员变量等

需要使用 typename来告诉编译器，这是一个类型，避免产生歧义。最好用的做法是使用auto关键字，自动推导类型。

二.基类和派生类的转换

  • 派生类的对象可以赋值给基类的指针或者引用（赋值兼容转换），可以通过切分来形容这个过程，编译器将派生类中属于基类的空间切分出来，使指针，或者引用指向基类空间的起始位置。

    • 派生类赋值给基类的过程不会发生临时对象的转换。

      指针的指向，指向的是基类那一部分

      引用，引用的是基类的那一部分

class person
{
public:
	person()
		: _name()
		, _age(18)
		, _tel(123123)
		, _address()
	{}
protected:
	string _name;//姓名
	int _age;//年龄
	int _tel;//电环
	string _address;//地址
};
class student : public person
{
public:
	student()
	{
		_name = "小晨";
		_age = 20;
		_tel = 666;
		_address = "csdn";
		_id = 987;
	}
private:
	int _id;//学号
};
int main()
{
	student stu;
	person* per1 = &stu;
	person& per2 = stu;

	person per3 = stu;
	return 0;
}

在这里插入图片描述

per1和stu的地址相同，per2也对stu进行了切片

在 main 函数中，per3 的声明可能会导致对象切片问题。因为 per3 是 person 类型，而 stu 是 student 类型，当 stu 被复制给 per3 时，student 类特有的成员 _id 会被“切掉”，per3 将不会包含 _id 成员。这意味着通过 per3 访问 _id 将会导致未定义行为。

  • 基类对象不能赋值给派生类对象
    • 基类对象可以通过强制类型转焕赋值给派生类的指针或者引用，但基类的指针必须指向派生类对象时才是安全的，具体细节后续在介绍。

三.继承中的作用域

  • 继承中基类和派生类中都有独立的作用域
  • 派生类和基类中存在同名成员，派生类将隐藏基类中的同名成员，而访问派生类的成员。
    • 通过 基类::基类成员的方式进行显示访问
    • 如果时成员函数同名构成的隐藏，仅需函数名相同即可构成隐藏
    • 不可以理解为基类和派生类之间存在同名函数，可以构成函数重载。函数重载存在于同一个作用域

基类的同名成员函数被隐藏。

在这里插入图片描述

warning C4717: “student::func”: 如递归所有控件路径，函数将导致运行时堆栈溢出

编译器眼里，是func自己不断调用自己，是一个死递归的过程。

在派生类中显示调用基类的同名函数

在这里插入图片描述

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

4.1默认成员函数的行为

默认成员函数的两个主要问题：

  • 不写默认成员函数，编译器默认生成的行为是什么
  • 默认生成的成员函数不符合需求，自己该如何实现？
#include <iostream>
#include <string>

using namespace std;

class person
{
public:
	person(const char* name = " ")
	{
		cout << "constructor person" << endl;
	}
	person(const person& p1)
	{
		cout << "person(const person& p1)" << endl;
	}

	person& operator=(const person& p)
	{
		if (this != &p)
		{
			cout << "person& operator=(const person&)" << endl;
		}
		return *this;
	}

	~person()
	{
		cout << "destructor person" << endl;
	}


protected:
	string _name;//姓名
};

class student : public person
{
public:
	//student(const char* name = " ")
	//	:_name(name)      // 错误的初始化
	//	,_id(2024)  
	//{ //基类会被当作一个整体进行初始化，也就是说，编译器不会再派生类中一个一个的初始化基类成员变量
	//	cout << "constructor" << endl;
	//}

	student(const char* name = " ")
		:person(name)
		,_id(2024)
	{
		cout << "constructor student" << endl;
	}
	
	student(const student& s)//
		:person(s)//派生类对象赋值给基类的引用，发生了切片行为，切分出基类那份成员变量
	{
		cout << "student(const student& s)" << endl;
	}

	student& operator=(const student& p)
	{
        if (this != &p)
		{
			// operator=(p); //必须之类基类类域，同名函数发生了隐藏行为
			person::operator=(p);
			// 必须显示调用基类的赋值重载函数
			cout << "student& operator=(const student&)" << endl;
		}
		return *this;
	}

	~student()
	{
		cout << "destructor student" << endl;
	}

private:
	int _id = 1;//学号
};

int main()
{
	student s1;
	return 0;
}

构造函数的行为

  • 派生类的构造函数必须调用基类的构造函数初始化基类的那部分成员。

    • 如果没有在基类中实现默认构造，在派生类的构造函数的初始化列表阶段显示调用，需要将基类当为一个整体进行初始化

  • 在初识化列表中初始化的顺序根据声明的前后顺序，基类最先出现，先初始化基类

  • 基类没有提供构造，派生类中也得显示的调用 。基类中不存在默认构造，派生类不会自动生成

先构造基类，然后构造派生类

拷贝构造

  • 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
    • 想要显示调用基类的构造函数，就只能通过初始化列表完成

赋值运算符重载的行为

  • 派生类的operator=必须要调用基类的operator=完成基类的赋值。
    • 此处存在同名函数隐藏。需要基类指定作用域显示调用基类的operator=函数。

析构函数的行为

与前几个默认成员函数的行为不同，析构函数并不需要显示调用基类的析构函数。

  • 在编译器调用派生类的析构函数时，不需要显示调用基类的析构函数，在析构过程中保证析构安全，编译器会默认调用基类的析构函数。然后析构派生类

此时析构派生类对象的时候会一起将

先析构基类，在析构派生类

4.2实现一个无法被继承的类

  1. 基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构造函数私有化后，派生类看不见无法调用，此时派生类将无法实例化出对象
  2. 使用C++11新增的关键字 final，使用它修改基类，就无法被派生类继承
#include <iostream>
#include <string>

using namespace std;

class person final
{
protected:
	string _name;//姓名
};

class student : public person
{
private:
	int _id = 1;//学号
};
int main()
{
	student s1;
	return 0;
}

在这里插入图片描述

五.继承与友元

基类的友元关系无法被继承，基类的友元无法访问派生类中收到保护的和私有的成员。

#include <iostream>
#include <string>

using namespace std;

class student;
class person
{
	friend void Fun(const person& per, const student& stu);
protected:
	string _name;//姓名
};
class student : public person
{

private:
	int _id;//学号
};
void Fun(const person& per, const student& stu)
{
	cout << per._name << endl;
	cout << stu._id << endl;//无法被访问。
    					  //解决：将Fun也变为student的友元即可被访问
}
int main()
{
	person per;
	student stu;

	Fun(per, stu);
	return 0;
}

在这里插入图片描述

而解决这种情况也很简单，只需要将fun函数也作为派生类的友元函数即可

六.继承与静态成员

在基类中定义了一个静态成员，则整个继承体系中都使用同一个静态成员，无论派生出多少个类。

执行以下代码，可以发现派生类进程了基类后，打印的 _name地址不相同，基类和派生类中各有一份。

而 _count打印的地址是相同的，印证了即使被继承，派生类和基类使用的还是同一个静态成员。

#include <iostream>
#include <string>

using namespace std;

class person
{
public:
	string _name;
	static int _count;
};
int person::_count = 0;

class student : public person
{
private:
	int _id;
};

int main()
{
	person p1;
	student s1;

	cout << &p1._name << endl;
	cout << &s1._name << endl;

	cout << &s1._count << endl;
	cout << &p1._count << endl;
	return 0;
}

在这里插入图片描述

使用类名访问静态成员变量

使用变量名访问静态成员变量
在这里插入图片描述

七.多继承和菱形继承

7.1多继承和菱形继承

  • 单继承：一个派生类只有一个直接继承基类

这种情况往往被认为是多继承，它实际上是单继承，Assignment只有一个直接继承基类、student也只有一个直接基类
在这里插入图片描述

  • 多继承：一个派生类有多个直接基类时称为多继承

    • 内存关系：先继承的基类放在前面，后继承的基类在后面，派生类的成员在最后一个

    在这里插入图片描述

菱形继承：是一种特殊的多继承，子类继承了多个父类，而这些父类又继承了同一个基类的数据和方法。此时的派生类表现出菱形继承。

  • 由于派生类继承了多份同一个基类，菱形继承存在着数据冗余和二义性问题。

在这里插入图片描述

#include <iostream>
#include <string>

using namespace std;
class person
{
public:
	string _name;
};

class student : public person
{
protected:
	int _id;//学号
};

class teacher : public person
{
protected:
	int _job_num;//工号
};

class Classroom : public student, public teacher
{
protected:
	string _course;
};

int main()
{
	Classroom Class;

	//Class._name = "john";// error C2385: 对“_name”的访问不明确

	//指定访问解决二义性，但无法解决数据冗余
	Class.student::_name = "john";
	Class.teacher::_name = "sophia";
	return 0;
}

在这里插入图片描述

7.2虚继承

在多继承这块就体现了C++语法的复杂。有了多继承，存在着菱形继承的问题，而为了解决菱形继承又有了菱形虚拟继承，它的底层很复杂，会丢失性能。在使用继承中应尽可能避免菱形继承的存在。

#include <iostream>

using namespace std;

class Animal
{
public:
	Animal()
	{
		cout << "Animal()" << endl;
	}
protected:
	bool _herbivore;//食草
};

// 虚继承animal
class bird : virtual public Animal
{
public:
	bird()
	{
		cout << "bird()" << endl;
	}
};
// 虚继承 继承animal
class fish : virtual public Animal
{
public:
	fish()
	{
		cout << "fish()" << endl;
	}
};
// 使用虚继承后就存在数据的二义性、冗余的问题
class flyingfish : public bird, public fish
{
public:
	flyingfish()
	{
		cout << "flyingfish()" << endl;
	}
};
int main()
{
	flyingfish ffish;
	ffish._herbivore = true;

	return 0;
}

八.总结

继承与组合

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

  • 组合是一种 has-a的关系。例如：使用vector类，实现栈、队列。这里的栈和vector是一种组合

  • 继承允许你根据基类的实现类定义派生类的实现。通过这种生成派生类的复用常被称为白箱复用

    • 白箱，相对可见性而言，基类的内部细节对派生类可见，继承一定程度上破坏了基类的封装，基类的该变会对继承产生很大的影响
    • 派生类和基类之间依赖关系强，耦合度很高

  • 对象组合是类继承的另一种复用选择。更复杂的功能可以通过组合对象来获得。组合中要求被组合的对象要具有良好的接口。deque就组合了许多类。这种复用风格被称为黑箱复用，对象只以黑箱的形式出现。组合类之间没有强依赖关系。

    • 黑箱，对象的内部细节是不可见的。
    • 组合的耦合度低

  • 优先使用组合，而不是继承。在使用上多考虑，它们的关系是 is-a关系还是，has-a关系

耦合

耦合指的是模块或类之间的依赖程度，低耦合意味着模块与模块之间的联系和依赖低，当一个模块出现bug的时候，不会影响别的模块，在设计类时应尽可能降低它们之间的练习程度。

这就好比如还在上学的同学与父母之间的依赖关系，在生活上的依赖关系是无比紧密的一但，同学没有生活费了，或者想要买写价格比较高的东西时，都离不开父母，一但某一天自己没有生活费，也练习不上父母了，那自己不就得喝西北方了~。

  • 降低了修改模块影响的范围
  • 提高代码的复用性
  • 模块独立性强，不依赖别的模块可完成测试

内聚

内聚指一个模块只关注它特定的职责和任务，实现一个打印数组的函数，那我们不会在打印函数中再实现一个将数组排为有序的功能，这就显得的多余。

  • 低内聚的模块包含了多个不同的、关联性不强的功能，使得模块的职责不明确。
  • 模块内部功能不聚焦，会出现重复的代码来处理不同的功能部分

程度上破坏了基类的封装，基类的该变会对继承产生很大的影响

  • 派生类和基类之间依赖关系强，耦合度很高

  • 对象组合是类继承的另一种复用选择。更复杂的功能可以通过组合对象来获得。组合中要求被组合的对象要具有良好的接口。deque就组合了许多类。这种复用风格被称为黑箱复用，对象只以黑箱的形式出现。组合类之间没有强依赖关系。

    • 黑箱，对象的内部细节是不可见的。
    • 组合的耦合度低

  • 优先使用组合，而不是继承。在使用上多考虑，它们的关系是 is-a关系还是，has-a关系

耦合

耦合指的是模块或类之间的依赖程度，低耦合意味着模块与模块之间的联系和依赖低，当一个模块出现bug的时候，不会影响别的模块，在设计类时应尽可能降低它们之间的练习程度。

这就好比如还在上学的同学与父母之间的依赖关系，在生活上的依赖关系是无比紧密的一但，同学没有生活费了，或者想要买写价格比较高的东西时，都离不开父母，一但某一天自己没有生活费，也练习不上父母了，那自己不就得喝西北方了~。

  • 降低了修改模块影响的范围
  • 提高代码的复用性
  • 模块独立性强，不依赖别的模块可完成测试

内聚

内聚指一个模块只关注它特定的职责和任务，实现一个打印数组的函数，那我们不会在打印函数中再实现一个将数组排为有序的功能，这就显得的多余。

  • 低内聚的模块包含了多个不同的、关联性不强的功能，使得模块的职责不明确。
  • 模块内部功能不聚焦，会出现重复的代码来处理不同的功能部分

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

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

相关文章

Liunx：文件fd、重定向、管道

Liunx：文件fd、重定向、管道

文件fd&#xff1a; 操作系统运行中一定存在着许多被打开的文件&#xff0c;这些文件需要被管理。一个进程会打开若干个文件。一个文件如果在操作系统中被打开&#xff0c;那么必须给该文件创建一个文件对象&#xff0c;包含被打开文件的各种属性。那么进程与文件的关系就变成…
阅读更多...
【AIGC】ChatGPT提示词Prompt高效编写技巧：逆向拆解OpenAI官方提示词

【AIGC】ChatGPT提示词Prompt高效编写技巧：逆向拆解OpenAI官方提示词

博客主页&#xff1a; [小ᶻZ࿆] 本文专栏: AIGC | ChatGPT 文章目录 &#x1f4af;前言&#x1f4af;OpenAI官方提示词的介绍OpenAI官方提示词的结构与组成如何通过分析提示词找到其核心组件 &#x1f4af;OpenAI官方提示词分析案例一&#xff1a;制定教学计划案例二&…
阅读更多...
干部谈话考察系统：革新传统，精准高效

干部谈话考察系统：革新传统，精准高效

在干部选拔任用和考核评价的过程中&#xff0c;谈话考察一直是关键环节之一。然而&#xff0c;传统的谈话考察方式却面临着诸多痛点&#xff0c;严重影响了干部考察工作的质量和效率。干部谈话考察系统的出现&#xff0c;为解决这些问题提供了有力的武器。 一、传统谈话考察的…
阅读更多...
细说STM32单片机USART中断收发RTC实时时间并改善其鲁棒性的另一种方法

细说STM32单片机USART中断收发RTC实时时间并改善其鲁棒性的另一种方法

目录 一、工程目的 1、目标 2、通讯协议及应对错误指令的处理目标 二、工程设置 三、程序改进 四、下载与调试 1、合规的指令 2、不以#开头&#xff0c;但以&#xff1b;结束&#xff0c;长度不限 3、以#开头&#xff0c;不以;结束&#xff0c;也不包含;&#xff0c;长…
阅读更多...
轨迹规划中优化预测：学习多个初始解的优化器

轨迹规划中优化预测：学习多个初始解的优化器

Abstract 在许多应用中&#xff0c;如机器人控制、自动驾驶和投资组合管理&#xff0c;需要在严格的运行时间限制下连续地解决相似的优化问题。在这种情况下&#xff0c;局部优化方法的性能对初始解的质量非常敏感&#xff1a;不良的初始化可能会导致收敛缓慢或得到次优解。为…
阅读更多...
Xserver v1.4.2发布，支持自动重载 nginx 配置

Xserver v1.4.2发布，支持自动重载 nginx 配置

Xserver——优雅、强大的 php 集成开发环境 本次更新为大家带来了更好的用户体验。 &#x1f389; 下载依赖组件时&#xff0c;显示进度条&#xff0c;展示下载进度。 &#x1f389; 保存站点信息和手动修改 vhost 配置文件之后&#xff0c;自动重载 nginx 配置 &#x1f41e…
阅读更多...
idea 基础简单应用（java）

idea 基础简单应用（java）

Java IDE&#xff08;集成开发环境&#xff09;的使用方法因不同的IDE而异&#xff0c;但通常都包含一些基本的操作和功能。以下以IntelliJ IDEA这一流行的Java IDE为例&#xff0c;介绍Java IDE的基本使用方法与指南&#xff1a; 一、下载与安装 请点击观看 idea免费安装步…
阅读更多...
Notepad++ 更改字体大小和颜色

Notepad++ 更改字体大小和颜色

前言 在长时间编程或文本编辑过程中&#xff0c;合适的字体大小和颜色可以显著提高工作效率和减少眼睛疲劳。Notepad 提供了丰富的自定义选项&#xff0c;让你可以根据个人喜好调整编辑器的外观。 步骤详解 1. 更改字体大小 打开 Notepad 启动 Notepad 编辑器。 进入设置菜…
阅读更多...
五个高质量伤感视频素材资源站，帮你快速找到完美创作素材

五个高质量伤感视频素材资源站，帮你快速找到完美创作素材

在制作短视频、MV或者广告时&#xff0c;伤感主题的视频素材往往能触动观众的情感&#xff0c;让作品更具共鸣。无论是表达分手、离别&#xff0c;还是展现孤独与失落&#xff0c;合适的伤感素材对情感类创作至关重要。为帮助创作者找到优质的视频素材&#xff0c;以下推荐5个高…
阅读更多...
理解Web登录机制：会话管理与跟踪技术解析（一）

理解Web登录机制：会话管理与跟踪技术解析（一）

在这篇博客中&#xff0c;我们将深入探讨登录校验、会话技术和会话跟踪技术的基本概念、实现原理及其在Web应用中的应用。我们将介绍常见的会话跟踪技术&#xff0c;如Cookies、Session&#xff0c;并讨论它们的优缺点。同时&#xff0c;我们也会涉及如何使用现有的技术栈来实现…
阅读更多...
ffmpeg：视频字幕嵌入（GPU加速）

ffmpeg：视频字幕嵌入（GPU加速）

实现方案 参考指令 ffmpeg -i input_video.mp4 -vf "subtitlessubtitles.srt" output_video.mp4 解决因文件名称复杂导致的指令执行失败问题&#xff08;引号给文件框起来&#xff09; ffmpeg -i "A.mp4" -vf "subtitlesB.srt" "c.mp4&qu…
阅读更多...
qt QListWidget详解

qt QListWidget详解

1、概述 QListWidget 是 Qt 框架中的一个类&#xff0c;它提供了一个基于模型的视图&#xff0c;用于显示项目的列表。QListWidget 继承自 QAbstractItemView 并为项目列表提供了一个直观的接口。与 QTreeView 和 QTableView 不同&#xff0c;QListWidget 是专门为单行或多行项…
阅读更多...
UE5 材质篇 0 创建一个材质

UE5 材质篇 0 创建一个材质

首先在starter里的shape里拖入一个几何到场景里 我选了个sphere 然后开始制作一个材质&#xff0c;直接右键点击 进入材质的蓝图界面 先来个纹理采样 左侧detail里选个图给他 type这里可以指定他是其他图片&#xff0c;例如normal map 采样一个之前给UV加个动态offset
阅读更多...
AOSP沙盒android 11

AOSP沙盒android 11

这里介绍一下aosp装系统 什么是aosp AOSP&#xff08;Android Open Source Project&#xff09;是Android操作系统的开源版本。 它由Google主导&#xff0c;提供了Android的源代码和相关工具&#xff0c;供开发者使用和修改。 AOSP包含了Android的核心组件和API&#xff0c;使…
阅读更多...
Linux挖矿病毒（kswapd0进程使cpu爆满）

Linux挖矿病毒（kswapd0进程使cpu爆满）

一、摘要 事情起因:有台测试服务器很久没用了&#xff0c;突然监控到CPU飙到了95以上&#xff0c;并且阿里云服务器厂商还发送了通知消息&#xff0c;【阿里云】尊敬的xxh: 经检测您的阿里云服务&#xff08;ECS实例&#xff09;i-xxx存在挖矿活动。因此很明确服务器中挖矿病毒…
阅读更多...
flink 内存配置（二）：设置TaskManager内存

flink 内存配置（二）：设置TaskManager内存

flink 内存配置&#xff08;一&#xff09;&#xff1a;设置Flink进程内存 flink 内存配置&#xff08;二&#xff09;&#xff1a;设置TaskManager内存 flink 内存配置&#xff08;三&#xff09;&#xff1a;设置JobManager内存 flink 内存配置&#xff08;四&#xff09;…
阅读更多...
基于YOLO11/v10/v8/v5深度学习的建筑墙面损伤检测系统设计与实现【python源码+Pyqt5界面+数据集+训练代码】

基于YOLO11/v10/v8/v5深度学习的建筑墙面损伤检测系统设计与实现【python源码+Pyqt5界面+数据集+训练代码】

《------往期经典推荐------》 一、AI应用软件开发实战专栏【链接】 项目名称项目名称1.【人脸识别与管理系统开发】2.【车牌识别与自动收费管理系统开发】3.【手势识别系统开发】4.【人脸面部活体检测系统开发】5.【图片风格快速迁移软件开发】6.【人脸表表情识别系统】7.【…
阅读更多...
sheng的学习笔记-tidb框架原理

sheng的学习笔记-tidb框架原理

目录 TiDB整体架构 TiDB架构图 组件-TiDB Server 架构图 流程 关系型数据转成kv ​编辑 组件-TiKV Server​ 架构图 主要功能&#xff1a; 列簇 组件-列存储TiFlash 组件-分布式协调层&#xff1a;PD PD架构图 路由 Region Cache back off TSO分配 概念 解…
阅读更多...
HarmonyOS-消息推送

HarmonyOS-消息推送

一. 服务简述 Push Kit&#xff08;推送服务&#xff09;是华为提供的消息推送平台&#xff0c;建立了从云端到终端的消息推送通道。所有HarmonyOS 应用可通过集成 Push Kit&#xff0c;实现向应用实时推送消息&#xff0c;使消息易见&#xff0c;构筑良好的用户关系&#xff0…
阅读更多...
linux 安装anaconda3

linux 安装anaconda3

1.下载 使用repo镜像网址下载对应安装包 右击获取下载地址&#xff0c;使用终端下载 wget https://repo.anaconda.com/archive/Anaconda3-2024.02-1-Linux-x86_64.sh2.安装 使用以下命令可直接指定位置 bash Anaconda3-2024.02-1-Linux-x86_64.sh -b -p /home/anaconda3也…
阅读更多...
最新文章

Copyright @ 2022~2023