【C++之继承知识】

C++学习笔记---017

  • C++之继承知识
    • 1、C++中继承的简单介绍
      • 1.1、继承的语法
      • 1. 2、继承的特性
      • 1.3、继承的类型
    • 3、继承的简单应用
    • 4、继承中的访问修饰符或访问的权限
    • 5、继承中的构造函数和析构函数
    • 6、继承中的覆盖和重载
    • 7、继承中的作用域
    • 8、派生类的默认成员函数
      • 8.1、6个默认成员函数
      • 8.2、派生类 = 父类 + 子类，父类的调用·父类·构造函数初始化(把父类当作一个整体)
      • 8.3、派生类的拷贝构造
    • 9、复用的几个体现
      • 9.1、继承与友元
      • 9.2、继承与静态成员
      • 9.3、复杂的菱形继承及菱形虚拟继承
      • 9.4 、菱形继承就容易可能出现隐含的问题
    • 10、总结

C++之继承知识

前言：
前面篇章学习了C++对于模板有了新的认识和了解，接下来继续学习，C++的另一个特性继承等相关知识。
/知识点汇总/
前言：

封装：
1.数据和方法放在一起，把想给访问的成员，定义为公有，不想被访问的定义为私有或保护。
2.一个类型放在另一个类型里面，通过typedef成员函数调整，封装另一个全新的类型。
继承：
继承机制是面向对象程序设计使得代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产合新的类，称为派生类。
继承呈现了对象面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前接触的复用是函数复用，继承是属于类的复用。

1、C++中继承的简单介绍

在C++中，继承（Inheritance）是面向对象编程（OOP）的一个重要特性，它允许一个类（称为派生类或子类）继承另一个类（称为基类或父类）的属性和方法。通过这种方式，派生类可以重用基类的代码，并添加或修改一些特定的功能。

1.1、继承的语法

在C++中，使用冒号（:）和访问修饰符（如public、protected、private）来声明继承关系。

//语法 --- 定义格式
class Student : public Person
{
protected:
	int _stulid;//学号
};
Student -- 派生类 --子类
public --- 继承方式
Person ---- 基类 ---父类


class Base {  
public:  
    void baseFunction() {  
        // ...  
    }  
};  
  
class Derived : public Base { // 派生类Derived公有继承基类Base  
public:  
    void derivedFunction() {  
        // ...  
        baseFunction(); // 可以调用基类的公有函数  
    }  
};

1. 2、继承的特性

继承的特性
代码重用
通过继承，派生类可以重用基类的属性和方法，避免重复编写相同的代码。
多态性
通过继承和虚函数，可以实现运行时多态性，即同一操作可以根据不同的对象执行不同的操作。
扩展性
派生类可以在继承基类的基础上添加新的属性和方法，从而扩展基类的功能。

1.3、继承的类型

公有继承（Public Inheritance）：
在公有继承中，基类的公有和保护成员在派生类中仍然是公有和保护成员，基类的私有成员在派生类中仍然是私有的，不能被直接访问。
保护继承（Protected Inheritance）：
在保护继承中，基类的公有和保护成员在派生类中变为保护成员，基类的私有成员在派生类中仍然是私有的。
私有继承（Private Inheritance）：
在私有继承中，基类的公有和保护成员在派生类中变为私有成员，基类的私有成员在派生类中仍然是私有的。注意，在私有继承中，派生类外部的代码不能访问基类的公有成员。

3、继承的简单应用

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

4、继承中的访问修饰符或访问的权限

#include <iostream>
using namespace std;
class Person
{
public:
	void Print()
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
	}
	//protected:
//protected:
	string _name = "perter";//姓名
//private: //----派生类不可见
	int _age = 18;//年龄
};

//class Student : public Person
//class Student : protected Person //公有遇见私有或保护，权限缩小。//保护遇见私有，变私有
class Student : public Person
{
public:
	void func()
	{
		cout << "name: " << _name << endl;
		//cout << "age: " << _age << endl;//不能直接访问父类的私有成员，不可见==不能访问
		//不过可以间接使用：调用父类的成员函数间接使用
		Print();
	}
protected:
	int _stulid;//学号
};
class Teacher : public Person
{
protected:
	int _jobid;//工号
};
int main()
{
	int i = 1;
	double d = i;
	string s = "111111";
	//const string& s = "111111";
	//不相关类型之间不支持转换
	//string str = i;

	//子类可转父类 --- 前提是公有
	//Student st;
	//Person p = st;

	//public继承
	//每个子类对象都是一个特殊的父类对象 --- 子可以给父，父不能给子(因为子继承有父的成员，而父不一定都有子的成员)

	//切割/切片复制兼容
	Student st;
	Person p = st;
	//复制兼容 -- 编译器进行特殊处理
	Person& ref = st;
	Person* ptr = &st;

	ref._name += 'x';
	ptr->_name += 'y';

	return 0;
}

小结：

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片
或者切割。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
的指针是指向派生类对象时才是安全的。

5、继承中的构造函数和析构函数

构造函数 在派生类中，如果需要初始化基类的成员，可以在派生类的构造函数中调用基类的构造函数。这通常通过初始化列表来完成。
析构函数 派生类的析构函数在基类析构函数之前被调用。这是为了确保在派生类部分被销毁之前，基类部分已经得到了适当的清理。

6、继承中的覆盖和重载

覆盖（Overriding） 在派生类中重新定义基类的虚函数，这种机制被称为覆盖或重写。通过覆盖，派生类可以改变基类虚函数的行为。
重载（Overloading） 在基类或派生类中，可以使用相同的函数名但不同的参数列表来定义多个函数，这被称为函数重载。

7、继承中的作用域

#include <iostream>
using namespace std;
class Person
{
public:
	void Print()
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
	}
protected:
	string _name = "perter";//姓名
	int _age = 18;//年龄
	int _num = 0;
};
class Student : public Person
{
public:
	void func()
	{
		//Student中有两个_num时，如何访问呢？---作用域优先级
		cout << _num << endl;//子类成员会屏蔽父类对同名成员的直接访问 -- 称为隐藏

		//如果就想访问父类的_num呢？--- 指定作用域访问
		cout << Person::_num << endl;
	}
protected:
	int _stulid = 0;//学号
	int _num = 1;
};
int main()
{
	Student sd;
	sd.func();
	return 0;
}

小结：

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

8、派生类的默认成员函数

8.1、6个默认成员函数

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

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认 的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator = 必须要调用基类的operator = 完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能 保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派生类对象初始化先调用基类构造再调派生类构造。
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。
#include <iostream>
using namespace std;

class Person
{
public:
	//Person(const char* name = "peter")
	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; // 姓名
};
//派生类的编译器的默认构造函数有做些什么？
//1.把父类成员看作一个整体
//2.自己的成员
// a、内置类型
// b、自定义类型
// （规则与之前的相同，内置类型不做处理，自定义类型调用自己的默认构造函数）
//3.
class Student : public Person
{
public:
	//父类没写默认构造就自己写
	//Student(int num,const char* str,const char* name)
	//	:_name(name)//不允许单独对父类的成员进行初始化
	//	,_num(num)
	//	,_str(str)
	//{}
	//派生类 = 父类 + 子类，父类的调用·父类·构造函数初始化(把父类当作一个整体)
	Student(int num, const char* str, const char* name)
		:Person(name)//不允许单独对父类的成员进行初始化
		, _num(num)
		, _str(str)
	{}
protected:
	//Person _p;//看作整体来使用
	int _num;
	string _str;

};
int main()
{
	//父类提供了默认构造
	//Student s;

	//父类没写默认构造就自己写
	Student s(1, "abc", "peter");
	return 0;
}

8.2、派生类 = 父类 + 子类，父类的调用·父类·构造函数初始化(把父类当作一个整体)

#include <iostream>
using namespace std;

class Person
{
public:
	//Person(const char* name = "peter")
	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 B
{
public:
	B(int num, const char* str, const char* name)
		:_p(name)
		,_num(num)
		,_str(str)
	{}
private:
	Person _p;//看作整体来使用
	int _num;
	string _str;
};

int main()
{
	B b(1, "abcd", "只能");
	return 0;
}

8.3、派生类的拷贝构造

1.内置类型不做处理(浅拷贝)
2.自定义类型会去调用它的拷贝构造(深拷贝)
3.父类会去调用父类自己的拷贝构造(父类看作一个自定义类型)

#include <iostream>
using namespace std;

class Person
{
public:
	//Person(const char* name = "peter")
	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:
	//父类 +自己，父类的调用父类构造函数初始化(复用)
	Student(int num, const char* str, const char* name)
		:Person(name)
		, _num(num)
		, _str(str)
	{
		cout << "Student()" << endl;
	}

	//s2(s1) -- 拷贝构造
	//切割/切片复制兼容
	//复制兼容 -- 编译器进行特殊处理
	Student(const Student& s)
		:Person(s)//直接传参，自动切片/切割
		, _num(s._num)
		, _str(s._str)
	{}

	//s3 = s2赋值构造
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//注意：派生类的与父类的同名，构成隐藏,需要指定作用域
			_num = s._num;
			_str = s._str;
			//_name = s._name;//父类复用
		}
		return *this;
	}
	//析构一般编译器就足够使用了，一些特定的资源需要手动释放
	~Student()
	{
		//一般手动就是复用父类的析构就行了
		//~Person();//多态和编译器的处理，造成隐藏
		//但是发现，此处不能显示的调用
		//由于多态中，析构函数的名字会被统一处理成destruct，造成了隐藏；比如刚才的operator的子类隐藏父类的原因，
		//导致子类的析构会隐藏父类
		//解决：指定其作用域
		cout << "~Student" << endl;
		//Person::~Person();//注意显示的写就无法保证析构是先子后父，所以一般就让子类析构结束后，系统自动调用
		//cout << "~Student" << endl;
	}
private:
	int _num;
	string _str;
};

void test1()
{
	Student b(1, "abcd", "哈哈");
	Student s2(b);
	Student s3(1, "abcd", "呵呵");
	s2 = s3;

	//析构函数和定位new可直接显示调用
	Person p("析构");
	p.~Person();
}

//构造要保证先父后子
//析构要保证先子后父
void test2()
{
	Student s1(1, "abcd", "只能");
}
int main()
{
	//test1();
	test2();
	return 0;
}

9、复用的几个体现

1.函数逻辑的复用
2.模板的复用(本质是交给编译器处理)
3.继承(派生类 = 父类 + 子类 --》 内置类型、自定义类型、父类看作整体的自定义类型)

9.1、继承与友元

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

#include <iostream>
using namespace std;
class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};
class Student : public Person
{
	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;//父类友元不能访问子类私有和保护成员
	//解决：直接父子都写一个友元类即可
	cout << s._stuNum << endl;
}
void main()
{
	Person p;
	Student s;
	Display(p, s);
}

9.2、继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。

#include <iostream>
using namespace std;

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;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

int main()
{
	//思考：这里的静态成员变量count会是几份呢？
	//父类静态成员属于当前类，也属于当前类的所有派生类，即公开的，是公用的
	TestPerson();
	return 0;
}

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

基本格式：
1.单继承：一个子类只有一个直接父类时称这个继承关系为单继承
class PostGraduate:public Student ----> class Student:public Person --> class Person
2.多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
class Assistant:public Student,public Teather ----> class Student和 class Teather
3.菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
在Assistant的对象中Person成员会有两份。
class Assistant:public Student,public Teather ----> class Student:public Person 和 class Teather:public Person --> class Person

9.4 、菱形继承就容易可能出现隐含的问题

1.数据冗余
2.二义性
解决方案：虚继承 – virtual关键字

#include <iostream>
using namespace std;
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";
	a._name = "peter";//virtual

	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}
int main()
{
	Test();
	return 0;
}

小结：

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

10、总结

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

  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在 派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他 成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected private。

  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过 最好显示的写出继承方式。

  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced / private继承，也不提倡 使用protetced / private继承，因为protetced / private继承下来的成员都只能在派生类的类里 面使用，实际中扩展维护性不强。
    6.建议：在实际中在继承体系里面最好不要定义同名的成员。

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

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

相关文章

Rust中的并发性：Sync 和 Send Traits

Rust中的并发性：Sync 和 Send Traits

在并发的世界中&#xff0c;最常见的并发安全问题就是数据竞争&#xff0c;也就是两个线程同时对一个变量进行读写操作。但当你在 Safe Rust 中写出有数据竞争的代码时&#xff0c;编译器会直接拒绝编译。那么它是靠什么魔法做到的呢&#xff1f; 这就不得不谈 Send 和 Sync 这…
阅读更多...
排序算法大总结

排序算法大总结

引言 排序算法&#xff08;sorting algorithm&#xff09;是用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用&#xff0c;因为有序数据通常能够被更高效地查找、分析和处理。 如图 1-1 所示&#xff0c;排序算法中的数据类型可以是整数、浮点数、字符或字符串等…
阅读更多...
SpringBoot中实现发送邮件

SpringBoot中实现发送邮件

概要 在Spring Boot中发送电子邮件相对简单。你可以使用Spring的邮件支持来实现这一点。 步骤&#xff1a; 1.添加依赖&#xff1a;首先&#xff0c;需要在你的pom.xml文件中添加Spring Boot的邮件发送器依赖。 2. 配置邮件服务器&#xff1a;在application.properties或app…
阅读更多...
Python 机器学习 基础 之 学习 基础环境搭建

Python 机器学习 基础 之 学习 基础环境搭建

Python 机器学习 基础 之 学习 基础环境搭建 目录 Python 机器学习 基础 之 学习 基础环境搭建 一、简单介绍 二、什么是机器学习 三、python 环境的搭建 1、Python 安装包下载 2、这里以 下载 Python 3.10.9 为例 3、安装 Python 3.10.9 4、检验 python 是否安装成功&…
阅读更多...
设计模式第二次测试 | 数据库连接池设计（原型模式、创建者模式、适配器模式）

设计模式第二次测试 | 数据库连接池设计（原型模式、创建者模式、适配器模式）

需求中文如下&#xff1a;原本是英文&#xff0c;用百度翻译转换而来 我们需要设计一个工具&#xff0c;它负责创建一个与数据库软件MySQL的连接池。 连接池中有数百个连接可供客户端使用。 所有连接对象都有相同的内容&#xff0c;但它们是不同的对象。 连接对象的创建是资源密…
阅读更多...
【嵌入式笔试题】进程线程笔试题

【嵌入式笔试题】进程线程笔试题

非常经典的笔试题。 1.进程&线程（16道） 1.1异步IO和同步IO区别？ 答案：如果是同步IO，当一个IO操作执行时，应用程序必须等待，直到此IO执行完。 相反，异步IO操作在后台运行，IO操作和应用程序可以同时运行，提高系统性能，提 高IO流量。 解读：在同步文件IO中，线…
阅读更多...
Sarcasm detection论文解析 |用于微博讽刺检测的上下文增强卷积神经网络

Sarcasm detection论文解析 |用于微博讽刺检测的上下文增强卷积神经网络

论文地址 论文地址&#xff1a;Context-augmented convolutional neural networks for twitter sarcasm detection - ScienceDirect 论文首页 笔记大纲 用于微博讽刺检测的上下文增强卷积神经网络 &#x1f4c5;出版年份:2018 &#x1f4d6;出版期刊:Neurocomputing &#x1f…
阅读更多...
Django后台项目开发实战五

Django后台项目开发实战五

完成两个功能&#xff1a; HR 可以维护候选人信息面试官可以录入面试反馈 第五阶段 创建 interview 应用&#xff0c;实现候选人面试评估表的增删改功能&#xff0c;并且按照页面分组来展示不同的内容&#xff0c;如候选人基础信息&#xff0c;一面&#xff0c;二面的面试结…
阅读更多...
在离线环境中将 CentOS 7.5 原地升级并迁移至 RHEL 7.9

在离线环境中将 CentOS 7.5 原地升级并迁移至 RHEL 7.9

《OpenShift / RHEL / DevSecOps 汇总目录》 说明 本文将说明如何在离线环境中将 CentOS 7.5 升级并迁移至 RHEL 7.9。为了简化准备过程&#xff0c;本文前面将在在线环境中安装用到的各种所需验证软件&#xff0c;而在后面升级迁移的时候再切换到由 ISO 构成的离线 Yum Repo…
阅读更多...
20240430，类模板案例-数组类封装，STL初识，STRING容器(构造函数，赋值）

20240430，类模板案例-数组类封装，STL初识，STRING容器(构造函数，赋值）

我真的碎掉了&#xff0c;主要是我很缺那点钱啊现在&#xff0c;我真的碎掉了我碎掉了碎掉了碎掉了 0.8 类模板案例-数组类封装 需求&#xff1a;1&#xff0c;存储&#xff1a;内置和自定义数据类型&#xff1b; 2&#xff0c;存到堆区&#xff1b; 3&#xff0c;构造函数传入…
阅读更多...
Docker部署RabbitMQ与简单使用

Docker部署RabbitMQ与简单使用

官网地址&#xff1a; Messaging that just works — RabbitMQ 我的Docker博客:Docker-CSDN博客 1.结构 其中包含几个概念&#xff1a; **publisher**&#xff1a;生产者&#xff0c;也就是发送消息的一方 **consumer**&#xff1a;消费者&#xff0c;也就是消费消息的一方 …
阅读更多...
第三节课，功能2：开发后端用户的管理接口--http client -- debug测试

第三节课，功能2：开发后端用户的管理接口--http client -- debug测试

一、idea 中 Http client 使用 二、测试步骤&#xff0c;先进入主程序 2.1 先run &#xff0c;再debug 2.2 再进入想要测试的代码 2.2.1 进入测试的接口 三、程序逻辑 1&#xff09;用户注册逻辑&#xff1a;如果用户不存在再后端&#xff0c;看用户名&密码&校验码是…
阅读更多...
一些优雅的监控运维技巧

一些优雅的监控运维技巧

准备工作 安装 sysstat sudo apt install sysstat查看某个进程的cpu情况 pidstst -u -p 256432查看某个进程的RAM情况 pidstst -r -p 256432查看某个进程的IO情况 pidstst -d -p 256432查看某个进程下的线程执行情况 pidstst -t -p 256432查看指定PID的进程对应的可执行文件…
阅读更多...
ip ssl证书无限端口网站

ip ssl证书无限端口网站

IP SSL证书是由CA认证机构颁发的一种特殊数字证书。大部分SSL数字证书都需要用户使用域名进行申请&#xff0c;想要对公网IP地址加密实现https访问就需要申请IP SSL证书。IP SSL证书采用了强大的加密算法&#xff0c;可以有效地防止数据在传输过程中被窃取或篡改&#xff0c;具…
阅读更多...
nbcio-boot基于jeecg的flowable支持部门经理的单个或多实例支持（前端部分）

nbcio-boot基于jeecg的flowable支持部门经理的单个或多实例支持（前端部分）

更多ruoyi-nbcio功能请看演示系统 gitee源代码地址 前后端代码&#xff1a; https://gitee.com/nbacheng/ruoyi-nbcio 演示地址&#xff1a;RuoYi-Nbcio后台管理系统 http://218.75.87.38:9666/ 更多nbcio-boot功能请看演示系统 gitee源代码地址 后端代码&#xff1a; h…
阅读更多...
特斯拉与百度合作；字节正全力追赶AI业务；小红书内测自研大模型

特斯拉与百度合作；字节正全力追赶AI业务；小红书内测自研大模型

特斯拉中国版 FSD 或与百度合作 根据彭博社的报道&#xff0c;特斯拉将通过于百度公司达成地图和导航协议&#xff0c;扫清在中国推出 FSD 功能的关键障碍。 此前&#xff0c;中国汽车工业协会、国家计算机网络应急技术处理协调中心发布《关于汽车数据处理 4 项安全要求检测情…
阅读更多...
大数据组件之Storm详解

大数据组件之Storm详解

Storm 是一个免费并开源的分布式实时计算系统&#xff0c;具有高容错性和可扩展性。它能够处理无边界的数据流&#xff0c;并提供了实时计算的功能。与传统的批处理系统相比&#xff0c;Apache Storm 更适合处理实时数据。 让我们深入了解一下 Storm&#xff1a; 1.Storm 简介…
阅读更多...
Systemback Ubuntu14.04 制作自定义系统ISO镜像

Systemback Ubuntu14.04 制作自定义系统ISO镜像

工作需要&#xff0c;要基于ubuntu自定义一些编译环境并将自己配置好的ubuntu做成镜像。 硬件准备 ​ 为保证能够顺利完成系统iso镜像的制作与系统还原&#xff0c;推荐准备一个较大容量的U盘或者移动固态硬盘&#xff0c;同时确保自己的Ubuntu系统还有比较大的可用空间。 1 S…
阅读更多...
sgg_ssm学习--前端搭建遇到的问题

sgg_ssm学习--前端搭建遇到的问题

目录 问题1&#xff1a;由于我是解压缩软件nodejs&#xff0c;没有添加系统路径 解决&#xff1a;添加nodejs的路径 到系统 path中 问题2&#xff1a;vscode 终端输入npm命令 报错 解决(如图所示在vscode打开前端工程&#xff0c;终端修改如下配置)&#xff1a; 问题1&…
阅读更多...
CSS 伪类、伪元素的应用实例：电池充电、高能进度条

CSS 伪类、伪元素的应用实例：电池充电、高能进度条

一、目的 本文通过 CSS 伪类、伪元素&#xff0c;结合动画 animation 和 Vue 动态样式属性&#xff08;通过 CSS 变量&#xff09;的写法&#xff0c;来实现电池充电、高能进度条的效果&#xff0c;如下图所示。 二、基础知识 1、CSS 伪类、伪元素 简单概括成以下 4 点&#x…
阅读更多...
最新文章

Copyright @ 2022~2023

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