C++11（下）

news2024/11/15 15:41:28

目录

  • 一、类的新功能
    • 1.1 默认成员函数
    • 1.2 类成员变量初始化
    • 1.3 强制生成默认函数的关键字default
    • 1.4 禁止生成默认函数的关键字delete
    • 1.5 继承和多态中的final与override关键字
  • 二、可变参数模板
  • 三、lambda表达式
    • 3.1 C++98中的一个例子
    • 3.2 lambda表达式
    • 3.3 lambda表达式语法
    • 3.4 函数对象与lambda表达式
  • 四、包装器
    • 4.1 function包装器
    • 4.2 bind

一、类的新功能

1.1 默认成员函数

原来的C++的类中，有6个默认成员函数。

  1. 构造函数
  2. 析构函数
  3. 拷贝构造函数
  4. 拷贝赋值重载
  5. 取地址重载
  6. const 取地址重载

最重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，对于自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，对于自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

有人会说，这编译器默认生成的移动构造和移动赋值的条件怎么那么苛刻呢？按照其它6个默认成员函数来说，只要我们没写某一个函数，编译器就会默认生成一个对应的函数，但是对于移动构造是要求我们没写移动构造，并且我们也没写析构函数，拷贝构造，拷贝赋值重载中的任意一个时编译器才会默认生成一个移动构造函数，为什么要这么规定呢？
原因是编译器认为只要我们写了析构函数，拷贝构造函数，拷贝赋值重载函数中的任意一个，那么我们写的这个类就是一个深拷贝的类，因为正常来说只有深拷贝的类需要自己实现析构，拷贝构造，赋值这几个函数。所以假设我们现在写了析构函数，拷贝构造和赋值，但是没写移动构造和移动赋值，如果这个时候编译器给我们默认生成一个移动构造和移动赋值，那么就会出现浅拷贝问题。
例如现在有一个string类，这是一个深拷贝的类，我们实现了析构，拷贝构造，赋值，但是没写移动构造和移动赋值。假如编译器默认生成了移动构造，因为string类中包含的是一个char*类型的_str指针和size，capacity，都是内置类型，那么在调用移动构造时，对于内置类型是完成值拷贝，浅拷贝的，即新构造出来的string的_str和旧的string的_str指向同一块空间，最后这块空间会被析构两次，程序会崩溃。
所以说，如果是深拷贝的类，即我们要自己实现析构，同时要实现拷贝构造，赋值重载函数时，我们就要自己实现移动构造和移动赋值，如果我们没有实现析构，拷贝构造，赋值中的任意一个，说明我们写的类是浅拷贝的类，这时编译器才会自动给我们生成移动构造和移动赋值，默认生成的移动构造对于内置成员完成值拷贝、浅拷贝，对于自定义类型会看它有没有实现移动构造，有实现就调用移动构造，没有实现就调用拷贝构造。

如果你提供了移动构造或者移动赋值，编译器就不会自动提供拷贝构造和拷贝赋值。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.2 类成员变量初始化

C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化，这个在前面的类和对象的文章中已经谈过了，所以这里就不再重复了。

1.3 强制生成默认函数的关键字default

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显式地指定移动构造生成。

在这里插入图片描述

1.4 禁止生成默认函数的关键字delete

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

在这里插入图片描述

1.5 继承和多态中的final与override关键字

这个我们在继承和多态的文章中已经进行了详细讲解这里就不再重复谈了。

二、可变参数模板

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。

printf就是一个最常见的带有可变参数列表的函数：
在这里插入图片描述
这里要再区分一个概念，模板参数是类型，函数参数是对象。

下面就是一个基本可变参数的函数模板：
在这里插入图片描述
那要如何计算我们传了多少个模板参数呢？
C++11规定用sizeof就能算出我们传了多少个模板参数了。
例如：
在这里插入图片描述上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们要用一些特别的方式一一获取参数包的值。

递归函数方式展开参数包
在这里插入图片描述
逗号表达式展开参数包
这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0),(printarg(arg2),0), (printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。
在这里插入图片描述
STL容器中的empalce相关接口函数：
在这里插入图片描述
首先我们看到的emplace系列的接口，支持模板的可变参数，并且是万能引用。那么相对insert和emplace系列接口的优势到底在哪里呢？
在这里插入图片描述

在这里插入图片描述

三、lambda表达式

3.1 C++98中的一个例子

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。
在这里插入图片描述
如果待排序元素为自定义类型，需要用户定义排序时的比较规则：
在这里插入图片描述
随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

3.2 lambda表达式

lambda表达式是一个局部的匿名函数对象。

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
int main()
{
	vector<Goods> v = { { "雪梨", 2.4, 7 }, { "西瓜", 3.5, 6 }, { "苹果", 2.3,3 }, { "菠萝", 1.6, 4 } };

	//lambda表达式本质是一个局部的匿名函数对象
	auto ComparePriceLess = [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; };
	auto ComparePriceGreater = [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; };

	//按价格升序
	sort(v.begin(), v.end(), ComparePriceLess);
	for (const auto& e : v)
	{
		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
	}
	cout << endl;

	//按价格降序
	sort(v.begin(), v.end(), ComparePriceGreater);
	for (const auto& e : v)
	{
		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
	}
	cout << endl;

	//按评价升序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate < g2._evaluate; });
	for (const auto& e : v)
	{
		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
	}
	cout << endl;

	//按名字升序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._name < g2._name; });
	for (const auto& e : v)
	{
		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
	}
	cout << endl;

	return 0;
}

上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个局部的匿名函数对象。

3.3 lambda表达式语法

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement}
1、lambda表达式各部分说明
（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

（2）(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略

（3）mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。

（4）->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

（5）{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
在这里插入图片描述
通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。

2、捕获列表说明
捕捉列表描述了上下文中哪些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针

注意：
a. 父作用域指包含lambda函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空。

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。

f. lambda表达式之间不能相互赋值，即使看起来类型相同，
但是在底层的类型是不同的。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.4 函数对象与lambda表达式

函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。例如：

class Rate
{
public:
	Rate(double rate) : _rate(rate)
	{}

	double operator()(double money, int year)
	{
		return money * _rate * year;
	}

private:
	double _rate;
};

int main()
{
	// 函数对象
	double rate = 0.56;
	Rate r1(rate);
	r1(5000, 10);

	// lambda
	auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
	r2(5000, 10);

	return 0;
}

从使用方式上来看，函数对象与lambda表达式完全一样。
函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。
在这里插入图片描述
通过上图可知，实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。所以lambda表达式在底层也是一个仿函数。

常见的可调用对象有三个：
函数指针，仿函数对象，lambda表达式。

四、包装器

4.1 function包装器

function包装器，也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

//ret = func(x);
//上面func可能是什么呢？func是一个可调用对象，所以func可能是函数指针，函数对象(仿函数对象)，
//也有可能是lamber表达式对象，如此丰富的类型，可能会导致模板的效率低下！为什么呢？我们继续往下看
template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;

	return f(x);
}

//函数指针
double f(double i)
{
	return i / 2;
}

//仿函数类
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

int main()
{
	// 函数名，即函数指针
	cout << useF(f, 11.11) << endl;
	// 仿函数类对象
	cout << useF(Functor(), 11.11) << endl;
	// lamber表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;

	return 0;
}

通过上面的程序验证，我们会发现useF函数模板实例化了三份。
有了包装器就可以很好地解决上面的问题。

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;

	return f(x);
}

//函数指针
double f(double i)
{
	return i / 2;
}

//仿函数类
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

int main()
{
	 函数名，即函数指针
	//cout << useF(f, 11.11) << endl;
	 仿函数类对象
	//cout << useF(Functor(), 11.11) << endl;
	 lamber表达式
	//cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;

	//包装器本质是一个适配器，可以封装像函数指针，仿函数，lambda表达式这样的可调用对象
	vector<function<double(double)>> f1 = { f ,[](double x) {return x / 4; },Functor() };
	int n = 10;
	for (const auto& func : f1)
	{
		cout << func(n++) << endl;
	}


	return 0;
}

//函数指针
int f(int a, int b)
{
	return a + b;
}

//仿函数
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};

class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};

int main()
{
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	// 函数对象(仿函数)
	std::function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;

	// lambda表达式
	std::function<int(int, int)> func3 = [](const int a, const int b){return a + b; };
	cout << func3(1, 2) << endl;

	// 类的成员函数
	//类的静态成员，&符号可写可不写，但是建议写上
	//std::function<int(int, int)> func4 = Plus::plusi;
	std::function<int(int, int)> func4 = &Plus::plusi;
	cout << func4(1, 2) << endl;
	//非静态成员，必须要带上&符号
	std::function<double(Plus, double, double)> func5 = &Plus::plusd;
	cout << func5(Plus(), 1.1, 2.2) << endl;

	return 0;
}

有了包装器，如何解决模板的效率低下，实例化多份的问题呢？

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};
int main()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// lamber表达式
	std::function<double(double)> func3 = [](double d)->double { return d / 4; };
	cout << useF(func3, 11.11) << endl;

	//函数指针，仿函数，lambda表达式经过包装器包装之后都会变成同一个类型了
	//所以使用useF时传func1，func2和func3都是同一个类型了，即模板只会实例化
	//出一份代码

	return 0;
}

在这里插入图片描述

4.2 bind

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺
序调整等操作。
在这里插入图片描述
可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
在这里插入图片描述

// 使用举例
#include <functional>
int add(int a, int b)
{
	return a + b;
}
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}

	static int ssub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//表示绑定函数add 参数分别由调用 func1 的第一，二个参数指定
	function<int(int, int)> func1 = bind(add, placeholders::_1, placeholders::_2);
	//auto func1 = bind(add, placeholders::_1, placeholders::_2);
	
	//func2的类型为 function<void(int, int, int)> 与func1类型一样
	//表示绑定函数 add 的第一，二为： 1， 2
	auto func2 = bind(add, 1, 2);
	cout << func1(1, 2) << endl;
	cout << func2() << endl;


	Sub s;
	//对于非静态的成员函数，第一个参数必须写成&Sub::ssub；但是对于静态的成员函数，第一个参数可以写成
	// &Sub::ssub，也可以写成Sub::ssub，建议统一写上&符号
	//s参数可以&，也可以不&;因为我们传&s时，编译器会类似于用对象的指针->访问，如果传的参数是s，就是对象.访问一样
	function<int(int, int)> func = bind(Sub::ssub, placeholders::_1, placeholders::_2);
	//function<int(int, int)> func = bind(&Sub::ssub, placeholders::_1, placeholders::_2);
	function<int(int, int)> func3 = bind(&Sub::sub, s,placeholders::_1, placeholders::_2);
	//function<int(int, int)> func3 = bind(&Sub::sub, &s, placeholders::_1, placeholders::_2);
	cout << func3(1, 2) << endl;

	// 参数调换顺序
	function<int(int, int)> func4 = bind(&Sub::sub, s,placeholders::_2, placeholders::_1);
	//function<int(int, int)> func4 = bind(&Sub::sub, &s, placeholders::_2, placeholders::_1);
	cout << func4(1, 2) << endl;

	return 0;
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
以上就是今天想要跟大家分享的内容，你学会了吗？如果感觉到有所收获，那就点点小心心，点点关注呗！后期还会持续更新C++的相关知识哦，我们下期见！！！

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

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

相关文章

CUDA----window更新升级cuda版本

CUDA----window更新升级cuda版本

在安装库的过程中发现cuda版本不匹配。我torch安装的是11.7&#xff0c;但是我电脑上安装的是11.2故想升级。 但是我用nvidia-smi命令查询cuda是12.2&#xff0c;这让我费解&#xff0c;后来发现是得使用nvcc -V来查询安装的cuda版本。 详细的升级过程可以看这篇博客&#xff…
阅读更多...
Android约束布局ConstraintLayout的Guideline，CardView

Android约束布局ConstraintLayout的Guideline，CardView

Android约束布局ConstraintLayout的Guideline&#xff0c;CardView <?xml version"1.0" encoding"utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android"http://schemas.android.com/apk/res/android"xmlns:a…
阅读更多...
C++ 类和对象篇(八) const成员函数和取地址运算符重载

C++ 类和对象篇(八) const成员函数和取地址运算符重载

目录 一、const成员函数 1. const成员函数是什么&#xff1f; 2. 为什么有const成员函数&#xff1f; 3. 什么时候需要使用const修饰成员函数&#xff1f; 二、取地址运算符重载 1. 为什么需要重载取地址运算符&#xff1f; 2. 默认取地址运算符重载函数 3. 默认const取地址运…
阅读更多...
016-第三代软件硬件及系统选型

016-第三代软件硬件及系统选型

第三代软件硬件及系统选型 文章目录 第三代软件硬件及系统选型项目介绍硬件选型软件系统选型总结 关键字&#xff1a; Qt、 Qml、 研华、 ubuntu、 x86 项目介绍 欢迎来到我们的 QML & C 项目&#xff01;这个项目结合了 QML&#xff08;Qt Meta-Object Language&…
阅读更多...
java基础 日期工具类

java基础 日期工具类

目录结构&#xff1a; DateUtils.java package dateStudy; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date;public class DateUtils {private static final String FORMAT_1"yyyy-MM-dd HH:mm:ss";//私有方法&#xf…
阅读更多...
国家开放大学 模拟试题 训练

国家开放大学 模拟试题 训练

试卷代号&#xff1a;2136 管理会计 参考 试题 一、单项选择题&#xff08;每小题1分&#xff0c;共20分&#xff09; 1.管理会计依靠各种功能来助力企业战略&#xff0c;下列哪项是管理会计的核心功能( )。 A.评价功能 B.预测功能 C.决策功能…
阅读更多...
计算机算法分析与设计（8）---图像压缩动态规划算法(含C++)代码

计算机算法分析与设计（8）---图像压缩动态规划算法(含C++)代码

文章目录 一、知识概述1.1 问题描述1.2 算法思想1.3 算法设计1.4 例题分析 二、代码 一、知识概述 1.1 问题描述 1. 一幅图像的由很多个像素点构成&#xff0c;像素点越多分辨率越高&#xff0c;像素的灰度值范围为0~255&#xff0c;也就是需要8bit来存储一个像素的灰度值信息…
阅读更多...
某果的一个小参数分析

某果的一个小参数分析

分析链接:aHR0cHM6Ly9hcHBsZWlkLmFwcGxlLmNvbS9hY2NvdW50 分析目标&#xff1a;X-Apple-I-Fd-Client-Info 1.在浏览器搜索关键词&#xff0c;打下断点 我们再里面进行搜索&#xff0c;定位到这个位置&#xff0c;可以看到X-Apple-I-FD-Client-Info这个参数等于e&#xff0c;…
阅读更多...
Netty深入浅出（无处不在的IO）

Netty深入浅出（无处不在的IO）

为什么要有Netty Netty是为了解决网络编程的复杂性和提供易于使用、高性能和可扩展的框架而开发的。它通过提供一组可重用的组件来处理网络通信的低级细节&#xff0c;例如套接字管理、线程和缓冲&#xff0c;简化了开发网络应用程序的过程。这使开发人员可以专注于应用程序逻…
阅读更多...
前端学习| 第二章

前端学习| 第二章

CSS学习|第一章 前言一、概述1. 语法规定2. 代码风格 二、选择器1. 基础选择器标签选择器类选择器id选择器通配符选择器 2. 复合选择器后代选择器子元素选择器并集选择器伪类选择器链接伪类选择器focus 伪类选择器 三、引入方式四、显示模式1. 块元素2. 行内元素3. 行内块元素4…
阅读更多...
FreeRTOS自我救赎3之USB虚拟串口

FreeRTOS自我救赎3之USB虚拟串口

任何项目的功能都从需求出发&#xff0c;在这里我用的是斥侯蜂的一块STM32F407ZGT6 在开发一个项目的过程中&#xff0c;免不了串口调试&#xff0c;而这块板子板载的mircousb不是直接连的引脚而是一个OTGUSB
阅读更多...
Qt实战 数据统计柱状图显示

Qt实战 数据统计柱状图显示

前段时间有朋友找我做个问卷调查的软件&#xff0c;我说现在很多在线文档都有这功能&#xff0c;为啥还要使用Qt撸一个&#xff0c;他说要申请软著&#xff0c;我说&#xff0c;欧了。 我们先看看WPS在线问卷的统计中&#xff0c;柱状图统计的效果吧 我认为主要有以下几个关键…
阅读更多...
集成显卡安装Pytorch

集成显卡安装Pytorch

1、安装pytorch的第一步需要先安装Anaconda&#xff0c;安装步骤可看我这篇教程【Anaconda的下载与安装】 2、安装完Anaconda之后&#xff0c;第二步查看自己电脑的显卡类型&#xff0c;是集成显卡还是独立显卡&#xff0c;我的电脑是集成显卡&#xff0c;若你的是独立显卡&am…
阅读更多...
磁盘满了对日志打印(Logback)的影响

磁盘满了对日志打印(Logback)的影响

背景 我们生产环境有一个服务半夜报警&#xff1a;磁盘剩余空间不足10%&#xff0c;请及时处理。排查后发现是新上线的一个功能&#xff0c;日志打太多导致的&#xff0c;解决方法有很多&#xff0c;就不赘述了。领导担心报警不及时、或者报警遗漏&#xff0c;担心磁盘满了对线…
阅读更多...
OSPF的7大状态和5大报文详讲

OSPF的7大状态和5大报文详讲

- Down OSPF的初始状态 - Init 初始化——我刚刚给别人发Hello报文 我们可以将OSPF邻居建立的过程理解为&#xff1a;我和你打招呼&#xff0c;你和我打招呼&#xff0c;然后咱俩成了邻居 比如&#xff1a; R1和R2要建立OSPF邻居 R1给R2发送了Hello报文&#xff0c;但是R1此时…
阅读更多...
如何提升和扩展 PostgreSQL — 从共享缓冲区到内存数据网格

如何提升和扩展 PostgreSQL — 从共享缓冲区到内存数据网格

利用共享缓存和操作系统缓存利用 RAM Postgres 是一个基于磁盘的数据库&#xff0c;即使您的整个架构是围绕磁盘访问设计的&#xff0c;利用 RAM 也很重要。如果按照人类规模的延迟来判断&#xff0c;这可以将延迟从几天缩短到几分钟&#xff08;图 1&#xff09;。只需看一下…
阅读更多...
【SV中的多线程fork...join/join_any/join_none】

【SV中的多线程fork...join/join_any/join_none】

SV中fork_join/fork_join_any/fork_join_none 1 一目了然1.1 fork...join1.2 fork...join_any1.3 fork...join_none 2 总结 SV中fork_join和fork_join_any和fork_join_none; Note: fork_join在Verilog中也有&#xff0c;只有其他的两个是SV中独有的&#xff1b; 1 一目了然 1.…
阅读更多...
CCF CSP认证 历年题目自练Day26

CCF CSP认证 历年题目自练Day26

题目一 试题编号&#xff1a; 202012-1 试题名称&#xff1a; 期末预测之安全指数 时间限制&#xff1a; 1.0s 内存限制&#xff1a; 512.0MB 题目分析&#xff08;个人理解&#xff09; 还是先看输出&#xff0c;此题简单的离谱&#xff0c;第一行输入小菜有几个测评依据…
阅读更多...
1.3 第一个JAVA程序

1.3 第一个JAVA程序

1.3 第一个JAVA程序 **1.3 第一个Java程序** **前言:** 在1.2节中&#xff0c;我们学习了如何搭建Java开发环境。本节将带你编写并执行你的第一个Java程序。 **1. 编写Java源文件** - 在JDK的bin文件夹下新建文本文档&#xff0c;并重命名为HelloWorld.java。 - 使用记…
阅读更多...
Linux命令笔记

Linux命令笔记

终端命令格式&#xff1a; bash command [-options] [parameter] 7个常见Linux命令&#xff1a; 01 ls | list | 查看当前文件夹下的内容 02 pwd | print work directory | 查看当前所在文件夹 03 cd [目录名] | change directory | 切换文件夹 04 touch [文件名] | touc…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023