详解Rust标准库：VecDeque 队列

theme: github
highlight: an-old-hope

查看本地官方文档

安装rust后运行

rustup doc

查看The Standard Library即可获取标准库内容

std::connections::VecDeque定义

队列是遵循先入先出规则的线性数据结构，在内存中不一定连续

VecDeque定义：可增长的环形缓冲区实现的双端队列

pub struct VecDeque<T, A: Allocator = Global> {// 队列头部在内部缓冲区中的索引位置head: usize,// 当前队列中的元素数量len: usize,// 管理内存分配和释放，确保有足够的空间来存储队列中的元素buf: RawVec<T, A>,
}

方法

with_capacity：用于创建一个具有指定初始容量的VecDeque

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.get(1) {println!("Element at index 1: {}", element);// Element at index 1: 2}
}

get：获取指定索引位置的元素的不可变引用

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.get(1) {println!("Element at index 1: {}", element);// Element at index 1: 2}
}

get_mut：获取指定索引位置的元素的可变引用

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.get_mut(1) {*element = 4;}println!("Modified deque: {:?}", deque);// Modified deque: [1, 4, 3]
}

swap：交换VecDeque中两个指定索引位置的元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);deque.swap(0, 2);println!("Swapped deque: {:?}", deque);// Swapped deque: [3, 2, 1]
}

capacity：返回VecDeque当前的容量

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::with_capacity(5);println!("Initial capacity: {}", deque.capacity());// Initial capacity: 5deque.push_back(1);println!("Capacity after adding an element: {}", deque.capacity());// Capacity after adding an element: 5
}

reserve_exact：精确地预留足够的空间以容纳指定数量的额外元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::new();deque.reserve_exact(3);println!("Capacity after reserve_exact: {}", deque.capacity());// Capacity after reserve_exact: 3deque.push_back(1);deque.push_back(2);deque.push_back(3);
}

reserve：预留足够的空间以容纳指定数量的额外元素（空间不够自动增长）

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::new();deque.reserve(5);println!("Capacity after reserve: {}", deque.capacity());// Capacity after reserve: 5deque.push_back(1);deque.push_back(2);deque.push_back(3);deque.push_back(4);deque.push_back(5);deque.push_back(6);println!("Capacity after reserve: {}", deque.capacity());// Capacity after reserve: 10
}

try_reserve_exact：尝试精确地预留足够的空间以容纳指定数量的额外元素，如果预留成功则返回Ok(())，否则返回错误

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::new();if let Ok(()) = deque.try_reserve_exact(3) {println!("Reserved successfully. Capacity: {}", deque.capacity());// Reserved successfully. Capacity: 3} else {println!("Reserve failed.");}deque.push_back(1);deque.push_back(2);deque.push_back(3);deque.push_back(4);println!("Reserved successfully. Capacity: {}", deque.capacity());// Reserved successfully. Capacity: 6
}

try_reserve：尝试预留足够的空间以容纳指定数量的额外元素，如果预留成功则返回Ok(())，否则返回错误

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::new();if let Ok(()) = deque.try_reserve(3) {println!("Reserved successfully. Capacity: {}", deque.capacity());// Reserved successfully. Capacity: 4} else {println!("Reserve failed.");}deque.push_back(1);deque.push_back(2);deque.push_back(3);deque.push_back(4);
}

shrink_to_fit：将VecDeque的容量收缩到与当前元素数量相同

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::with_capacity(10);deque.push_back(1);deque.push_back(2);deque.push_back(3);deque.shrink_to_fit();println!("Capacity after shrink_to_fit: {}", deque.capacity());// Capacity after shrink_to_fit: 3
}

shrink_to：将VecDeque的容量收缩到指定大小

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::with_capacity(10);deque.push_back(1);deque.push_back(2);deque.push_back(3);deque.shrink_to(5);println!("Capacity after shrink_to: {}", deque.capacity());// Capacity after shrink_to: 5
}

truncate：将VecDeque截断到指定长度

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);deque.truncate(3);println!("Truncated deque: {:?}", deque);// Truncated deque: [1, 2, 3]
}

iter：返回一个不可变的迭代器，用于遍历VecDeque中的元素

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3]);for element in deque.iter() {println!("Element: {}", element);}// Element: 1// Element: 2// Element: 3
}

iter_mut：返回一个可变的迭代器，允许在遍历过程中修改VecDeque中的元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);for element in deque.iter_mut() {*element *= 2;}println!("Modified deque: {:?}", deque);// Modified deque: [2, 4, 6]
}

as_slice：将VecDeque分成不可变的切片

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3, 4, 5]);let (front_slice, back_slice) = deque.as_slices();println!("Front slice: {:?}", front_slice);// Front slice: [1, 2, 3, 4, 5]println!("Back slice: {:?}", back_slice);// Back slice: []
}

as_mut_slices：将VecDeque分成可变的切片

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);let (front_slice, back_slice) = deque.as_mut_slices();for element in front_slice {*element *= 2;}for element in back_slice {*element *= 3;}println!("Modified deque: {:?}", deque);// Modified deque: [2, 4, 6, 8, 10]
}

len：返回VecDeque中元素的数量

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3]);println!("Length of deque: {}", deque.len());// Length of deque: 3
}

is_empty：判断VecDeque是否为空

use std::collections::VecDeque;fn main() {let deque:VecDeque<i32> = VecDeque::new();println!("Is deque empty? {}", deque.is_empty());// Is deque empty? truelet deque2 = VecDeque::from([1]);println!("Is deque2 empty? {}", deque2.is_empty());// Is deque2 empty? false
}

range：返回一个指定范围内的不可变迭代器

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3, 4, 5]);for element in deque.range(1..3) {println!("Element: {}", element);// Element: 2// Element: 3}
}

range_mut：返回一个指定范围内的可变迭代器

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);for element in deque.range_mut(1..3) {*element *= 2;}println!("Modified deque: {:?}", deque);// Modified deque: [1, 4, 6, 4, 5]
}

drain：移除并返回一个迭代器，用于遍历被移除的元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);let drained = deque.drain(1..3).collect::<Vec<i32>>();println!("Drained elements: {:?}", drained);// Drained elements: [2, 3]println!("Remaining deque: {:?}", deque);// Remaining deque: [1, 4, 5]
}

clear：清空VecDeque，移除所有元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);println!("Before clearing: {:?}", deque);// Before clearing: [1, 2, 3]deque.clear();println!("After clearing: {:?}", deque);// After clearing: []
}

contains：判断VecDeque中是否包含特定元素

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3]);println!("Does deque contain 2? {}", deque.contains(&2));// Does deque contain 2? trueprintln!("Does deque contain 4? {}", deque.contains(&4));// Does deque contain 4? false
}

front：返回VecDeque头部元素的不可变引用，如果为空则返回None

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.front() {println!("Front element: {}", element);// Front element: 1}
}

front_mut：返回VecDeque头部元素的可变引用，如果为空则返回None

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.front_mut() {*element = 4;}println!("Modified deque: {:?}", deque);// Modified deque: [4, 2, 3]
}

back：返回VecDeque尾部元素的不可变引用，如果为空则返回None

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.back() {println!("Back element: {}", element);// Back element: 3}
}

back_mut：返回VecDeque尾部元素的可变引用，如果为空则返回None

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.back_mut() {*element = 4;}println!("Modified deque: {:?}", deque);// Modified deque: [1, 2, 4]
}

pop_front：移除并返回VecDeque头部元素，如果为空则返回None

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.pop_front() {println!("Popped element: {}", element);// Popped element: 1}println!("Remaining deque: {:?}", deque);// Remaining deque: [2, 3]
}

pop_back：移除并返回VecDeque尾部元素，如果为空则返回None

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.pop_back() {println!("Popped element: {}", element);// Popped element: 3}println!("Remaining deque: {:?}", deque);// Remaining deque: [1, 2]
}

push_front：在VecDeque头部插入一个元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::new();deque.push_front(1);deque.push_front(2);println!("Modified deque: {:?}", deque);// Modified deque: [2, 1]
}

push_back：在VecDeque尾部插入一个元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::new();deque.push_back(1);deque.push_back(2);println!("Modified deque: {:?}", deque);// Modified deque: [1, 2]
}

swap_remove_front：移除并返回VecDeque头部开始的元素索引，同时用其后的第一个元素替换它，避免移动其后的所有元素，如果为空则返回None

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4]);if let Some(element) = deque.swap_remove_front(2) {println!("Swapped and removed element: {}", element);// Swapped and removed element: 3}println!("Remaining deque: {:?}", deque);// Remaining deque: [2, 1, 4]
}

swap_remove_back：移除并返回VecDeque尾部开始的元素索引，同时用前一个元素替换它，避免移动前面的所有元素，如果为空则返回None

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4]);if let Some(element) = deque.swap_remove_back(2) {println!("Swapped and removed element from back: {}", element);// Swapped and removed element from back: 3}println!("Remaining deque: {:?}", deque);// Remaining deque: [1, 2, 4]
}

insert：在指定索引位置插入一个元素。如果索引超出范围，会导致程序 panic（元素为[1,2,3]时容量为3，插入索引1不改变容量，插入4时由于索引是连续的，会开辟原队列的两倍容量6，后续插入索引5可以成功，如果直接插入5索引不连续不会开辟新空间会panic）

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);println!("deque capacity: {}", deque.capacity());// deque capacity: 3deque.insert(1, 9);// deque.insert(4, 5); // 这一行存在以下操作成功，不存在 panic!deque.insert(5, 6); // panic!'println!("deque capacity: {}", deque.capacity());// deque capacity: 6println!("After insertion: {:?}", deque);// After insertion: [1, 9, 2, 4, 3, 6]println!("deque capacity: {}", deque.capacity());// deque capacity: 6
}

remove：移除指定索引位置的元素，并返回该元素。如果索引超出范围，会导致程序 panic

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);if let Some(element) = deque.remove(1) {println!("Removed element: {}", element);// Removed element: 2}println!("Remaining deque: {:?}", deque);// Remaining deque: [1, 3]
}

split_off：在指定索引位置将VecDeque分割成两个，返回从指定索引开始的后半部分

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);let deque2 = deque.split_off(2);println!("{:?}", deque2);// [3, 4, 5]
}

append：将另一个VecDeque的所有元素追加到当前VecDeque的末尾

use std::collections::VecDeque;fn main() {let mut deque1 = VecDeque::from([1, 2, 3]);let mut deque2 = VecDeque::from([4, 5, 6]);deque1.append(&mut deque2);println!("Appended deque: {:?}", deque1);// Appended deque: [1, 2, 3, 4, 5, 6]
}

retain：保留满足给定谓词的元素，移除不满足的元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);deque.retain(|&x| x % 2 == 0);println!("After retain: {:?}", deque);// After retain: [2, 4]
}

retain_mut：与retain类似，但可以对元素进行可变操作

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);deque.retain_mut(|x| {*x *= 2;*x % 3 == 0});println!("After retain_mut: {:?}", deque);// After retain_mut: [6]
}

resize_with：调整VecDeque的大小到指定长度，使用给定的函数生成新元素填充额外的空间或者截断多余的元素

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2]);deque.resize_with(5, || 0);println!("Resized deque: {:?}", deque);// Resized deque: [1, 2, 0, 0, 0]
}

make_contiguous：尝试使VecDeque在内存中连续存储，可能会导致重新分配内存

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3]);deque.make_contiguous();println!("After make_contiguous: {:?}", deque);// After make_contiguous: [1, 2, 3]
}

rotate_left：将VecDeque向左旋转指定的步数

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);deque.rotate_left(2);println!("After rotate_left: {:?}", deque);// After rotate_left: [3, 4, 5, 1, 2]
}

rotate_right：将VecDeque向右旋转指定的步数

use std::collections::VecDeque;fn main() {let mut deque = VecDeque::from([1, 2, 3, 4, 5]);deque.rotate_right(2);println!("After rotate_right: {:?}", deque);// After rotate_right: [4, 5, 1, 2, 3]
}

binary_search：在已排序的VecDeque中进行二分查找指定元素，返回一个Result类型，表示查找结果。如果找到元素，返回Ok(index)，默认最后一个结果；如果未找到返回Err()；在未排序的队列进行查找会返回unspecified，这个结果没有意义

当查找的元素不存在时返回查找元素应当插入位置有序队列位置的索引

当查找的元素存在时返回最后一个匹配的元素

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3, 3, 4, 5]);let result = deque.binary_search(&3);println!("{:?}", result);// Ok(3)// 有序且不存在let deque = VecDeque::from([3, 3, 3, 3, 3, 4, 4, 7, 8]);let result = deque.binary_search(&5);println!("{:?}", result);// Err(7)// 有序且存在let deque = VecDeque::from([3, 3, 3, 3, 3, 4, 4, 7, 8]);let result = deque.binary_search(&3);println!("{:?}", result);// Ok(4)// 注意以下结果没有意义// 无序且不存在let deque = VecDeque::from([3, 9, 3, 3, 8, 4, 3, 7, 3]);let result = deque.binary_search(&5);println!("{:?}", result);// Err(4)// 无序且存在let deque = VecDeque::from([3, 9, 3, 3, 8, 4, 3, 7, 3]);let result = deque.binary_search(&3);println!("{:?}", result);// Ok(2)
}

binary_search_by：使用自定义的比较函数在已排序的VecDeque中进行二分查找

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([1, 2, 3, 3, 4, 6]);// 找到最后一个等于3的元素索引let result = deque.binary_search_by(|x| x.cmp(&3));println!("{:?}", result);// Ok(3)// 找到最后一个等于5de的元素索引,不存在返回应当插入位置的索引let result = deque.binary_search_by(|x| x.cmp(&5));println!("{:?}", result);// Err(5)
}

binary_search_by_key：如果队列是以元组键的顺序排序的，使用自定义的键提取函数在已排序的VecDeque中进行二分查找

use std::collections::VecDeque;fn main() {let deque = VecDeque::from([(0, 0),(2, 1),(4, 1),(5, 1),(3, 1),(1, 2),(2, 3),(4, 5),(5, 8),(3, 13),(1, 21),(2, 34),(4, 55),]);// 按元组第二个键值排序let result = deque.binary_search_by_key(&13, |&(a, b)| b);println!("{:?}", result);// Ok(9)
}

partition_point：在已排序的VecDeque中找到满足给定谓词的元素的分界点。即返回第一个不满足谓词的元素的索引

use std::collections::VecDeque;fn main() {let deque: VecDeque<i32> = VecDeque::from([1, 2, 3, 3, 5, 6, 7]);// 按小于5的元素划分，返回第一个大于等于5的索引let result = deque.partition_point(|&x| x < 5);println!("{:?}", result);// 4
}

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

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

相关文章

有哪些实用的 Ads Spy 工具推荐？

有哪些实用的 Ads Spy 工具推荐？

了解竞争对手的广告策略至关重要。Ads Spy 工具可以帮助我们洞察竞争对手的广告活动&#xff0c;从而优化自己的推广计划。以下是一些实用的 Ads Spy 工具介绍&#xff1a; 1. PowerAdSpy&#xff1a;可以按广告版位全渠道搜索筛选&#xff0c;实时在线筛查正在展示的广告&…
阅读更多...
01 Oracle 数据库存储结构深度解析：从数据文件到性能优化的全链路探究

01 Oracle 数据库存储结构深度解析：从数据文件到性能优化的全链路探究

文章目录 Oracle 数据库存储结构深度解析&#xff1a;从数据文件到性能优化的全链路探究一、Oracle存储结构的物理层次1.1 控制文件&#xff08;Control File&#xff09;1.2 联机重做日志文件&#xff08;Online Redo Log File&#xff09;1.3 数据文件&#xff08;Data File&…
阅读更多...
练习LabVIEW第四十二题

练习LabVIEW第四十二题

学习目标&#xff1a; 使用labview编写一个用户确认界面&#xff1a; 我们在程序中赋予5个人的账号密码&#xff0c;账号使用人名&#xff0c;密码随便&#xff0c;并规定相关权限。访问权限要在前面板显示&#xff0c;并且访问成功与否也要有显示。 开始编写&#xff1a; 前…
阅读更多...
如何安装QT（linux/windows）

如何安装QT（linux/windows）

1. linux 1.1 下载安装程序 进入QT官网&#xff0c;点击右上角下载 Qt | Tools for Each Stage of Software Development Lifecycle​www.qt.io/ 然后选择下载linux版本&#xff0c;这里你需要填写一些信息&#xff0c;注册一些即可 填写之后会出现下面这个网页&#xff0c;…
阅读更多...
数组和指针的复杂关系

数组和指针的复杂关系

C语言中指针和数组的关系似乎很“纠结”&#xff0c;让人爱恨交织。本文试图帮助读者理清它们之间的复杂关系&#xff01; 数组名的理解 数组元素在内存中是连续存放的&#xff0c;在C语言中&#xff0c;数组名有特殊的含义&#xff0c;它表示数组首元素的地址。因此&#xf…
阅读更多...
pandas和numpy介绍

pandas和numpy介绍

pandas和numpy都是Python中用于数据处理和分析的重要库&#xff0c;它们有以下特点和区别&#xff1a; numpy&#xff08;Numerical Python&#xff09; 基本功能&#xff1a; numpy是一个功能强大的Python库&#xff0c;主要用于对多维数组执行计算。它提供了一个高性能的多…
阅读更多...
GitHub每日最火火火项目（11.6）

GitHub每日最火火火项目（11.6）

项目名称&#xff1a;zmh-program/chatnio 项目介绍&#xff1a;“zmh-program/chatnio”是下一代 AI 一站式国际化解方案&#xff0c;无论是 B 端还是 C 端用户都能从中受益。它支持众多知名的 AI 模型&#xff0c;如 OpenAI、Midjourney、Claude、讯飞星火、Stable Diffusion…
阅读更多...
前后端分离，Jackson，Long精度丢失

前后端分离，Jackson，Long精度丢失

案例:后端接口放回一个Long数据 GetMapping("/testForLong")public Map<String, Object> testForLong() {Map<String, Object> map new HashMap<>();map.put("aaa", 1234567890123456789L);return map;}实际前端接收的数据 前后端数据…
阅读更多...
1.3 自然语言处理的应用

1.3 自然语言处理的应用

自然语言处理&#xff08;NLP&#xff09;在多个领域有广泛应用&#xff0c;如自动文摘、机器翻译、情感分析等。本实战将通过NLTK库&#xff0c;演示文本预处理的关键技术&#xff0c;包括小写转换、去噪、文本规范化、词干提取、词形还原、标记化以及删除停止词。这些技术为构…
阅读更多...
深度学习经典模型之LeNet-5

深度学习经典模型之LeNet-5

1 LeNet-5 1.1 模型介绍 ​ LeNet-5是由 L e C u n LeCun LeCun 提出的一种用于识别手写数字和机器印刷字符的卷积神经网络&#xff08;Convolutional Neural Network&#xff0c;CNN&#xff09; [ 1 ] ^{[1]} [1]&#xff0c;其命名来源于作者 L e C u n LeCun LeCun的名字…
阅读更多...
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01

计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01

计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01 目录 文章目录 计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01目录1. A Perspective for Adapting Generalist AI to Specialized Medical AI Applications and Their Challenges2. Synergi…
阅读更多...
D60【python 接口自动化学习】- python基础之数据库

D60【python 接口自动化学习】- python基础之数据库

day60 数据库定义 学习日期&#xff1a;20241106 学习目标&#xff1a;MySQL数据库-- 128&#xff1a;数据库定义 学习笔记&#xff1a; 无处不在的数据库 数据库如何存储数据 数据库管理系统&#xff08;数据库软件&#xff09; 数据库和SQL的关系 总结 数据库就是指数据…
阅读更多...
windows C#-弃元(上)

windows C#-弃元(上)

弃元是一种在应用程序代码中人为取消使用的占位符变量。 弃元相当于未赋值的变量&#xff1b;它们没有值。 弃元将意图传达给编译器和其他读取代码的文件&#xff1a;你打算忽略表达式的结果。 你可能需要忽略表达式的结果、元组表达式的一个或多个成员、方法的 out 参数或模式…
阅读更多...
【图论】——理论基础总结

【图论】——理论基础总结

图论这一章尤其需要图例进行说明&#xff0c;方便理解&#xff0c;对于作者来说很费时间&#xff0c;本文主要为自己复习方便&#xff0c;所以并不会写的非常详细&#xff0c;见谅。 图论 图的基本概念 基本要素&#xff1a; 边节点 两点连成线&#xff0c;多个点连成的线…
阅读更多...
printf影响单片机中断速度

printf影响单片机中断速度

printf是我们常用的调试程序的手段&#xff0c;在第一版程序中&#xff0c;经常会使用printf来验证程序是否工作正确。这样的调试手段应该在正式版的程序发布前注释掉或者删除。而且不当地使用printf也会带来某些功能性问题&#xff0c;例如&#xff0c;在某项目中&#xff0c;…
阅读更多...
mysql error：1449权限问题 及 用户授权

mysql error：1449权限问题 及 用户授权

一、权限问题 Got error: 1449: The user specified as a definer (skip-grants userskip-grants host) does not exist when using LOCK TABLES 在迁移数据库时&#xff0c;定义的definer&#xff0c;在两个数据库之间不同步时&#xff0c;要将不存在的definer改成数据库中已…
阅读更多...
HTB：Grandpa[WriteUP]

HTB：Grandpa[WriteUP]

目录 连接至HTB服务器并启动靶机 1.Which version of Microsoft IIS is running on TCP port 80? 2.Which 2017 CVE abuses a Buffer overflow in the ScStoragePathFromUrl function in that specific IIS version, allowing remote attackers to execute arbitrary code?…
阅读更多...
AI笔筒操作说明及应用场景

AI笔筒操作说明及应用场景

AI笔筒由来&#xff1a; 在快节奏的现代办公环境中&#xff0c;我们一直在寻找既能提升效率、增添便利&#xff0c;又能融入企业文化、展现个人品味的桌面伙伴。为此&#xff0c;我们特推出专为追求卓越、注重细节的您设计的AI笔筒礼品版&#xff0c;它集高科技与实用性于一身…
阅读更多...
ssm+vue684基于WEB技术的在线商品交易平台的设计

ssm+vue684基于WEB技术的在线商品交易平台的设计

博主介绍&#xff1a;专注于Java&#xff08;springboot ssm 等开发框架&#xff09; vue .net php phython node.js uniapp 微信小程序 等诸多技术领域和毕业项目实战、企业信息化系统建设&#xff0c;从业十五余年开发设计教学工作 ☆☆☆ 精彩专栏推荐订阅☆☆☆☆☆不…
阅读更多...
【青牛科技】GC8549替代LV8549/ONSEMI在摇头机、舞台灯、打印机和白色家电等产品上的应用分析

【青牛科技】GC8549替代LV8549/ONSEMI在摇头机、舞台灯、打印机和白色家电等产品上的应用分析

引言 在现代电子产品中&#xff0c;控制芯片的性能直接影响到设备的功能和用户体验。摇头机、舞台灯、打印机和白色家电等领域对控制精度、功耗和成本等方面的要求日益提高。LV8549/ONSEMI等国际品牌的芯片曾是这些产品的主要选择&#xff0c;但随着国内半导体技术的进步&…
阅读更多...
最新文章

Copyright @ 2022~2023