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

news2024/11/9 5:03:05

文章目录

  • 一.继承的概念及定义
    • 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的时候，不会影响别的模块，在设计类时应尽可能降低它们之间的练习程度。

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

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

内聚

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

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

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

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

相关文章

无人车之编队控制算法篇

无人车之编队控制算法篇

一、编队控制算法概述 无人车编队控制算法旨在实现多辆无人车之间的协同行驶&#xff0c;保持预定的队形和间距&#xff0c;以应对各种复杂环境和任务需求。该算法通常包括队形生成、队形保持、队形变换和编队模式切换等关键步骤。 二、编队控制算法的核心要素 队形生成&…
阅读更多...
【大数据学习 | kafka高级部分】kafka的数据同步和数据均衡

【大数据学习 | kafka高级部分】kafka的数据同步和数据均衡

1. 数据同步 通过上图我们发现每个分区的数据都不一样&#xff0c;但是三个分区对外的数据却是一致的 这个时候如果第二个副本宕机了 但是如果是leader副本宕机了会发生什么呢&#xff1f; 2. 数据均衡 在线上程序运行的时候&#xff0c;有的时候因为上面副本的损坏&#xff…
阅读更多...
计算机网络——TCP篇

计算机网络——TCP篇

TCP篇 基本认知 TCP和UDP的区别? TCP 和 UDP 可以使用同一个端口吗&#xff1f; 可以的 传输层中 TCP 和 UDP在内核中是两个完全独立的软件模块。可以根据协议字段来选择不同的模块来处理。 TCP 连接建立 TCP 三次握手过程是怎样的&#xff1f; 一次握手:客户端发送带有 …
阅读更多...
Xserver v1.4.2发布，支持自动重载 nginx 配置

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

Xserver——优雅、强大的 php 集成开发环境 本次更新为大家带来了更好的用户体验。 &#x1f389; 下载依赖组件时&#xff0c;显示进度条&#xff0c;展示下载进度。 &#x1f389; 保存站点信息和手动修改 vhost 配置文件之后&#xff0c;自动重载 nginx 配置 &#x1f41e…
阅读更多...
Day107：代码审计-PHP模型开发篇MVC层RCE执行文件对比法1day分析0day验证

Day107：代码审计-PHP模型开发篇MVC层RCE执行文件对比法1day分析0day验证

知识点&#xff1a; 1、PHP审计-MVC开发-RCE&代码执行 2、PHP审计-MVC开发-RCE&命令执行 3、PHP审计-MVC开发-RCE&文件对比 MVC 架构 MVC流程&#xff1a; Controller截获用户发出的请求&#xff1b;Controller调用Model完成状态的读写操作&#xff1b;Contr…
阅读更多...
飞书API-获取tenant_access_token

飞书API-获取tenant_access_token

1.在飞书工作台创建应用&#xff0c;跳到开发者后台&#xff0c;选创建企业自建应用 2.设置并发布应用 必须要发布应用才可以开始使用了&#xff01;&#xff01;&#xff01; 3.调用获取token的API 参考链接&#xff1a; 开发文档 - 飞书开放平台https://open.feishu.cn/do…
阅读更多...
推荐 4 个 YYDS 的开源项目！

推荐 4 个 YYDS 的开源项目！

如下是本期盘点的几个好玩有趣的开源项目&#xff0c;目录&#xff1a; 1. 网页截屏转为代码 2. 将文档转为 Markdown 和 JSon 格式 3. 帮你写代码的 AI 助手 4. 开源 RAG 工具 01 网页截屏转为代码 screenshot-to-code 利用先进的大模型识别屏幕截图中的 UI 元素、布局以及其他…
阅读更多...
Android关机流程知多少？

Android关机流程知多少？

在 Android 中&#xff0c;关机流程涉及系统各个组件的协同工作&#xff0c;确保设备在断电之前能够安全地关闭所有活动并保存数据。以下是 Android 系统中关机流程的详细介绍&#xff1a; 1. 用户触发关机请求 关机流程由用户的操作触发&#xff0c;通常有以下几种方式&#…
阅读更多...
Mac保护电池健康，延长电池使用寿命的好方法

Mac保护电池健康，延长电池使用寿命的好方法

使用Mac的过程中&#xff0c;如何延长电池的使用寿命是大家非常关心的问题&#xff0c;而养成一个良好的充电习惯能够有效的延长电池的使用寿命 避免过度充电和过度放电能够有效的保护电池&#xff0c;因此长时间的充电与长时间放点都不可取&#xff0c;但是在日常的使用过程中…
阅读更多...
Android中Activity启动的模式

Android中Activity启动的模式

在 Android 开发中&#xff0c;Activity 的启动模式&#xff08;Launch Mode&#xff09;定义了当启动一个 Activity 时&#xff0c;系统会如何处理它的实例。不同的启动模式可以影响 Activity 在任务栈中的管理方式&#xff0c;对用户的使用体验产生直接影响。下面详细介绍四种…
阅读更多...
基础算法练习--滑动窗口(已完结)

基础算法练习--滑动窗口(已完结)

算法介绍 滑动窗口算法来自tcp协议的一种特性,它的高效使得其也变成了算法题的一种重要考点.滑动窗口的实现实际上也是通过两个指针前后遍历集合实现,但是因为它有固定的解题格式,我将其单独做成一个篇章. 滑动窗口的解题格式: 首先,定义两个指针left和right,与双指针不同的…
阅读更多...
基于SpringBoot的Java教学支持系统开发指南

基于SpringBoot的Java教学支持系统开发指南

1系统概述 1.1 研究背景 随着计算机技术的发展以及计算机网络的逐渐普及&#xff0c;互联网成为人们查找信息的重要场所&#xff0c;二十一世纪是信息的时代&#xff0c;所以信息的管理显得特别重要。因此&#xff0c;使用计算机来管理教学辅助平台的相关信息成为必然。开发合适…
阅读更多...
C++builder中的人工智能（11）：双曲正切激活函数（ANN函数）？

C++builder中的人工智能（11）：双曲正切激活函数（ANN函数）？

在这篇文章中&#xff0c;我们将探讨双曲正切函数&#xff08;tanh&#xff09;是什么&#xff0c;以及如何在C中使用这个函数。让我们来回答这些问题。 在AI中激活函数意味着什么&#xff1f; 激活函数&#xff08;phi()&#xff09;&#xff0c;也称为转移函数或阈值函数&a…
阅读更多...
Unity SRP学习笔记（二）

Unity SRP学习笔记（二）

Unity SRP学习笔记&#xff08;二&#xff09; 主要参考&#xff1a; https://catlikecoding.com/unity/tutorials/custom-srp/ https://docs.unity.cn/cn/2022.3/ScriptReference/index.html 中文教程部分参考&#xff08;可选&#xff09;&#xff1a; https://tuncle.blog/c…
阅读更多...
帮你快速理解并巧记设计模式

帮你快速理解并巧记设计模式

经常因为记不住或不能理解设计模式而苦恼的童鞋们注意了&#xff0c;闲暇之余总结了常用的22中设计模式&#xff0c;并一一举例&#xff0c;帮助大家快速理解、牢记&#xff0c;如有不对的地方&#xff0c;欢迎大家指正哈 创建型模式 单例模式&#xff08;Singleton Pattern&…
阅读更多...
STM32CUBEIDE FreeRTOS操作教程（八）：queues多队列

STM32CUBEIDE FreeRTOS操作教程（八）：queues多队列

STM32CUBEIDE FreeRTOS操作教程&#xff08;八&#xff09;&#xff1a;queues多队列 STM32CUBE开发环境集成了STM32 HAL库进行FreeRTOS配置和开发的组件&#xff0c;不需要用户自己进行FreeRTOS的移植。这里介绍最简化的用户操作类应用教程。以STM32F401RCT6开发板为例&#…
阅读更多...
防火墙|WAF|漏洞|网络安全

防火墙|WAF|漏洞|网络安全

防火墙|WAF|漏洞|网络安全 防火墙 根据内容分析数据包&#xff1a; 1、源IP和目的IP地址 2、有效负载中的内容。 3、数据包协议&#xff08;例如&#xff0c;连接是否使用 TCP/IP 协议&#xff09;。 4、应用协议&#xff08;HTTP、Telnet、FTP、DNS、SSH 等&#xff09;。 5…
阅读更多...
【04】【Maven项目热部署】将Maven项目热部署到远程tomcat服务器上

【04】【Maven项目热部署】将Maven项目热部署到远程tomcat服务器上

1.虽然现在Maven中央仓库中支持的tomcat插件只支持到tomcat7这个版本&#xff0c;但是可以利用这个插件对Web项目进行热部署&#xff0c;热部署到远程服务器的tomcat服务器上&#xff0c;远程服务器上的tomcat版本可以是更高的版本&#xff0c;比如说tomcat8、9、10或更高的版本…
阅读更多...
大数据新视界 -- 大数据大厂之 Impala 性能优化：融合机器学习的未来之路（上 （2-1））（11/30）

大数据新视界 -- 大数据大厂之 Impala 性能优化：融合机器学习的未来之路（上 （2-1））（11/30）

&#x1f496;&#x1f496;&#x1f496;亲爱的朋友们&#xff0c;热烈欢迎你们来到 青云交的博客&#xff01;能与你们在此邂逅&#xff0c;我满心欢喜&#xff0c;深感无比荣幸。在这个瞬息万变的时代&#xff0c;我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而 我的…
阅读更多...
解决：使用EasyExcel导入Excel模板时出现数据导入不进去的问题

解决：使用EasyExcel导入Excel模板时出现数据导入不进去的问题

解决&#xff1a;使用EasyExcel导入Excel模板时出现数据导入不进去的问题 在Java中&#xff0c;当我们用EasyExcel导入Excel时&#xff0c;可能会出现数据导入不进去的问题。例如&#xff1a; 这种异常等。 问题原因1&#xff1a;这个1代表从第几行开始&#xff0c;你的exce…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023