C++正则表达式全攻略：从基础到高级应用

news2024/10/5 16:32:46

C++正则表达式全攻略：从基础到高级应用

  • 一、基础知识
  • 二、正则表达式的基本匹配
  • 三、C++中使用正则表达式
  • 四、高级正则表达式
  • 五、实践示例
  • 六、性能优化
    • 6.1、编译正则表达式
    • 6.2、避免过度使用回溯
    • 6.3、优化匹配算法
  • 七、总结

一、基础知识

正则表达式是一种用于匹配、搜索和编辑文本的字符串模式。它由一系列字符和特殊符号构成，可以灵活地表达文本的模式、结构和特征。正则表达式在各种编程语言和应用程序中广泛应用，包括C++。它可以用来在文本中查找特定模式的字符串、验证输入的格式、提取信息和进行文本替换等操作。

正则表达式的基本元素包括普通字符（如字母、数字和符号）、特殊字符（如通配符、边界符和量词）以及捕获组和反向引用等高级功能。通过组合这些元素，可以构建复杂的匹配规则，实现强大的文本处理功能。

C++中使用正则表达式的优势：

  1. 强大的文本处理能力：正则表达式提供了灵活的方式来描述文本模式和规则，能够轻松地实现复杂的文本匹配、搜索和提取功能。

  2. 通过正则表达式，可以快速验证用户输入的数据格式是否符合要求，提高了数据的准确性和一致性。

  3. 正则表达式可以轻松地进行文本替换和格式化操作，例如批量替换文本中的内容或者格式化输出文本。

  4. 正则表达式可以用较短的代码实现复杂的文本处理功能，提高代码的可读性和简洁性。

  5. 正则表达式可以用于日志分析、数据提取、文本解析等各种场景，为 C++ 提供了强大的文本处理工具。

在 C++ 中使用正则表达式，通过提供的<regex>头文件来实现。基本语法和规则：

  1. 普通字符：包括字母、数字和一些符号，表示自身字符。

  2. 特殊字符：包括元字符（如 ^、$、.、*、+、?、|、\ 等），用于描述匹配规则。

  3. 量词：指定前面模式出现的次数，如 *（零次或多次）、+（一次或多次）、?（零次或一次），{m,n}（出现次数范围为m到n次）等。

  4. 转义字符：使用 \ 来转义特殊字符，使其成为普通字符。

  5. 字符类：用 [ ] 表示一组字符中的任意一个。比如 [abc] 匹配 “a”、“b” 或 “c” 中的任意一个。

  6. 捕获组：用( )将模式组合成一个单元，可以获取匹配的子串。

在 C++ 的 <regex> 头文件中，常用的类有 std::regex、std::smatch 和 std::regex_match 等，通过这些类可以实现正则表达式的匹配、搜索和提取。例如，使用 std::regex_match 函数来检查一个字符串是否与指定的正则表达式匹配，使用 std::smatch 类来存储匹配的结果。

正则表达式在 C++ 中的基本语法和规则与其他语言中的正则表达式基本相同，但在具体的实现上可能会有一些差异。可查看官方介绍。
在这里插入图片描述

二、正则表达式的基本匹配

  1. 匹配单个字符：

    • 使用普通字符进行匹配，例如正则表达式 a 可以匹配字符串中的单个字符 “a”。
    • 使用元字符.进行匹配任意单个字符，例如正则表达式 s. 可以匹配字符串中的 “sa”、“sb”、“sc” 等。

  2. 匹配多个字符：

    • 使用量词*匹配前面的字符出现零次或多次，例如正则表达式ab*可以匹配 “a”, “ab”, “abb”, “abbb” 等。
    • 使用量词+匹配前面的字符出现一次或多次，例如正则表达式ab+可以匹配 “ab”, “abb”, “abbb” 等。
    • 使用量词?匹配前面的字符出现零次或一次，例如正则表达式ab?可以匹配 “a”, “ab” 等。
    • 使用花括号{m,n}匹配前面的字符出现m到n次，例如正则表达式a{2,4}可以匹配 “aa”, “aaa”, “aaaa”。

  3. 匹配起始和结束位置：

    • 使用锚字符^匹配字符串的起始位置，例如正则表达式^start可以匹配以 “start” 开头的字符串。
    • 使用锚字符$匹配字符串的结束位置，例如正则表达式end$可以匹配以 “end” 结尾的字符串。

当使用正则表达式进行文本匹配时，需要匹配字符类（character class）和排除字符类（negated character class）。字符类用来匹配一个字符集合中的任何一个字符，而排除字符类则用来匹配除指定字符集合之外的任何字符。

在正则表达式中使用方括号[]来表示一个字符类，方括号内包含要匹配的字符集合。例如：

  • [aeiou] 可以匹配任何一个小写元音字母。
  • [A-Za-z] 可以匹配任何一个大写或小写字母。
  • [0-9] 可以匹配任何一个数字字符。

另外，可以在方括号内使用连字符-来表示一个范围，如[a-z]表示匹配任何一个小写字母。

相反，使用脱字符^在字符类内表示排除字符类。例如：

  • [^aeiou] 可以匹配除了小写元音字母之外的任何字符。

正则表达式支持匹配重复出现的模式，使用不同的量词来指定重复匹配的规则。

常用的量词：

  • *：匹配前面的模式零次或多次。
  • +：匹配前面的模式一次或多次。
  • ?：匹配前面的模式零次或一次。
  • {n}：匹配前面的模式恰好n次。
  • {n,}：匹配前面的模式至少n次。
  • {n,m}：匹配前面的模式至少n次且至多m次。

例如：

  • a* 可以匹配零个或多个 “a”。
  • a+ 可以匹配一个或多个 “a”。
  • a? 可以匹配零个或一个 “a”。
  • a{3} 可以匹配恰好三个 “a”。
  • a{2,4} 可以匹配两个到四个 “a”。

正则表达式还有两个重要的概念是锚点（anchors）和分组（groups）。

锚点用来指定匹配的位置，常用的锚点：

  • ^：匹配字符串的开始位置。
  • $：匹配字符串的结束位置。
  • \b：匹配单词边界。
  • \B：匹配非单词边界。

例如：

  • ^abc 可以匹配以 “abc” 开头的字符串。
  • xyz$ 可以匹配以 “xyz” 结尾的字符串。
  • \bword\b 可以匹配单独的 “word” 单词。
  • \Bword\B 可以匹配 “word” 单词的内部。

分组则用来把对模式的匹配结果进行分组，并对每个分组进行单独的处理。分组用括号()表示。例如：

  • (ab)+ 可以匹配 “ab”、“abab”、“ababab” 等。
  • (a|b) 可以匹配 “a” 或者 “b”。

三、C++中使用正则表达式

  1. 在C++中使用正则表达式需要包含 <regex> 头文件，并使用 std 命名空间。
  2. 使用std::regex类来创建正则表达式对象。正则表达式对象可以用来存储和表示一个特定的正则表达式模式。
  3. 使用正则表达式来进行匹配和搜索。在C++中使用std::regex_search函数和std::regex_match函数来实现这些功能。

示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "Hello, this is a sample text with some numbers 12345.";
    std::regex pattern("\\d+"); // 匹配一个或多个数字

    std::smatch matches; // 用于存储匹配结果

    if (std::regex_search(text, matches, pattern)) {
        std::cout << "Found match: " << matches.str() << std::endl;
    } else {
        std::cout << "No match found." << std::endl;
    }

    return 0;
}

使用std::regex_search函数来搜索文本text，并且尝试找到与正则表达式模式pattern匹配的内容。还使用了std::smatch类来存储匹配的结果，并打印出匹配的内容。

还可以使用std::regex_match函数来检查整个字符串是否完全匹配正则表达式模式。

if (std::regex_match(text, pattern)) {
    std::cout << "Full match found" << std::endl;
} else {
    std::cout << "No full match found" << std::endl;
}

此外，可以使用C++中的正则表达式库来提取和替换匹配的部分。C++标准库中的std::regex类和std::regex_replace函数可以完成这些任务。

示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The cat sat on the mat.";
    std::regex pattern("\\b(cat)\\b"); // 匹配整个单词"cat"

    std::sregex_iterator it(text.begin(), text.end(), pattern);
    std::sregex_iterator end;

    for (; it != end; ++it) {
        std::smatch match = *it;
        std::cout << "Match found: " << match.str() << " at position " << match.position() << std::endl;
    }

    // 替换匹配的部分
    std::string replaced_text = std::regex_replace(text, pattern, "dog");
    std::cout << "Replaced text: " << replaced_text << std::endl;

    return 0;
}

使用std::sregex_iterator来迭代查找匹配的结果，然后使用std::regex_replace函数来替换匹配的部分。这里还使用了position()函数来获取匹配的位置。

四、高级正则表达式

（1）较为复杂的模式匹配。C++的正则表达式库支持一系列功能强大的正则表达式语法，可以用于更复杂的模式匹配需求，实现更精细的文本匹配和提取。
示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The cat sat on the mat. The dog sat on the rug.";
    std::regex pattern("\\b(\\w+)\\s+sat\\s+on\\s+the\\s+(\\w+)\\b"); // 匹配类似"xxx sat on the xxx"的句子

    std::sregex_iterator it(text.begin(), text.end(), pattern);
    std::sregex_iterator end;

    for (; it != end; ++it) {
        std::smatch match = *it;
        std::cout << "Match found: " << match.str() << std::endl;
        std::cout << "First captured group: " << match[1].str() << std::endl;
        std::cout << "Second captured group: " << match[2].str() << std::endl;
    }

    return 0;
}

（2）使用捕获组和回溯。捕获组允许在正则表达式中标记并捕获特定的部分，而回溯则允许在替换文本中引用捕获的内容。
示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The price is $10.99. The total is $25.50.";
    std::regex pattern("\\$(\\d+\\.\\d+)"); // 匹配美元金额

    std::string replaced_text = std::regex_replace(text, pattern, "¥$1"); // 使用捕获组的内容进行替换
    std::cout << "Replaced text: " << replaced_text << std::endl;

    return 0;
}

使用了捕获组来匹配金额，并在替换文本中使用了$1来引用捕获的内容进行替换。这里的$1表示使用第一个捕获组的内容来替换匹配的部分。

（3）懒惰匹配与贪婪匹配。懒惰匹配和贪婪匹配用于描述量词的匹配方式。贪婪匹配尽可能多地匹配字符串，而懒惰匹配则尽可能少地匹配字符串。

在C++的正则表达式中使用?来表示懒惰匹配。示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The cat sat on the mat. The dog sat on the rug.";
    std::regex greedy_pattern("s[a-z]+t"); // 贪婪匹配，尽可能多地匹配s和t之间的字母
    std::regex lazy_pattern("s[a-z]+?t");  // 懒惰匹配，尽可能少地匹配s和t之间的字母

    std::sregex_iterator it_greedy(text.begin(), text.end(), greedy_pattern);
    std::sregex_iterator end_greedy;
    for (; it_greedy != end_greedy; ++it_greedy) {
        std::smatch match = *it_greedy;
        std::cout << "Greedy Match found: " << match.str() << std::endl;
    }

    std::sregex_iterator it_lazy(text.begin(), text.end(), lazy_pattern);
    std::sregex_iterator end_lazy;
    for (; it_lazy != end_lazy; ++it_lazy) {
        std::smatch match = *it_lazy;
        std::cout << "Lazy Match found: " << match.str() << std::endl;
    }

    return 0;
}

贪婪匹配尽可能多地匹配了s和t之间的字母，而懒惰匹配尽可能少地匹配了s和t之间的字母。

（4）向前和向后查找。向前和向后查找提供了一种基于当前匹配位置的相对定位功能，能够查找在特定位置之前或之后的模式。这对于需要匹配特定上下文的情况非常有用。

示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The quick brown fox jumps over the lazy dog";
    std::regex forward_pattern("\\b\\w+(?=\\sfox)"); // 向前查找，匹配fox之前的单词
    std::regex backward_pattern("(?<=brown\\s)\\w+\\b"); // 向后查找，匹配brown之后的单词

    std::smatch match;
    if (std::regex_search(text, match, forward_pattern)) {
        std::cout << "Forward match found: " << match.str() << std::endl;
    }

    if (std::regex_search(text, match, backward_pattern)) {
        std::cout << "Backward match found: " << match.str() << std::endl;
    }

    return 0;
}

向前查找使用 (?=\sfox) 来匹配 fox 之前的单词，向后查找使用 (?<=brown\s) 来匹配 brown 之后的单词。

五、实践示例

（1）数据验证与格式化。邮箱地址进行验证和格式化：

#include <iostream>
#include <regex>
#include <string>

bool isValidEmail(const std::string& email) {
    std::regex pattern(R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})");
    return std::regex_match(email, pattern);
}

std::string formatPhoneNumber(const std::string& phoneNumber) {
    std::regex pattern(R"(\b(\d{3})(\d{3})(\d{4})\b)");
    return std::regex_replace(phoneNumber, pattern, R"($1-$2-$3)");
}

int main() {
    // 邮箱验证
    std::string email = "2505756506@qq.com";
    if (isValidEmail(email)) {
        std::cout << "Email is valid" << std::endl;
    } else {
        std::cout << "Invalid email" << std::endl;
    }

    // 电话号码格式化
    std::string phoneNumber = "12345678901";
    std::string formattedNumber = formatPhoneNumber(phoneNumber);
    std::cout << "Formatted phone number: " << formattedNumber << std::endl;

    return 0;
}

验证是通过std::regex_match实现，而格式化是通过std::regex_replace实现。

（2文本提取与分析。提取文本中的数字并进行分析：

#include <iostream>
#include <regex>
#include <string>
#include <vector>

std::vector<int> extractNumbers(const std::string& input) {
    std::vector<int> numbers;
    std::regex pattern(R"(\d+)");
    std::sregex_iterator iter(input.begin(), input.end(), pattern);
    std::sregex_iterator end;

    for (; iter != end; ++iter) {
        numbers.push_back(std::stoi(iter->str()));
    }

    return numbers;
}

int main() {
    std::string text = "The price of the item is $250. The weight is 5.5 pounds.";
    std::vector<int> numbers = extractNumbers(text);

    std::cout << "Extracted numbers: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 分析提取的数字
    int sum = 0;
    for (int num : numbers) {
        sum += num;
    }

    std::cout << "Sum of the numbers: " << sum << std::endl;

    return 0;
}

（3）日志文件分析。提取和分析日志文件中的关键信息，例如时间戳、IP地址、错误信息等：

#include <iostream>
#include <fstream>
#include <regex>
#include <string>

void analyzeLogFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Error opening file " << filename << std::endl;
        return;
    }

    std::regex timePattern(R"((\d{2}:\d{2}:\d{2}))");
    std::regex ipPattern(R"((\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))");
    std::regex errorPattern(R"(error|ERROR)");

    std::string line;
    while (std::getline(file, line)) {
        std::smatch timeMatch;
        std::smatch ipMatch;
        std::smatch errorMatch;

        if (std::regex_search(line, timeMatch, timePattern) && std::regex_search(line, ipMatch, ipPattern) && std::regex_search(line, errorMatch, errorPattern)) {
            std::cout << "Timestamp: " << timeMatch[0] << ", IP address: " << ipMatch[0] << ", Error: " << errorMatch[0] << std::endl;
        }
    }

    file.close();
}

int main() {
    analyzeLogFile("example.log");
    return 0;
}

（4）高级的文本处理应用。

#include <iostream>
#include <regex>
#include <string>

void advancedTextProcessing(const std::string& text) {
    // 通过正则表达式替换文本中的日期格式
    std::regex datePattern(R"(\b(\d{1,2})/(\d{1,2})/(\d{4})\b)");
    std::string processedText = std::regex_replace(text, datePattern, "$3-$1-$2");
    std::cout << "Processed text with date format replaced: " << processedText << std::endl;

    // 提取文本中的URL
    std::regex urlPattern(R"((https?://\S+))");
    std::sregex_iterator iter(text.begin(), text.end(), urlPattern);
    std::sregex_iterator end;

    std::cout << "Extracted URLs: ";
    for (; iter != end; ++iter) {
        std::cout << iter->str() << " ";
    }
    std::cout << std::endl;

    // 使用正则表达式分组提取文本中的标题和内容
    std::regex articlePattern(R"(<title>(.*?)</title>.*?<content>(.*?)</content>)", std::regex::dotall);
    std::smatch match;
    if (std::regex_search(text, match, articlePattern)) {
        std::cout << "Title: " << match[1].str() << std::endl;
        std::cout << "Content: " << match[2].str() << std::endl;
    }
}

int main() {
    std::string sampleText = "Today's date is 12/30/2023. Visit our website at https://www.baidu.com/ for more information. <title>Sample Title</title><content>This is a sample content.</content>";
    advancedTextProcessing(sampleText);
    return 0;
}

六、性能优化

6.1、编译正则表达式

  1. 预先编译正则表达式：对于会重复使用的正则表达式，建议在程序初始化阶段就进行编译，以避免在每次匹配时都重新编译。可以使用 std::regex 的构造函数来进行编译。

    std::regex regExpr(pattern); // 预先编译正则表达式

  2. 在可能的情况下，尽量使用简单的正则表达式模式，避免过于复杂和耗时的匹配规则。

  3. 在正则表达式中尽量使用非贪婪量词（*?、+?、{n, m}?）来进行匹配，以避免贪婪匹配导致的性能问题。

  4. 如果可能的话，尽量在正则表达式中使用具体的字符串，而不是通用的通配符，以减少匹配的复杂度。

  5. 如果程序需要频繁使用多个正则表达式，可以将它们预先编译并存储起来，以提高性能。

    std::unordered_map<std::string, std::regex> regexCache;
regexCache["datePattern"] = std::regex(R"((\d{1,2})/(\d{1,2})/(\d{4}))");

6.2、避免过度使用回溯

在编写正则表达式时，避免过度使用回溯是非常重要的，因为回溯会导致正则表达式的性能下降，尤其是在处理长文本或复杂模式时。

  1. 尽量使用非贪婪量词（例如*?、+?、{n,m}?），以避免匹配过程中出现不必要的回溯。

  2. 避免在正则表达式中过度使用嵌套的重复，因为这可能导致回溯的增加。尽量简化模式，减少嵌套的深度。

  3. 使用原子组: 原子组可以避免回溯，因此可以使用它们来限制回溯发生的范围。

  4. 如果只需要匹配特定的固定字符串，最好直接使用字符串匹配函数，而不是使用正则表达式。

  5. 有些正则表达式引擎可以将正则表达式编译为确定性有限自动机（DFA），这种方法可以避免回溯，提高匹配性能。

  6. 预先编译正则表达式: 如前面所述，在程序初始化阶段就进行编译，可以避免在每次匹配时都重新编译，提高性能。

6.3、优化匹配算法

  1. 不同的算法在不同的场景下有不同的性能表现。例如，在处理大型文本时，基于有限自动机（DFA）的算法会比回溯算法更高效。

  2. 回溯是一种耗时的操作，尽量避免使得正则表达式需要进行大量回溯，可以通过优化正则表达式模式或使用非贪婪量词来减少回溯次数。

  3. 如果只需要匹配特定的固定字符串，直接使用字符串匹配函数（如 strstr 或其它语言的等效函数）可能比使用正则表达式更高效。

  4. 如果需要频繁匹配相同的正则表达式，可以缓存匹配结果以减少重复的匹配操作。

  5. 对输入文本进行预处理（例如，去除不需要进行匹配的部分）可以减少匹配的复杂度，提高匹配性能。

  6. 对于大量需要匹配的数据，使用多线程并行匹配来加快匹配速度。

七、总结

正则表达式应用方向：

  1. 输入验证：用于验证用户输入的数据是否符合特定的格式，如电子邮件地址、电话号码、日期、密码等。

  2. 数据提取：从文本中提取特定模式的数据，例如从网页中提取链接、从日志文件中提取特定格式的数据等。

  3. 替换和格式化：在文本处理中用于替换特定模式的字符串或格式化文本，例如将日期格式进行统一、删除不需要的空格等。

  4. URL路由：在web开发中用于定义和匹配URL路由规则，实现页面的跳转和参数的提取。

  5. 语法分析：在编译器和解释器中用于解析和处理特定语法和结构，如正则表达式引擎本身就是一个语法解析器的实现。

  6. 日志分析：用于分析和筛选大量日志数据中的特定模式和信息。

  7. 数据清洗：在数据处理和清洗中使用正则表达式来识别和处理不规范的数据格式。

  8. 敏感词过滤：用于在文本中过滤敏感词和不良内容。

  9. 字符串匹配：用于查找字符串中是否包含特定的模式或关键字。

在这里插入图片描述

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

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

相关文章

C#【必备技能篇】cmd重定向

C#【必备技能篇】cmd重定向

文章目录 一、实现目的二、工程1&#xff1a;Test.cs代码三、工程2&#xff1a;MainConsoleApp.cs代码四、测试结果 一、实现目的 通过MainConsoleApp.exe向Test.exe中输入参数&#xff0c;并将结果返回到MainConsoleApp.exe 二、工程1&#xff1a;Test.cs代码 using System…
阅读更多...
机器学习-生存分析：如何基于随机生存森林训练乳腺癌风险评估模型？

机器学习-生存分析：如何基于随机生存森林训练乳腺癌风险评估模型？

一、 引言 乳腺癌是女性最常见的恶性肿瘤之一&#xff0c;也是全球范围内女性死亡率最高的癌症之一。据统计&#xff0c;每年全球有超过200万人被诊断为乳腺癌&#xff0c;其中约60万人死于该疾病。因此&#xff0c;乳腺癌的早期诊断和风险评估对于预防和治疗乳腺癌具有非常重要…
阅读更多...
计算机毕业论文内容参考|基于Java的超市管理系统的设计与实现

计算机毕业论文内容参考|基于Java的超市管理系统的设计与实现

文章目录 摘要：前言绪论1课题背景2国内外现状与趋势3课题内容相关技术与方法介绍系统分析系统设计系统实现系统测试总结与展望后续工作展望摘要： 本文详细介绍了基于Java的超市管理系统的设计与实现。该系统采用Java语言和常用的开发框架，实现了超市的进货、销售、库存等日…
阅读更多...
[Flutter]WindowsOS中相关配置

[Flutter]WindowsOS中相关配置

Flutter项目在Windows平台上如何配置 目录 Flutter项目在Windows平台上如何配置 写在开头 正文 1、OS准备 2、编译环境准备 ① 下载AndroidStudio ② 下载dart ③ 下载flutter ④ 下载并安装VS ⑤ 在AS中配置dart和flutter 3、配置中遇到的问题 写在结尾 写在开头…
阅读更多...
2024年编程学习规划：掌握编程技能的最佳路线

2024年编程学习规划：掌握编程技能的最佳路线

如果大家感感兴趣也可以去看&#xff1a; &#x1f389;博客主页&#xff1a;阿猫的故乡 &#x1f389;系列专栏&#xff1a;JavaScript专题栏 &#x1f389;ajax专栏&#xff1a;ajax知识点 &#x1f389;欢迎关注&#xff1a;&#x1f44d;点赞&#x1f64c;收藏✍️留言 文章…
阅读更多...
经典卷积神经网络-VGGNet

经典卷积神经网络-VGGNet

经典卷积神经网络-VGGNet 一、背景介绍 VGG是Oxford的Visual Geometry Group的组提出的。该网络是在ILSVRC 2014上的相关工作&#xff0c;主要工作是证明了增加网络的深度能够在一定程度上影响网络最终的性能。VGG有两种结构&#xff0c;分别是VGG16和VGG19&#xff0c;两者并…
阅读更多...
JRT代码结构调整和示例

JRT代码结构调整和示例

之前一直没建表专门使用ORM的api&#xff0c;做模板设计器需要建表&#xff0c;就一边开发设计器一般测试和调整ORM的api&#xff0c;只有做业务才能知道哪些api使用别扭&#xff0c;写了设计器之后改进了ORM的api以方便业务操作数据库。新写法差不多是ORM操作数据库的稳定api了…
阅读更多...
【jmeter】将上一个请求的结果作为下一个请求的参数

【jmeter】将上一个请求的结果作为下一个请求的参数

1、简介 ApacheJMeter是Apache组织开发的基于Java的压力测试工具。用于对软件做压力测试&#xff0c;它最初被设计用于Web应用测试但后来扩展到其他测试领域。它可以用于测试静态和动态资源例如静态文件、Java小服务程序、CGI脚本、Java对象、数据库&#xff0c;FTP服务器&…
阅读更多...
Think-on-Graph—基于知识图谱的LLM推理

Think-on-Graph—基于知识图谱的LLM推理

文章目录 背景动机LLM模型存在的问题LLM ⊕ \oplus ⊕KG范式的局限性 LLM ⊗ \otimes ⊗KG范式&#xff08;Think on Graph&#xff0c;ToG&#xff09;LLM ⊗ \otimes ⊗KG范式的过程ToG的三个阶段初始化实体提取关系及实体探索推理 例子及效果相关结论搜索深度和波束宽度对To…
阅读更多...
Centos安装Kafka（KRaft模式）

Centos安装Kafka（KRaft模式）

1. KRaft引入 Kafka是一种高吞吐量的分布式发布订阅消息系统&#xff0c;它可以处理消费者在网站中的所有动作流数据。其核心组件包含Producer、Broker、Consumer&#xff0c;以及依赖的Zookeeper集群。其中Zookeeper集群是Kafka用来负责集群元数据的管理、控制器的选举等。 由…
阅读更多...
大模型通向AGI，腾讯云携手业界专家探索创新应用新风向

大模型通向AGI，腾讯云携手业界专家探索创新应用新风向

引言 一年过去&#xff0c;ChatGPT 引发的 AGI 热潮丝毫未减。只是相对于最初推出时掀起的全民大模型热&#xff0c;如今关于该如何落地的讨论更多了起来。 随着算力、数据库、大数据等底层技术的发展&#xff0c;大模型的建设与在各个领域的应用正在加速推进&#xff0c;那么…
阅读更多...
SaleSmartly获得了Meta Business Partners认证徽章

SaleSmartly获得了Meta Business Partners认证徽章

近日&#xff0c;SaleSmartly通过了社交网络服务巨头Meta在消息领域的Business Partners认证&#xff0c;这项权威且重要的认证进一步证实了SaleSmartly在消息管理领域的卓越实力和卓越成果。 Meta是一家美国互联网公司&#xff0c;旗下拥有Facebook、Instagram、WhatsApp等社交…
阅读更多...
YOLOv8改进 | 注意力篇 | ACmix自注意力与卷积混合模型（提高FPS+检测效率）

YOLOv8改进 | 注意力篇 | ACmix自注意力与卷积混合模型（提高FPS+检测效率）

一、本文介绍 本文给大家带来的改进机制是ACmix自注意力机制的改进版本&#xff0c;它的核心思想是&#xff0c;传统卷积操作和自注意力模块的大部分计算都可以通过1x1的卷积来实现。ACmix首先使用1x1卷积对输入特征图进行投影&#xff0c;生成一组中间特征&#xff0c;然后根…
阅读更多...
项目引入Jar包的几种方式

项目引入Jar包的几种方式

目录 背景 方式一 前提 创建一个jar包 使用 方式二 背景 通常情况下&#xff0c;使用SpringBoot框架开发项目的过程中&#xff0c;需要引入一系列依赖&#xff0c;首选的就是在项目的 pom.xml 文件里面通过Maven坐标进行引入&#xff08;可以通过Maven的坐标引入jar包的前…
阅读更多...
设计模式之工厂设计模式【创造者模式】

设计模式之工厂设计模式【创造者模式】

学习的最大理由是想摆脱平庸&#xff0c;早一天就多一份人生的精彩&#xff1b;迟一天就多一天平庸的困扰。各位小伙伴&#xff0c;如果您&#xff1a; 想系统/深入学习某技术知识点… 一个人摸索学习很难坚持&#xff0c;想组团高效学习… 想写博客但无从下手&#xff0c;急需…
阅读更多...
今天用vite新建的vue3的项目 启动遇到报错

今天用vite新建的vue3的项目 启动遇到报错

UnhandledPromiseRejectionWarning: SyntaxError: Unexpected token ??at Loader.moduleStrategy (internal/modules/esm/translators.js:145:18) (Use node --trace-warnings ... to show where the warning was created) (node:30304) UnhandledPromiseRejectionWarning: U…
阅读更多...
数据库索引、三范式、事务

数据库索引、三范式、事务

索引 索引&#xff08;Index&#xff09;是帮助 MySQL 高效获取数据的数据结构。常见的查询算法,顺序查找,二分查找,二叉排序树查找,哈希散列法,分块查找,平衡多路搜索树 B 树&#xff08;B-tree&#xff09;。 常见索引原则有 选择唯一性索引&#xff1a;唯一性索引的值是唯…
阅读更多...
听GPT 讲Rust源代码--library/panic_unwind

听GPT 讲Rust源代码--library/panic_unwind

File: rust/library/panic_unwind/src/seh.rs 在Rust源代码中&#xff0c;rust/library/panic_unwind/src/seh.rs这个文件的作用是实现Windows操作系统上的SEH&#xff08;Structured Exception Handling&#xff09;异常处理机制。 SEH是Windows上的一种异常处理机制&#xff…
阅读更多...
c++ / day04

c++ / day04

1. 整理思维导图 2. 全局变量&#xff0c;int monster 10000;定义英雄类hero&#xff0c;受保护的属性string name&#xff0c;int hp,int attck&#xff1b;公有的无参构造&#xff0c;有参构造&#xff0c;虚成员函数 void Atk(){blood-0;}&#xff0c;法师类继承自英雄类&a…
阅读更多...
七功能遥控编解码芯片

七功能遥控编解码芯片

一、基本概述 TT6/TR6 是一对为遥控玩具车设计的 CMOS LSI 芯片。TT6 为发射编码芯片&#xff0c;TR6 为接收解码芯片。TT6/TR6 提供七个功能按键控制前进、后退、左转、右转、加速、独立功能 F1,独立功能 F2 的动作。除此以外&#xff0c;还有这五种常规小车功能&#xff08;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023