【C++进阶篇】C++11新特性（下篇）

news2025/11/1 0:27:52

C++函数式编程黑魔法：Lambda与包装器实战全解析

  • 一. lambda表达式
    • 1.1 仿函数使用
    • 1.2 lambda表达式的语法
    • 1.3 lambda表达式使用
      • 1.3.1 传值和传引用捕捉
      • 1.3.2 隐式捕捉
      • 1.3.3 混合捕捉
    • 1.4 lambda表达式原理
    • 1.5 lambda优点及建议
  • 二. 包装器
    • 2.1 function
    • 2.2 bind绑定
  • 三. 最后

一. lambda表达式

lambda可以像仿函数一样传给函数，像sort，它的优势在于代码清晰度高，且简便，它的本质是一个匿名对象。它没有类型，可以使用auto接收推导类型。

1.1 仿函数使用

仿函数作为对象，控制sort排升序还是降序。

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

struct cmpGreater
{
	bool operator()(int X, int Y)
	{
		return X > Y;
	}
};

struct cmpLess
{
	bool operator()(int X, int Y)
	{
		return X < Y;
	}
};
int main()
{
	vector<int> arr{ 10,4,2,6,7,3,8,0,1,5,9 };

	//仿函数传递对象
	sort(arr.begin(), arr.end(), cmpLess());//降序
	for (auto e : arr)
		cout << e << " ";
	cout << endl;

	sort(arr.begin(), arr.end(), cmpGreater());//降序
	for (auto e : arr)
		cout << e << " ";
	return 0;
}

创建vector对象，通过sort排序，仿函数控制升序行为。

  • 输出结果：

在这里插入图片描述

上面已经说过lambda也可以完成仿函数的行为，下面展示一下。

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

int main()
{
	vector<int> arr{ 10,4,2,6,7,3,8,0,1,5,9 };

	//lambda表达式
	//升序
	sort(arr.begin(), arr.end(), [](int x, int y)-> int {return x > y; });//升序
	for (auto e : arr)
		cout << e << " ";
	cout << endl;

	//降序
	sort(arr.begin(), arr.end(), [](int x, int y)-> int {return x < y; });//降序
	for (auto e : arr)
		cout << e << " ";
	cout << endl;
	return 0;
}

输出结果：
在这里插入图片描述
sort函数使用lambda代替仿函数，从结果可以看出一样完成一样的功能。

1.2 lambda表达式的语法

C/C++ lambda 语法格式：

[capture-list] (parameters)-> return type { function boby };

解释：

  1. [Capture List] :捕捉列表，用于定义Lambda如何访问外部作用域的变量。
  2. (Parameters): 参数列表定义 Lambda的输入参数。
  3. ->return type ：返回值类型，⽤追踪返回类型形式声明函数的返回值类型，没有返回值时此
    部分可省略。⼀般返回值类型明确情况下，也可省略，由编译器对返回类型进⾏推导。
  4. {function boby} ：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以
    使⽤其参数外，还可以使⽤所有捕获到的变量，函数体为空也不能省略。

在这里插入图片描述
其中，参数列表，mutable，-> returntype可以省略。

  • 省略参数列表，表示当前是一个无参的参数对象。
  • 省略mutable，表示捕捉的对象保持其常性。
  • 省略->returntype，返回值类型由编译器自动推导。

注意：捕捉列表和函数体不可省略，很容易理解。也就是说最基本的 lambda 表达式 只需要写 [ ]{ }

int main()
{
	//最简单的lambda表达式
	[] {};
	return 0;
}

此时表达式相当于返回值为空，参数为空，函数体为空的匿名对象。

void func()  {  };

lambda表达式本质是匿名对象，而func是一个有名对象，直接调用即可。

1.3 lambda表达式使用

上面说过lambda是匿名对象，该对象出了作用域（当前行）就销毁了，其它作用域无法使用它。
lambda只允许使用函数体及参数中的变量，要想使用外层变量，此时就需要捕捉。
捕捉分为，值捕捉，引用捕捉，隐式捕捉，全捕捉，即混合捕捉等。

1.3.1 传值和传引用捕捉

下面通过写代码，看看编译器现象。
在lambda表达式外定义几个变量，看看lambda表达式是否能使用？？？
在这里插入图片描述
需要捕捉，先进行值捕捉，看看现象。

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

int main()
{
	int x = 10, y = 20;
	[x](int a, int b)//当前作用域调用该匿名对象
		{
			a++;
			b++;
			x;
			cout << "x = " << x << endl;
		}(10,20);

	auto ret1 = [x](int a, int b)//使用对象构建lambda表达式
		{
			a++;
			b++;
			x;
			cout << "x = " << x << endl;
		};
	ret1(20, 30);
	return 0;
}

输出结果：
在这里插入图片描述
下面我们对捕捉的对象进行修改，看看行不行？？？
在这里插入图片描述
从上图可以看出编译器报错，不支持，我们就需要修改呢，有没有办法？？？
有的兄弟，有的，可以是用mutable关键字，加在参数列表即可。默认捕捉的值具有常性。

  • 功能：捕捉的值可以去除该值的常性。
int main()
{
	int x = 10, y = 20;
	[x](int a, int b)//当前作用域调用该匿名对象
	mutable	{
			a++;
			b++;
			x++;
			cout << "x = " << x << endl;
		}(10, 20);
		return 0;
}

在这里插入图片描述
从结果可以看出该值进行了自增。且不是该对象的拷贝对象。
还有其它的方法也可以完成该功能：传引用捕捉。

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

int main()
{
	int x = 10, y = 20;
	//传引用捕捉
	[&x](int a, int b)//当前作用域调用该匿名对象
	{
		a++;
		b++;
		x++;
		cout << "x = " << x << endl;
	}(10, 20);

	return 0;
}

一样的输出结果。
在这里插入图片描述

1.3.2 隐式捕捉

在捕捉列表显示写个 = ，表示为隐式捕捉，我们用了哪些变量就捕捉哪些变量，该行为编译器会自动推导。

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

int main()
{
	int x = 10, y = 20,a=30,b=40,z=50;
	//隐式引用捕捉
	[=]()
	{
		int ret = x + y + a;
		cout << "ret = " << ret << endl;
	}();

	//等价于
	auto ret = [=](){ int ret = x + y + a; cout << "ret = " << ret << endl;};
	ret();
	return 0;
}

输出结果：
在这里插入图片描述
隐式捕捉好处在于代码简洁，提升代码表达力的利器。

1.3.3 混合捕捉

显示捕捉分为传值捕捉和传引用捕捉。混合捕捉是隐式捕捉和显示捕捉的混合体。
规则：

  1. 当使用混合捕捉时，第一个元素必须是&或=。
  2. &混合捕捉时，后面的捕捉变量必须是值捕捉。
  3. =混合捕捉时，后面的捕捉变量必须是引用捕捉。
#include<iostream>
#include<algorithm>
using namespace std;

int main()
{
	int a = 10, b = 20, c = 30, d = 90, x = 1, y = 2, z = 3;
	//混合捕捉,第1个为隐式捕捉
	auto ret = [=,&a,&b](){
		a++;
		b++;
		int ret = a + b + x + y;
		cout << "ret= " << ret << endl;
		return ret;
		};
	ret();

	cout << "之前: x = " << x << ", y = " << y << endl;
	//混合捕捉,第1个为隐式捕捉
	auto ret1 = [&, a, b]() {
		x++;
		y++;
		int ret = a + b + x + y;
		cout << "之后: ";
		cout << "x = " << x <<", y = " << y << endl;
		return ret;
		};
	ret1();

	return 0;
}

输出结果：
在这里插入图片描述
从结果可以看出x和y都进行自增，符合预期行为。
注意：局部静态变量和全局变量不需要捕捉，强行捕捉会报错。

  • 报错示例：

在这里插入图片描述
默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改，mutable加在参数列表的后⾯可以取消其常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。

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

int main()
{
	int x = 10;
	[x]() mutable{
		x++;
		cout << "lambda表达式里的x = " << x << endl;
		return x; }();


	cout << "lambda表达式外的x = " << x << endl;
}

在这里插入图片描述
从结果可以看出x并没有改变，捕捉的对象确实是存储在lambda表达式中临时对象。
当lambda表达式定义在全局变量捕捉列表必须为空，因为没有其它的变量可以被捉到。

1.4 lambda表达式原理

lambda对象的大小。

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

//普通函数
int add(int x, int y)
{
	return x + y;
}

//仿函数
struct ADD
{
	int operator()(int x, int y)
	{
		return x + y;
	};
};

int main()
{
	auto typec = add;
	ADD add1;
	auto ret = [](int x, int y) {return x + y; };

	cout << "普通函数: " << sizeof(typec) << endl;
	cout << "仿函数: " << sizeof(add1) << endl;
	cout << "lambda表达式: " << sizeof(ret) << endl;

	return 0;
}

在这里插入图片描述
可以看出lambda表达式对象与仿函数一样都是大小都是1字节。空类（没有成员变量）独占1个字节。
VS2022两者汇编代码：
在这里插入图片描述
可以看出汇编代码完全一致，所以编译器就是把lambda表达式当做仿函数。
结论：lambda 表达式 本质上就是一个 仿函数。

1.5 lambda优点及建议

  1. 代码简洁性革命
  • 减少模板代码：替代单方法接口的匿名类（如Java的Runnable），代码量减少50%-70%
  • 内联逻辑封装：在算法中间件（如std::sort的比较函数）中直接嵌入逻辑，避免上下文切换
  1. 函数式编程加速器
  • 高阶函数支持：天然适配map/filter/reduce等操作，实现链式数据处理流水线
  • 不可变数据：强制以表达式形式返回值，天然支持无副作用编程
  1. 延迟执行专家
  • 回调封装：在GUI事件处理、异步编程中封装待执行逻辑
  • 策略模式实现：动态替换算法逻辑（如Java的Comparator接口）
  1. 并发编程利器
  • 无状态共享：天然适配并行流（如Java的parallelStream()）
  • 线程安全默认：值捕获（[=]）创建的副本天然隔离线程间数据

最佳实践：Lambda表达式是现代编程的瑞士军刀，但需遵循"3行法则"：超过3行的逻辑应重构为具名函数。合理使用可显著提升代码表现力，但需在简洁性与可维护性间找到平衡点。建议从简单场景开始实践，逐步掌握其高级特性，并始终关注变量作用域和线程安全性。

二. 包装器

包装器分为函数包装器和类包装器。

2.1 function

一个结构一致的函数，lambda表达式基本相同。

// 普通函数
void func(int n)
{
	cout << "void func(int n): " << n << endl;
}

// 仿函数
struct Func
{
public:
	void operator()(int n)
	{
		cout << "void operator()(int n): " << n << endl;
	}
};

// lambda 表达式
auto lambda = [](int n)->void
	{
		cout << "[](int n)->void: " << n << endl;
	};

int main()
{
	void(*pf)(int);//函数指针

	pf = func;//函数名本身就是函数的地址

	pf(10);

	//Func f;//类实例化出对象
	//pf = f;//error

	pf = lambda;
	pf(20);
	return 0;
}

输出结果：
在这里插入图片描述

可以看出函数指针无法指向类对象，仿函数对象。
有没有什么东西可以完成该功能。包装器就是解药。
function就是一个类模版，可以包装任何对象，包括函数指针、仿函数、lambda、宾得表达式等。
function是基于 可变模版参数 实现的，原型如下：

template <class Ret, class… Args>
class function<Ret(Args…)>;

其中Ret是返回值类型，Args为模版参数包，表示传给函数的参数，function 模板类通过 模板特化 指明了包装的函数对象类型。
注意：使用function前，需要包含头文件

int main()
{
	// 包装器
	function<void(int)> f;

	f = func;
	f(10);

	f = Func();
	f(20);

	f = lambda;
	f(30);

	return 0;
}

在这里插入图片描述
function还可以包装 类内成员函数。
包装静态成员函数相对较简单，只需指明类域即可。

#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;


class Plus
{
public:
	Plus(int n = 10)
		:_n(n)
	{}
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return (a + b) * _n;
	}
private:
		int _n;
};

int main()
{
	function<int(int,int)> f = Plus::plusi;
	//function<int(int,int)> f = &Plus::plusi;//correct

	cout << "f(10, 20) = " << f(10, 20) << endl;
	return 0;
}

在这里插入图片描述
下面进行包装静态成员函数，相对复杂一点。使用上述方法会报错。
在这里插入图片描述
解决办法：在包装时，指定第一个参数为类，并且需要取地址。

function<double(Plus,double, double)> f = &Plus::plusd;//因为成员函数还多了个this指针,这个&不可省略

//匿名对象
f(Plus(), 10, 20);

//普通对象
Plus p;
f(p, 10, 20);
return 0;

在这里插入图片描述

  • 细节：为什么包装静态成员函数不需要取地址，而非静态成员函数需要取地址？？？

非静态成员函数必须通过&Plus::plusd、显式获取成员函数指针，并通过std::bind、Lambda或std::mem_fn绑定对象实例，否则无法直接调用。

  • 本质区别：

在这里插入图片描述
当第一参数设置为类的指针时，看看现象。
在这里插入图片描述
第一个参数设置为指针，普通函数可以，对于匿名对象就不可以。
再将第一参数设置为引用版本看看，能不能解决问题。
在这里插入图片描述
可能有人会想第一个参数用const修饰，但是会导致普通的对象无法使用，因为涉及权限放大，从非const到const的放大。

最佳实践：将第一个参数设置为普通的类即可。

2.2 bind绑定

bind 是⼀个函数模板，它也是⼀个可调⽤对象的包装器，可以把他看做⼀个函数适配器，对接收
的fn可调⽤对象进⾏处理后返回⼀个可调⽤对象。 bind 可以⽤来调整参数个数和参数顺序。
bind 也在这个头⽂件中。
原型：

template <class Fn, class... Args>
bind (Fn&& fn, Args&&... args);

fn 是传递的 函数对象，args 是传给函数的 可变参数包，这里使用了 万能引用（引用折叠），使其在进行模板类型推导时，既能引用左值，也能引用右值。
使用bind改变参数顺序。

void func(int x, int y)
{
	cout << "void func(int x, int y)" << x << " " << y << endl;
}

int main()
{
	//正常调用
	func(10, 20);

	auto ret = bind(func, -2,-1);
	ret(10, 20);
	return 0;
}

在这里插入图片描述
输出结果好像不对，因为没有指定类域，导致-2，-1传递给函数。现在指定一下。

 placeholders::_2, placeholders::_1

在这里插入图片描述
结果好像是对的。

bind的底层是仿函数，通过bind绑定的函数将参数根据用户指定的行为传递给函数，函数做出行为。
bind主要作用用于指定参数的个数。
下面我们将第一个参数指定。

int main()
{
	auto f = bind(func, 100, placeholders::_1);
	f(10);
	f(10, 20);
	return 0;
}

此时如果坚持传递参数，会优先使用绑定的参数，再从函数参数列表中，从左到右选择参数进行传递，直到参数数量符合，比如这里第二次调用虽然传递了 10 和 20，但实际调用 Func 时，RFunc 会先传递之前绑定的值 100 作为参数1传递，而 10 会作为参数2传递，至于 20 会被丢弃。
在这里插入图片描述
这里的不能这样写 auto f = bind(func, 100, placeholders::_2);因为参数的个数不满足。

看到上面没都要传递类对象，而bind的引入将一个参数类绑死就不需要传入。

class MyClass {
public:
    void memberFunc(int a, int b) {
        cout << "a = " << a << ", b = " << b << endl;
    }
};

int main() {
    MyClass obj;

    // 绑定类成员函数，固定第一个参数为100
    auto bound_func = bind(&MyClass::memberFunc, &obj, 100, _1);

    // 调用绑定后的函数：只需传递第二个参数（原函数的第二个参数）
    bound_func(200); // 输出：a = 100, b = 200

    return 0;
}

输出结果：
在这里插入图片描述
就不需要手动每次都传递对象。下面看需要传递的麻烦处。

class MyClass {
public:
    void memberFunc(int a, int b) {
        cout << "a = " << a << ", b = " << b
            << ", this = " << this << endl;
    }
};

int main() {
    MyClass obj1, obj2;

    // 绑定成员函数，但保留对象实例的位置为占位符
    auto bound_func = bind(&MyClass::memberFunc, _1, 100, _2);

    // 调用时需显式传递对象实例和其他参数
    bound_func(obj1, 200); // 输出：a = 100, b = 200, this = 0x7ffd...（obj1的地址）
    bound_func(obj2, 300); // 输出：a = 100, b = 300, this = 0x7ffd...（obj2的地址）

    return 0;
}

三. 最后

本文深入解析了C++中lambda表达式与函数包装器的核心机制及实践应用。lambda作为匿名函数对象，通过值/引用/隐式/混合捕捉实现灵活作用域访问，本质是编译器生成的仿函数，支持代码内联封装与函数式编程范式。std::function作为统一调用包装器，可封装普通函数、仿函数、lambda及成员函数，解决函数指针类型限制问题。std::bind通过参数重排与对象绑定实现接口适配，尤其适用于回调场景。三者协同可显著提升代码简洁性，在算法排序、事件处理等场景中简化模板代码，平衡开发效率与可维护性，是现代C++函数式编程的重要工具链。关于线程的部分后面再补充。，也重要

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

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

相关文章

全生命周期的智慧城市管理

全生命周期的智慧城市管理

前言 全生命周期的智慧城市管理。未来&#xff0c;城市将在 实现从基础设施建设、日常运营到数据管理的 全生命周期统筹。这将避免过去智慧城市建设 中出现的“碎片化”问题&#xff0c;实现资源的高效配 置和项目的协调发展。城市管理者将运用先进 的信息技术&#xff0c;如物…
阅读更多...
echarts柱状图实现动态展示时报错

echarts柱状图实现动态展示时报错

echarts柱状图实现动态展示时报错 1、问题&#xff1a; 在使用Echarts柱状图时&#xff0c;当数据量过多&#xff0c;x轴展示不下的时候&#xff0c;可以使用dataZoom实现动态展示。如下图所示&#xff1a; 但是当鼠标放在图上面滚动滚轮时或拖动滚动条时会报错&#xff0c;…
阅读更多...
408第一季 - 数据结构 - 线性表

408第一季 - 数据结构 - 线性表

只能用C/C&#xff01; 顺序表 闲聊 线性表的逻辑顺序和物理顺序相同 都是1234 顺序表的优点&#xff1a; 随机访问&#xff0c;随机访问的意思是访问的时间 和位置没有关系&#xff0c;访问下标1和100一样的&#xff0c;更深层就是直接计算 a100 * 数组大小&#xff0c;随便…
阅读更多...
第23讲、Odoo18 邮件系统整体架构

第23讲、Odoo18 邮件系统整体架构

目录 Odoo 邮件系统整体架构邮件发送方式邮件模板配置SMTP 邮件服务器配置邮件发送过程开发中常见邮件发送需求常见问题排查提示与最佳实践完整示例&#xff1a;审批通过自动发邮件门户表单自动邮件通知案例邮件队列与异步发送邮件添加附件邮件日志与调试多语言邮件模板邮件安…
阅读更多...
HarmonyOS：Counter计数器组件

HarmonyOS：Counter计数器组件

一、概述 计数器组件&#xff0c;提供相应的增加或者减少的计数操作。 说明 该组件从API Version 7开始支持。后续版本如有新增内容&#xff0c;则采用上角标单独标记该内容的起始版本。 二、属性 除支持通用属性外&#xff0c;还支持以下属性。 enableInc enableInc(value: b…
阅读更多...
sqlsugar WhereIF条件的大于等于和等于查出来的坑

sqlsugar WhereIF条件的大于等于和等于查出来的坑

一、如下图所示&#xff0c;当我用 .WhereIF(input.Plancontroltype > 0, u > u.Plancontroltype (DnjqPlancontroltype)input.Plancontroltype) 这里面用等于的时候&#xff0c;返回结果一条数据都没有。 上图中生成的SQL如下&#xff1a; SELECT id AS Id ,code AS …
阅读更多...
Pandas 技术解析：从数据结构到应用场景的深度探索

Pandas 技术解析：从数据结构到应用场景的深度探索

序 我最早用Python做大数据项目时&#xff0c;接触最早的就是Pandas了。觉得对于IT技术人员而言&#xff0c;它是可以属于多场景的存在&#xff0c;因为它的本身就是数据驱动的技术生态中&#xff0c;对于软件工程师而言&#xff0c;它是快速构建数据处理管道的基石&#xff1…
阅读更多...
数据库系统概论（十七）超详细讲解数据库规范化与五大范式（从函数依赖到多值依赖，再到五大范式，附带例题，表格，知识图谱对比带你一步步掌握）

数据库系统概论（十七）超详细讲解数据库规范化与五大范式（从函数依赖到多值依赖，再到五大范式，附带例题，表格，知识图谱对比带你一步步掌握）

数据库系统概论&#xff08;十七&#xff09;超详细讲解数据库规范化与五大范式&#xff08;从函数依赖到多值依赖&#xff0c;再到五大范式&#xff0c;附带例题&#xff0c;表格&#xff0c;知识图谱对比带你一步步掌握&#xff09; 前言一、为什么需要规范化1. 我们先想一个…
阅读更多...
并发编程实战(生产者消费者模型)

并发编程实战(生产者消费者模型)

在并发编程中使用生产者和消费者模式能够解决绝大多数的并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序整体处理数据的速度。 生产者和消费者模式&#xff1a; 在线程的世界中生产者就是产生数据的线程&#xff0c;而消费者则是消费数据的线程。在多线程开…
阅读更多...
git小乌龟不显示图标状态解决方案

git小乌龟不显示图标状态解决方案

第一步 在开始菜单的搜索处&#xff0c;输入regedit命令&#xff0c;打开注册表。 第二步 在注册表编辑器中&#xff0c;找到HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\ShellIconOverlayIdentifiers 这一项。 第三步 让Tortoise相关的项目排在前…
阅读更多...
获取 OpenAI API Key

获取 OpenAI API Key

你可以按照以下步骤来获取 openai.api_key&#xff0c;用于调用 OpenAI 的 GPT-4、DALLE、Whisper 等 API 服务&#xff1a; &#x1f9ed; 获取 OpenAI API Key 的步骤&#xff1a; ✅ 1. 注册或登录 OpenAI 账号 打开 https://platform.openai.com/ 使用你的邮箱或 Google/…
阅读更多...
【Android基础回顾】五：AMS（Activity Manager Service）

【Android基础回顾】五：AMS（Activity Manager Service）

Android 的 AMS&#xff08;Activity Manager Service&#xff09;是 Android 系统中的核心服务之一&#xff0c;负责管理整个应用生命周期、任务栈、进程和四大组件&#xff08;Activity、Service、BroadcastReceiver、ContentProvider&#xff09;的运行。它运行在系统进程 s…
阅读更多...
pycharm中提示C++ compiler not found -- please install a compiler

pycharm中提示C++ compiler not found -- please install a compiler

1.最近用pycharm编译一个开源库,编译的依赖c compiler 2.单单使用pycharm编译&#xff0c;编译器报错C compiler not found – please install a compiler 3.需要在配置环境中引入对应库 4.从新编译后没有提示:C compiler not found – please install a compiler错误。
阅读更多...
一站式直播工具：助力内容创作者高效开启直播新时代

一站式直播工具：助力内容创作者高效开启直播新时代

近年来&#xff0c;随着互联网技术的不断进步和短视频、直播行业的爆发式增长&#xff0c;越来越多的企业和个人投入到直播电商、互动娱乐、在线教育等场景。直播运营过程中&#xff0c;涉及到数据统计、弹幕互动、流程自动化、内容同步等诸多环节。如何提升运营效率、减少人工…
阅读更多...
以智能管理为基础，楼宇自控打造建筑碳中和新路径

以智能管理为基础，楼宇自控打造建筑碳中和新路径

在全球气候变化的严峻形势下&#xff0c;“碳中和”已成为各国发展的重要战略目标。建筑行业作为能源消耗与碳排放的“大户”&#xff0c;其运行阶段的能耗占全社会总能耗近40%&#xff0c;碳排放占比与之相当&#xff0c;实现建筑碳中和迫在眉睫。传统建筑管理模式下&#xff…
阅读更多...
day029-Shell自动化编程-计算与while循环

day029-Shell自动化编程-计算与while循环

文章目录 1. read 交互式初始化变量1.1 案例-安装不同的软件1.2 案例-比较大小 2. 计算2.1 bc2.2 awk2.3 expr2.4 let2.5 案例-计算内存的空闲率2.6 案例-检查域名过期时间和https整数过期时间 3. 循环3.1 循环控制语句3.2 for循环-c语言格式3.3 while循环3.3.1 案例-猜数字3.3…
阅读更多...
Linux命令基础（2）

Linux命令基础（2）

su和exit命令 可以通过su命令切换到root账户 语法&#xff1a;su [-] 用户名 -符号是可选的&#xff0c;表示是否在切换用户后加载环境变量&#xff0c;建议带上 参数&#xff1a;用户名&#xff0c;表示要切换的用户&#xff0c;用户名可以省略&#xff0c;省略表示切换到ro…
阅读更多...
vue3 ＋ vite实现动态路由，并进行vuex持久化设计

vue3 ＋ vite实现动态路由，并进行vuex持久化设计

在后台管理系统中&#xff0c;如何根据后端返回的接口&#xff0c;来动态的设计路由呢&#xff0c;今天一片文章带你们解 1、在vuex中设置一个方法 拿到完整的路由数据 const state {routerList: []}; const mutations { dynameicMenu(state, payload) {// 第一步 通过glob…
阅读更多...
学习路之php--性能优化

学习路之php--性能优化

一、php周边优化 二、代码级优化 变量管理‌ 及时unset()释放大数组/对象&#xff0c;减少内存占用局部变量访问速度比全局变量快约2倍&#xff0c;优先使用局部变量大数组采用引用传递&#xff08;&$var&#xff09;避免内存 循环优化‌ 预计算循环次数&#xff1a; …
阅读更多...
GC1808：高性能24位立体声音频ADC芯片解析

GC1808：高性能24位立体声音频ADC芯片解析

1. 芯片简介 GC1808 是一款24位立体声音频模数转换器&#xff08;ADC&#xff09;&#xff0c;支持96kHz采样率&#xff0c;集成Δ-Σ调制器、数字抗混叠滤波器和高通滤波器&#xff0c;适用于家庭影院、蓝牙音箱等场景。 核心特性 高精度&#xff1a;24位分辨率&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023