【C++】STL性能优化实战

STL性能优化实战

STL (Standard Template Library) 是 C++ 标准库的核心部分，提供了各种容器、算法和迭代器。虽然 STL 提供了强大的功能，但不恰当的使用可能导致性能问题。下面我将详细介绍 STL 性能优化的实战技巧，并通过具体案例说明。

1. 容器选择优化

不同的 STL 容器有不同的性能特性，选择合适的容器对性能影响很大。

案例：从 std::list 到 std::vector

// 优化前：使用list存储大量数据并频繁随机访问
std::list<int> dataList;
for (int i = 0; i < 1000000; i++) {dataList.push_back(i);
}// 查找第500000个元素
auto it = dataList.begin();
std::advance(it, 500000); // O(n)操作，非常慢
int value = *it;// 优化后：使用vector
std::vector<int> dataVector;
dataVector.reserve(1000000); // 预分配内存，避免多次重新分配
for (int i = 0; i < 1000000; i++) {dataVector.push_back(i);
}// 查找第500000个元素，O(1)操作
int value = dataVector[500000];

性能差异：在百万级数据上，vector 的随机访问可能比 list 快数百倍。

2. 内存管理优化

预分配内存

// 优化前
std::vector<int> v;
for (int i = 0; i < 100000; i++) {v.push_back(i); // 可能导致多次重新分配内存
}// 优化后
std::vector<int> v;
v.reserve(100000); // 预先分配足够的内存
for (int i = 0; i < 100000; i++) {v.push_back(i); // 不再需要重新分配内存
}

案例：大型应用中的内存优化

class DataProcessor {
private:std::vector<double> data;std::vector<int> indices;public:// 优化前void processData(const std::vector<double>& input) {// 每次处理都重新分配内存data.clear();indices.clear();for (size_t i = 0; i < input.size(); i++) {if (input[i] > 0) {data.push_back(input[i]);indices.push_back(i);}}}// 优化后void processDataOptimized(const std::vector<double>& input) {// 估计可能的大小并预分配data.clear();indices.clear();data.reserve(input.size() / 2);  // 假设约一半的元素符合条件indices.reserve(input.size() / 2);for (size_t i = 0; i < input.size(); i++) {if (input[i] > 0) {data.push_back(input[i]);indices.push_back(i);}}// 释放多余容量data.shrink_to_fit();indices.shrink_to_fit();}
};

3. 迭代器和算法优化

使用合适的算法

std::vector<int> v(1000000);
// 填充数据...// 优化前：手动查找
int target = 42;
bool found = false;
for (auto it = v.begin(); it != v.end(); ++it) {if (*it == target) {found = true;break;}
}// 优化后：使用STL算法
bool found = std::find(v.begin(), v.end(), target) != v.end();// 更优化：如果容器已排序
std::sort(v.begin(), v.end()); // 先排序
bool found = std::binary_search(v.begin(), v.end(), target); // 二分查找，O(log n)

案例：数据分析应用中的算法优化

class DataAnalyzer {
private:std::vector<double> dataset;public:// 优化前：手动实现统计计算std::pair<double, double> calculateMeanAndStdDev() {double sum = 0.0;for (const auto& value : dataset) {sum += value;}double mean = sum / dataset.size();double sumSquaredDiff = 0.0;for (const auto& value : dataset) {double diff = value - mean;sumSquaredDiff += diff * diff;}double stdDev = std::sqrt(sumSquaredDiff / dataset.size());return {mean, stdDev};}// 优化后：使用STL算法std::pair<double, double> calculateMeanAndStdDevOptimized() {double sum = std::accumulate(dataset.begin(), dataset.end(), 0.0);double mean = sum / dataset.size();double sumSquaredDiff = std::transform_reduce(dataset.begin(), dataset.end(),0.0,std::plus<>(),[mean](double value) { return std::pow(value - mean, 2); });double stdDev = std::sqrt(sumSquaredDiff / dataset.size());return {mean, stdDev};}
};

4. 避免不必要的拷贝

使用引用和移动语义

// 优化前：传值和返回值导致多次拷贝
std::vector<int> processData(std::vector<int> data) {std::vector<int> result;// 处理数据...return result;
}// 优化后：使用引用和移动语义
std::vector<int> processDataOptimized(const std::vector<int>& data) {std::vector<int> result;// 处理数据...return std::move(result); // 使用移动语义
}// 调用方式优化
std::vector<int> input = {1, 2, 3, 4, 5};
// 优化前
auto result1 = processData(input); // 拷贝input// 优化后
auto result2 = processDataOptimized(input); // 使用引用，避免拷贝

案例：大型文本处理应用

class TextProcessor {
private:std::vector<std::string> documents;public:// 优化前void addDocument(std::string doc) {documents.push_back(doc); // 拷贝doc}std::vector<std::string> findMatchingDocuments(std::string pattern) {std::vector<std::string> matches;for (const auto& doc : documents) {if (doc.find(pattern) != std::string::npos) {matches.push_back(doc); // 拷贝doc}}return matches; // 拷贝整个matches}// 优化后void addDocumentOptimized(std::string&& doc) {documents.push_back(std::move(doc)); // 移动doc，避免拷贝}std::vector<std::string> findMatchingDocumentsOptimized(const std::string& pattern) {std::vector<std::string> matches;matches.reserve(documents.size() / 10); // 预估匹配数量for (const auto& doc : documents) {if (doc.find(pattern) != std::string::npos) {matches.push_back(doc); // 仍然是拷贝，但预分配了内存}}return std::move(matches); // 移动返回，避免拷贝}
};

5. 使用 emplace 系列函数

struct ComplexObject {std::string name;int id;std::vector<double> data;ComplexObject(std::string n, int i, std::vector<double> d): name(std::move(n)), id(i), data(std::move(d)) {}
};// 优化前
std::vector<ComplexObject> objects;
std::string name = "Object1";
int id = 42;
std::vector<double> data = {1.0, 2.0, 3.0};
objects.push_back(ComplexObject(name, id, data)); // 构造临时对象然后拷贝/移动// 优化后
objects.emplace_back(name, id, data); // 直接在容器内构造对象，避免临时对象

案例：游戏引擎中的实体管理

class EntityManager {
private:std::vector<Entity> entities;std::unordered_map<std::string, Entity*> entityMap;public:// 优化前void addEntity(const std::string& name, int health, const Position& pos) {Entity entity(name, health, pos);entities.push_back(entity);entityMap[name] = &entities.back();}// 优化后void addEntityOptimized(std::string name, int health, Position pos) {entities.emplace_back(std::move(name), health, std::move(pos));Entity& entity = entities.back();entityMap.emplace(entity.getName(), &entity);}
};

6. 使用正确的查找方法

案例：频繁查找操作的优化

// 场景：需要频繁查找元素
// 优化前：使用vector和find算法
std::vector<int> data = {/* 大量数据 */};
bool exists = std::find(data.begin(), data.end(), target) != data.end(); // O(n)// 优化方案1：如果数据已排序，使用binary_search
std::sort(data.begin(), data.end()); // 一次性排序
bool exists = std::binary_search(data.begin(), data.end(), target); // O(log n)// 优化方案2：如果需要频繁查找，使用unordered_set
std::unordered_set<int> dataSet(data.begin(), data.end());
bool exists = dataSet.find(target) != dataSet.end(); // 平均O(1)

实际应用：网络包过滤器

class PacketFilter {
private:// 优化前：使用vector存储IP黑名单std::vector<std::string> blacklistedIPs;// 优化后：使用unordered_set存储IP黑名单std::unordered_set<std::string> blacklistedIPSet;public:// 优化前bool isBlacklisted(const std::string& ip) {return std::find(blacklistedIPs.begin(), blacklistedIPs.end(), ip) != blacklistedIPs.end();// 时间复杂度：O(n)，n为黑名单大小}// 优化后bool isBlacklistedOptimized(const std::string& ip) {return blacklistedIPSet.find(ip) != blacklistedIPSet.end();// 时间复杂度：平均O(1)}// 初始化函数void initialize(const std::vector<std::string>& ips) {// 优化前blacklistedIPs = ips;// 优化后blacklistedIPSet.clear();blacklistedIPSet.reserve(ips.size());for (const auto& ip : ips) {blacklistedIPSet.insert(ip);}}
};

7. 自定义比较和哈希函数

案例：复杂对象的高效存储和查找

struct Customer {std::string id;std::string name;std::string address;// 其他字段...bool operator==(const Customer& other) const {return id == other.id; // 只比较ID}
};// 自定义哈希函数
namespace std {template<>struct hash<Customer> {size_t operator()(const Customer& c) const {return hash<std::string>()(c.id); // 只哈希ID}};
}// 使用自定义哈希的容器
std::unordered_set<Customer> customers;
std::unordered_map<Customer, int> customerScores;

实际应用：缓存系统

class CacheSystem {
private:struct CacheKey {std::string resource;std::string version;std::string locale;bool operator==(const CacheKey& other) const {return resource == other.resource && version == other.version && locale == other.locale;}};struct CacheKeyHash {size_t operator()(const CacheKey& key) const {// 组合哈希size_t h1 = std::hash<std::string>()(key.resource);size_t h2 = std::hash<std::string>()(key.version);size_t h3 = std::hash<std::string>()(key.locale);return h1 ^ (h2 << 1) ^ (h3 << 2);}};// 使用自定义键和哈希函数的缓存std::unordered_map<CacheKey, std::vector<char>, CacheKeyHash> cache;public:void store(const std::string& resource, const std::string& version, const std::string& locale, const std::vector<char>& data) {CacheKey key{resource, version, locale};cache[key] = data;}bool retrieve(const std::string& resource, const std::string& version,const std::string& locale, std::vector<char>& outData) {CacheKey key{resource, version, locale};auto it = cache.find(key);if (it != cache.end()) {outData = it->second;return true;}return false;}
};

8. 并行算法优化

C++17 引入了并行算法，可以显著提高性能。

#include <execution>
#include <algorithm>
#include <vector>std::vector<int> data(10000000);
// 填充数据...// 优化前：单线程排序
std::sort(data.begin(), data.end());// 优化后：并行排序
std::sort(std::execution::par, data.begin(), data.end());// 其他并行算法示例
std::for_each(std::execution::par, data.begin(), data.end(), [](int& x) { x *= 2; });
auto sum = std::reduce(std::execution::par, data.begin(), data.end(), 0);

案例：图像处理应用

class ImageProcessor {
private:std::vector<Pixel> imageData; // 假设Pixel是一个表示像素的结构体int width, height;public:// 优化前：单线程处理void applyFilter(const Filter& filter) {for (auto& pixel : imageData) {pixel = filter.process(pixel);}}// 优化后：并行处理void applyFilterParallel(const Filter& filter) {std::for_each(std::execution::par,imageData.begin(),imageData.end(),[&filter](Pixel& pixel) {pixel = filter.process(pixel);});}// 优化前：单线程边缘检测std::vector<Edge> detectEdges() {std::vector<Edge> edges;// 复杂的边缘检测算法...return edges;}// 优化后：分块并行边缘检测std::vector<Edge> detectEdgesParallel() {// 将图像分成多个块const int blockSize = height / std::thread::hardware_concurrency();std::vector<std::vector<Edge>> blockEdges(std::thread::hardware_concurrency());std::vector<std::thread> threads;for (int i = 0; i < std::thread::hardware_concurrency(); ++i) {threads.emplace_back([this, i, blockSize, &blockEdges]() {int startY = i * blockSize;int endY = (i == std::thread::hardware_concurrency() - 1) ? height : (i + 1) * blockSize;// 处理当前块for (int y = startY; y < endY; ++y) {for (int x = 0; x < width; ++x) {// 边缘检测逻辑...if (/* 检测到边缘 */) {blockEdges[i].push_back(Edge{x, y});}}}});}// 等待所有线程完成for (auto& thread : threads) {thread.join();}// 合并结果std::vector<Edge> allEdges;for (const auto& edges : blockEdges) {allEdges.insert(allEdges.end(), edges.begin(), edges.end());}return allEdges;}
};

9. 小字符串优化 (SSO) 和字符串视图

// 优化前：频繁创建临时字符串
std::string extractSubstring(const std::string& str, size_t start, size_t length) {return str.substr(start, length);
}void processSubstrings(const std::string& text) {for (size_t i = 0; i < text.size(); i += 10) {std::string sub = extractSubstring(text, i, 10);// 处理sub...}
}// 优化后：使用string_view避免拷贝
std::string_view extractSubstringView(const std::string& str, size_t start, size_t length) {return std::string_view(str.data() + start, std::min(length, str.size() - start));
}void processSubstringsOptimized(const std::string& text) {for (size_t i = 0; i < text.size(); i += 10) {std::string_view sub = extractSubstringView(text, i, 10);// 处理sub...}
}

案例：日志解析器

class LogParser {
private:std::vector<std::string> logLines;public:// 优化前std::vector<std::string> extractTimestamps() {std::vector<std::string> timestamps;timestamps.reserve(logLines.size());for (const auto& line : logLines) {// 假设时间戳在每行的前19个字符if (line.size() >= 19) {timestamps.push_back(line.substr(0, 19));}}return timestamps;}// 优化后：使用string_viewstd::vector<std::string_view> extractTimestampsOptimized() {std::vector<std::string_view> timestamps;timestamps.reserve(logLines.size());for (const auto& line : logLines) {if (line.size() >= 19) {timestamps.emplace_back(line.data(), 19);}}return timestamps;}// 进一步优化：直接处理而不存储void processTimestamps(std::function<void(std::string_view)> processor) {for (const auto& line : logLines) {if (line.size() >= 19) {processor(std::string_view(line.data(), 19));}}}
};

10. 性能分析与测量

优化的最后一步是测量和验证。

#include <chrono>template<typename Func>
auto measureTime(Func&& func) {auto start = std::chrono::high_resolution_clock::now();std::forward<Func>(func)();auto end = std::chrono::high_resolution_clock::now();return std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
}// 使用示例
void comparePerformance() {std::vector<int> data(1000000);// 填充数据...auto timeOriginal = measureTime([&]() {// 原始算法std::sort(data.begin(), data.end());});auto timeOptimized = measureTime([&]() {// 优化算法std::sort(std::execution::par, data.begin(), data.end());});std::cout << "原始算法: " << timeOriginal << "ms\n";std::cout << "优化算法: " << timeOptimized << "ms\n";std::cout << "性能提升: " << (static_cast<double>(timeOriginal) / timeOptimized) << "x\n";
}

案例：大型应用性能分析

class PerformanceAnalyzer {
public:void analyzeDataStructures() {const int dataSize = 1000000;// 测试vector vs list的随机访问性能std::vector<int> vec(dataSize);std::list<int> lst;for (int i = 0; i < dataSize; ++i) {vec[i] = i;lst.push_back(i);}std::cout << "随机访问性能测试:\n";auto vecTime = measureTime([&]() {int sum = 0;for (int i = 0; i < 1000; ++i) {int idx = rand() % dataSize;sum += vec[idx];}});auto lstTime = measureTime([&]() {int sum = 0;for (int i = 0; i < 1000; ++i) {int idx = rand() % dataSize;auto it = lst.begin();std::advance(it, idx);sum += *it;}});std::cout << "Vector随机访问: " << vecTime << "ms\n";std::cout << "List随机访问: " << lstTime << "ms\n";std::cout << "性能差异: " << (static_cast<double>(lstTime) / vecTime) << "x\n";// 测试查找性能std::cout << "\n查找性能测试:\n";std::vector<int> searchVec(dataSize);std::set<int> searchSet;std::unordered_set<int> searchHashSet;for (int i = 0; i < dataSize; ++i) {searchVec[i] = i;searchSet.insert(i);searchHashSet.insert(i);}auto vecSearchTime = measureTime([&]() {int count = 0;for (int i = 0; i < 10000; ++i) {int target = rand() % (dataSize * 2); // 一半会找不到if (std::find(searchVec.begin(), searchVec.end(), target) != searchVec.end()) {count++;}}});auto setSearchTime = measureTime([&]() {int count = 0;for (int i = 0; i < 10000; ++i) {int target = rand() % (dataSize * 2);if (searchSet.find(target) != searchSet.end()) {count++;}}});auto hashSetSearchTime = measureTime([&]() {int count = 0;for (int i = 0; i < 10000; ++i) {int target = rand() % (dataSize * 2);if (searchHashSet.find(target) != searchHashSet.end()) {count++;}}});std::cout << "Vector线性查找: " << vecSearchTime << "ms\n";std::cout << "Set二分查找: " << setSearchTime << "ms\n";std::cout << "Unordered_set哈希查找: " << hashSetSearchTime << "ms\n";}private:template<typename Func>auto measureTime(Func&& func) {auto start = std::chrono::high_resolution_clock::now();std::forward<Func>(func)();auto end = std::chrono::high_resolution_clock::now();return std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();}
};

总结

STL 性能优化是一个系统性工作，需要从多个角度考虑：

  1. 选择合适的容器：根据操作特性选择最适合的容器类型
  2. 内存管理：预分配内存、避免频繁重新分配
  3. 算法选择：使用 STL 提供的高效算法，考虑并行算法
  4. 避免拷贝：使用引用、移动语义和 emplace 系列函数
  5. 高效查找：对于频繁查找操作，使用哈希容器或保持有序状态
  6. 自定义比较和哈希：为复杂对象提供高效的比较和哈希函数
  7. 字符串优化：利用 SSO 和 string_view 减少字符串操作开销
  8. 性能测量：通过实际测量验证优化效果

通过这些技术，可以显著提高 C++ 程序的性能，同时保持代码的可读性和可维护性。

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

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

相关文章

OSI模型_TCP/IP模型_五层模型

OSI模型_TCP/IP模型_五层模型

文章目录 OSI模型_TCP/IP模型_五层模型模型对比模型层级对比关键区别对比 OSI模型OSI模型概述举例说明流程图示 TCP/IP 四层模型模型结构举例说明流程图示 TCP/IP 五层模型模型的结构举例说明流程图示 OSI模型_TCP/IP模型_五层模型 学OSI&#xff0c;用TCP/IP&#xff0c;分析选…
阅读更多...
R语言——字符串

R语言——字符串

参考资料&#xff1a;学习R 文本数据存储在字符向量中。重要的是&#xff0c;字符向量中的每个元素都是字符串&#xff0c;而非单独的字符。 文本的基本单位是字符向量&#xff0c;着意味着大部分字符串处理函数也能用于字符向量。 1、创建和打印字符串 字符向量可用c函数创建…
阅读更多...
如何区别在Spring Boot 2 和 Spring Boot 3 中使用 Knife4j：集成与配置指南

如何区别在Spring Boot 2 和 Spring Boot 3 中使用 Knife4j：集成与配置指南

在现代的 Web 开发中&#xff0c;API 文档是不可或缺的一部分。Knife4j 是基于 Swagger 的增强工具&#xff0c;它不仅提供了更友好的 API 文档界面&#xff0c;还支持更多实用的功能&#xff0c;如离线文档导出、全局参数配置等。本文将详细介绍如何在 Spring Boot 2 和 Sprin…
阅读更多...
pagehelper 分页插件使用说明

pagehelper 分页插件使用说明

pom.xml&#xff1a;pageHelper坐标 <!--pageHelper坐标--><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper-spring-boot-starter</artifactId><version>1.4.6</version></dependency> 分…
阅读更多...
C++可变参数

C++可变参数

可变参数C风格的可变参数C风格可变参数的使用 C11可变参数模板递归展开参数包参数列表展开折叠表达式 STL中的emplace插入接口 可变参数 C风格的可变参数 可变参数是一种语言特性&#xff0c;可以在函数声明中使用省略号...来表示函数接受可变数量的参数。 例如典型的printf…
阅读更多...
数据库的操作，以及sql之DML

数据库的操作，以及sql之DML

首先&#xff0c;创建表以及插入数据 create table t_text(id int primary key auto_increment,name varchar(20) unique not null,gender char(5) not null check(gender in ("男","女")),deed varchar(255) not null default "事例不详"); in…
阅读更多...
vue2前端日志数据存储（indexedD）自动清理3天前的数据

vue2前端日志数据存储（indexedD）自动清理3天前的数据

前言&#xff1a;关于Dexie.js这个前端本地数据库&#xff0c;如何使用IndexedDB来存储数据&#xff0c;并且设置到期自动清理的机制。首先&#xff0c;我需要回忆一下Dexie.js的基本用法&#xff0c;以及IndexedDB的特性。IndexedDB是浏览器中的一种非关系型数据库&#xff0c…
阅读更多...
【MySQL篇】索引特性，索引的工作原理以及索引的创建与管理

【MySQL篇】索引特性，索引的工作原理以及索引的创建与管理

目录 一&#xff0c;初识索引 二&#xff0c;MySQL与磁盘交互的基本单位 三&#xff0c;MySQL中数据文件的特性 四&#xff0c;理解page和索引 五&#xff0c;聚簇索引和非聚簇索引 六&#xff0c;索引操作 查询索引 创建主键索引 唯一索引的创建 普通索引的创建 全文…
阅读更多...
springboot项目启动常见的问题以及配置以及一些使用技巧

springboot项目启动常见的问题以及配置以及一些使用技巧

1.配置仓库 这里要把xml文件从国外的镜像源改成国内的镜像源。改镜像源可以查看这篇文章 点击查看 2.更改文件类型 方法一&#xff1a;右键文件找到Mark Dircetory as可以更改文件类型 方法二&#xff1a; 3.springboot本地Maven仓库的位置 4.pom.xml文件报红错误怎么办 这…
阅读更多...
【初探数据结构】二叉树的顺序结构——堆的实现详解（上下调整算法的时间复杂度分析）

【初探数据结构】二叉树的顺序结构——堆的实现详解（上下调整算法的时间复杂度分析）

&#x1f4ac; 欢迎讨论&#xff1a;在阅读过程中有任何疑问&#xff0c;欢迎在评论区留言&#xff0c;我们一起交流学习&#xff01; &#x1f44d; 点赞、收藏与分享&#xff1a;如果你觉得这篇文章对你有帮助&#xff0c;记得点赞、收藏&#xff0c;并分享给更多对数据结构感…
阅读更多...
流量分析2

流量分析2

一&#xff0c;webshell流量 [GKCTF 2021]签到 先看协议分级&#xff0c;大部分是tcp&#xff0c;里面有http的基于的行文本数据占了很大的比重&#xff0c;看看里面有什么 过滤http的流量 点击一条流量&#xff0c;里面的内容进去后面有基于行的文本数据&#xff0c; 先解he…
阅读更多...
头歌实践教学平台--【数据库概论】--SQL

头歌实践教学平台--【数据库概论】--SQL

一、表结构与完整性约束的修改(ALTER) 1.修改表名 USE TestDb1; alter table your_table rename TO my_table; 2.添加与删除字段 #语句1&#xff1a;删除表orderDetail中的列orderDate alter table orderDetail drop orderDate; #语句2&#xff1a;添加列unitPrice alter t…
阅读更多...
在 React 中，组件之间传递变量的常见方法

在 React 中，组件之间传递变量的常见方法

目录 1. **通过 Props 传递数据**2. **通过回调函数传递数据**3. **通过 Context API 传递数据**4. **通过 Redux 管理全局状态**5. **通过事件总线&#xff08;如 Node.js 的 EventEmitter&#xff09;**6. **通过 Local Storage / Session Storage**7. **通过 URL 查询参数传…
阅读更多...
Redis + 布隆过滤器解决缓存穿透问题

Redis + 布隆过滤器解决缓存穿透问题

Redis 布隆过滤器解决缓存穿透问题 1. Redis 布隆过滤器解决缓存穿透问题 &#x1f4cc; 什么是缓存穿透&#xff1f; 缓存穿透指的是查询的数据既不在缓存&#xff0c;也不在数据库&#xff0c;导致每次查询都直接访问数据库&#xff0c;增加数据库压力。 例如&#xff1…
阅读更多...
Vue动态添加或删除DOM元素：购物车实例

Vue动态添加或删除DOM元素：购物车实例

Vue 指令系列文章： 《Vue插值：双大括号标签、v-text、v-html、v-bind 指令》 《Vue指令：v-cloak、v-once、v-pre 指令》 《Vue条件判断：v-if、v-else、v-else-if、v-show 指令》 《Vue循环遍历：v-for 指令》 《Vue事件处理：v-on 指令》 《Vue表单元素绑定：v-model 指令》…
阅读更多...
vue h5实现车牌号输入框

vue h5实现车牌号输入框

哈喽&#xff0c;大家好&#xff0c;最近鹏仔开发的项目是学校校内车辆超速方面的统计检测方面的系统&#xff0c;在开发过程中发现有个小功能&#xff0c;就是用户移动端添加车牌号&#xff0c;刚开始想着就一个输入框&#xff0c;提交时正则效验一下格式就行&#xff0c;最后…
阅读更多...
硬件基础（5）：（3）二极管的应用

硬件基础（5）：（3）二极管的应用

文章目录 [toc]1. **整流电路****功能**&#xff1a;**工作原理**&#xff1a;**应用实例**&#xff1a;电路组成&#xff1a;整流过程&#xff1a;电路的应用&#xff1a; 2. **稳压电路****功能**&#xff1a;**工作原理**&#xff1a;**应用实例**&#xff1a;电路组成及功能…
阅读更多...
Wireshark网络抓包分析使用详解

Wireshark网络抓包分析使用详解

序言 之前学计网还有前几天备考华为 ICT 网络赛道时都有了解认识 Wireshark&#xff0c;但一直没怎么专门去用过&#xff0c;也没去系统学习过&#xff0c;就想趁着备考的网络相关知识还没忘光&#xff0c;先来系统学下整理点笔记~ 什么是抓包&#xff1f;抓包就是将网络传输…
阅读更多...
安心联车辆管理平台源码价值分析

安心联车辆管理平台源码价值分析

安心联车辆管理平台源码的价值可从技术特性、功能覆盖、市场适配性、扩展潜力及商业化支持等多个维度进行分析。以下结合实际应用进行详细解读&#xff1a; 一、技术架构与开发优势 主流技术栈与高性能架构 源码采用成熟的前后端分离架构&#xff0c;后端基于Java技术&#xff…
阅读更多...
【操作系统】Docker如何使用-续

【操作系统】Docker如何使用-续

文章目录 1、概述2、巩固知识2.1、基础命令2.2、容器管理2.3、镜像管理2.4、网络管理2.5、Compose 3、常用命令 1、概述 在使用Docker的过程中&#xff0c;掌握常用的命令是至关重要的。然而&#xff0c;随着时间的推移&#xff0c;我们可能会遗忘一些关键的命令或对其用法变得…
阅读更多...
最新文章

Copyright @ 2022~2023