[项目详解][boost搜索引擎#2] 建立index | 安装分词工具cppjieba | 实现倒排索引

news2024/12/23 15:42:54

目录

编写建立索引的模块 Index

1. 设计节点

2.基本结构

3.(难点) 构建索引

1. 构建正排索引（BuildForwardIndex）

2.❗构建倒排索引

3.1 cppjieba分词工具的安装和使用

3.2 引入cppjieba到项目中

倒排索引代码

本篇文章，我们将继续项目的部分讲解，思路如下

在讲解 index 前，我们先 接着上篇文章 来看一下保存 html 文件

采用下面的方案：

  • 写入文件中，一定要考虑下一次在读取的时候，也要方便操作!
  • 类似：title\3 content\3url \n title\3content\3url \n title\3content\3url \n ...
  • 方便我们getline(ifsream, line)，直接获取文档的全部内容：title\3content\3url

为什么使用‘\3’？

  • \3 在ASSCII码表中是不可以显示的字符，我们将title、content、url用\3进行区分，不会污染我们的文档，当然你也可以使用\4等
bool SaveHtml(const std::vector<DocInfo_t> &results, const std::string &output)
{
    #define SEP '\3'//分割符---区分标题、内容和网址

    // 打开文件，在里面进行写入
    // 按照二进制的方式进行写入 -- 你写的是什么文档就保存什么
    std::ofstream out(output, std::ios::out | std::ios::binary);
    if(!out.is_open())
    {
        std::cerr << "open " << output << " failed!" << std::endl;
        return false;
    }

    // 到这里就可以进行文件内容的写入了
    for(auto &item : results)
        {
            std::string out_string;
            out_string = item.title;//标题
            out_string += SEP;//分割符
            out_string += item.content;//内容
            out_string += SEP;//分割符
            out_string += item.url;//网址
            out_string += '\n';//换行，表示区分每一个文件

            // 将字符串内容写入文件中
            out.write(out_string.c_str(), out_string.size());
        }

    out.close();
    return true;
}
  • 接下来我们做一下测试：
  • /data/raw_html目录下的 raw.txt 就会填入所有的处理完的 html 文档。

尝试查看

至此，我们的parser（去标签+数据清）模块就完成了，为了大家能够更好的理解，下面是一张关系图：

编写建立索引的模块 Index

首先创建 一个 Index.hpp 文件，用来编写 索引模块

该文件主要负责三件事：① 构建索引 、② 正排索引 、③ 倒排索引

构建思路框图：

搜索引擎逻辑：
用户输入【关键字】搜索 → 【倒排索引】搜出 【倒排拉链】 → 倒排拉链中包含所有关键字有关的文档ID及其权重 → 【正派索引】文档ID，得到文档三元素 ， 并按照权重排列呈现给用户

1. 设计节点

  • 正排索引是构建倒排索引的基础
  • 通过给到的关键字，去倒排索引里查找出文档ID，再根据文档ID，找到对应的文档内容
  • 两个节点结构，一个是文档信息的节点，一个是倒排对应的节点；
namespace ns_index
{
    struct DocInfo //文档信息节点
    {
        std::string title;    //文档的标题
        std::string content;  //文档对应的去标签后的内容
        std::string url;      //官网文档的url
        uint64_t doc_id;      //文档的ID
    };
 
    struct InvertedElem //倒排对应的节点
    {
        uint64_t doc_id;      //文档ID
        std::string word;     //关键字（通过关键字可以找到对应的ID）
        int weight;           //权重---根据权重对文档进行排序展示
    };
}

说明：

  • 有 doc_id、word 和 weight；我们可以通过 word 关键字找到对应的文档ID
  • 有文档的信息节点，通过倒排找到的文档ID，就能够在文档信息节点中找到对应的文档所有内容
  • 这两个节点都有doc_id，就像MySQL中外键，相当于两张表产生了关联；

2.基本结构

索引模块最大的两个部分当然是构建正排索引和构建倒排索引，其主要接口如下：

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <unordered_map>
#include <mutex>
#include "log.hpp"

namespace ns_index
{
    struct DocInfo // 文档信息节点
    {
        std::string title;   // 文档的标题
        std::string content; // 文档对应的去标签后的内容
        std::string url;     // 官网文档的url
        uint64_t doc_id;     // 文档的ID
    };

    struct InvertedElem // 倒排对应的节点
    {
        uint64_t doc_id;  // 文档ID
        std::string word; // 关键字（通过关键字可以找到对应的ID）
        int weight;       // 权重---根据权重对文档进行排序展示
    };
    // 倒排拉链--一个关键字对应了一组文档
    typedef std::vector<InvertedElem> InvertedList;

    class Index
    {
    private:
        std::vector<DocInfo> forward_index; // 正排索引
        // 倒排索引
        std::unordered_map<std::string, InvertedList> inverted_index;

    public:
        Index() {}
        ~Index() {}

    public:
        // 根据去标签，格式化后的文档，构建正排和倒排索引
        // 将数据源的路径：data/raw_html/raw.txt传给input即可，这个函数用来构建索引
        bool BuildIndex(const std::string &input)
        {
            return true;
        }
        // 根据倒排索引的关键字word，获得倒排拉链
        InvertedList *GetInvertedList(const std::string &word)
        {
            //...
            return nullptr;
        }
        // 根据doc_id找到正排索引对应doc_id的文档内容
        DocInfo *GetForwardIndex(uint64_t doc_id)
        {
            //...
            return nullptr;
        }
    };
}
  • GetInvertedList函数：根据倒排索引的关键字word，获得倒排拉链（和上面类似）
  • 返回第二个元素
//根据倒排索引的关键字word，获得倒排拉链
InvertedList* GetInvertedList(const std::string &word)
{
    // word关键字不是在 unordered_map 中，直接去里面找对应的倒排拉链即可
    auto iter = inverted_index.find(word);
    if(iter == inverted_index.end()) // 判断是否越界
    {
        std::cerr << " have no InvertedList" << std::endl;
        return nullptr;
    }
    // 返回 unordered_map 中的第二个元素--- 倒排拉链
    return &(iter->second);
}
  • GetForwardIndex函数：根据【正排索引】的 doc_id 找到文档内容
  • 数组下标就是 doc_id
//根据doc_id找到正排索引对应doc_id的文档内容
DocInfo* GetForwardIndex(uint64_t doc_id)
{
    //如果这个doc_id已经大于正排索引的元素个数，则索引失败
    if(doc_id >= forward_index.size())
    {                                                                                                                                                         
          std::cout << "doc_id out range, error!" << std::endl;
          return nullptr;
    }
    return &forward_index[doc_id];//否则返回相应doc_id的文档内容
}

3.(难点) 构建索引

  • 构建索引的思路正好和用户使用搜索功能的过程正好相反。
  • 思路：一个一个文档正排遍历，为其每个构建先正排索引后构建倒排索引。

步骤：

  • 先把处理干净的文档读取上来，是按行读取，这样就能读到每个html文档
  • 按行读上来每个html文档后，我们就可以开始构建正排索引和倒排索引，此时就要提供两个函数，
  • 分别为BuildForwardIndex（构建正排索引）和 BuildInvertedIndex（构建倒排索引）

基本代码如下：

//根据去标签，格式化后的文档，构建正排和倒排索引
//将数据源的路径：data/raw_html/raw.txt传给input即可，这个函数用来构建索引
bool BuildIndex(const std::string &input)
{
    //在上面SaveHtml函数中，我们是以二进制的方式进行保存的，那么读取的时候也要按照二进制的方式读取，读取失败给出提示
    std::ifstream in(input, std::ios::in | std::ios::binary);
    if(!in.is_open())
    {
        std::cerr << "sory, " << input << " open error" << std::endl;
        return false;
    }
 
    std::string line;
    int count = 0;
    while(std::getline(in, line))
    {
        DocInfo* doc = BuildForwardIndex(line);//构建正排索引
 
        if(nullptr == doc)
        {
            std::cerr << "build " << line << " error" << std::endl;
            continue;
        }
 
        BuildInvertedIndex(*doc);//有了正排索引才能构建倒排索引
        count++;    
        if(count % 50 == 0)    
        {    
            std::cout << "当前已经建立的索引文档：" << count << "个" << std::endl;     
        }
    }
    return true;
}
  • vscode 下的搜索，ctrl+f
1. 构建正排索引（BuildForwardIndex）
  • 在编写构建正排索引的代码前，我们要知道，在构建索引的函数中，我们是按行读取了每个html文件的（每个文件都是这种格式：title\3content\3url...）构建正排索引，就是将DocInfo结构体内的字段进行填充，
  • 这里我们就需要给一个字符串切分的函数，我们写到util.hpp中，
  • 这里我们又要引入一个新的方法——boost库当中的切分字符串函数split；

代码如下：

class StringUtil
    {
    public:
        //切分字符串
        static void Splist(const std::string &target, std::vector<std::string> *out, const std::string &sep)
        {
            //boost库中的split函数
            boost::split(*out, target, boost::is_any_of(sep), boost::token_compress_on);
        }
};

boost::split(*out, target, boost::is_any_of(sep), boost::token_compress_on);

  • 第一个参数：表示你要将切分的字符串放到哪里
  • 第二个参数：表示你要切分的字符串
  • 第三个参数：表示分割符是什么，不管是多个还是一个
  • 第四个参数：它是默认可以不传，即切分的时候不压缩，不压缩就是保留空格

如：字符串为aaaa\3\3bbbb\3\3cccc\3\3d

  • 如果不传第四个参数 结果为aaaa bbbb cccc d
  • 如果传第四个参数为boost::token_compress_on 结果为aaaabbbbccccd
  • 如果传第四个参数为boost::token_compress_off 结果为aaaa bbbb cccc d

构建正排索引的编写：

//构建正排索引
DocInfo* BuildForwardIndex(const std::string &line)
{
    // 1.解析line，字符串切分
    // 将line中的内容且分为3段：原始为title\3content\3url\3
    // 切分后：title content url
    std::vector<std::string> results;
    std::string sep = "\3"; //行内分隔符
    ns_util::StringUtil::Splist(line, &results, sep);//字符串切分                                                                                             
    if(results.size() != 3)                                             
    {                                                                   
        return nullptr;                                                 
    }                                                                   
                                                                                
    // 2.字符串进行填充到DocInfo                                        
    DocInfo doc;                                                        
    doc.title = results[0];                                             
    doc.content = results[1];                                           
    doc.url = results[2];                                               
    doc.doc_id = forward_index.size(); 
    //先进行保存id，在插入，对应的id就是当前doc在vector中的下标
                                                                                
    // 3.插入到正排索引的vector                                         
    forward_index.push_back(std::move(doc)); //使用move可以减少拷贝带来的效率降低
    return &forward_index.back();                                       
}
2.❗构建倒排索引

原理图：

总的思路：

  • 对 title 和 content 进行分词（使用cppjieba）
  • 在分词的时候，必然会有某些词在 title 和 content 中出现过；我们这里还需要做一个处理，就是对每个词进行词频统计（你可想一下，你在搜索某个关键字的时候，为什么有些文档排在前面，而有些文档排在最后）这主要是词和文档的相关性
  • 自定义相关性：我们有了词和文档的相关性的认识后，就要来自己设计这个相关性；我们把出现在title中的词，其权重更高，在content中，其权重低一些（如：让出现在title中的词的词频x10，出现在content中的词的词频x1，两者相加的结果称之为该词在整个文档中的权重）
  • 根据这个权重，我们就可以对所有文档进行权重排序，进行展示，权重高的排在前面展示，权重低的排在后面展示

我们之前的基本结构代码：

//倒排拉链节点
struct InvertedElem{
    uint64_t doc_id;  //文档的ID
    std::string word; //关键词
    int weight;       //权重
};
 
//倒排拉链
typedef std::vector<InvertedElem> InvertedList;
 
//倒排索引一定是一个关键字和一组(个)InvertedElem对应[关键字和倒排拉链的映射关系]
std::unordered_map<std::string, InvertedList> inverted_index;
 
//文档信息节点
struct DocInfo{
    std::string title;   //文档的标题
    std::string content; //文档对应的去标签之后的内容
    std::string url;     //官网文档url
    uint64_t doc_id;     //文档的ID
};
  1. 需要对 title && content都要先分词 -- 使用jieba分词
  • title: 吃/葡萄/吃葡萄(title_word)
    content：吃/葡萄/不吐/葡萄皮(content_word)
  1. 词频统计 它是包含标题和内容的，我们就需要有一个结构体，来存储每一篇文档中每个词出现在title和content中的次数，伪代码如下：
//词频统计的结点
struct word_cnt
{
    int title_cnt;  //词在标题中出现的次数
    int content_cnt;//词在内容中出现的次数
}
  • 统计这些次数之后
  • 我们还需要将词频和关键词进行关联，文档中的每个词都要对应一个词频结构体，
  • 这样我们通过关键字就能找到其对应的词频结构体，
  • 通过这个结构体就能知道该关键字在文档中的title和content中分别出现了多少次，
  • 下一步就可以进行权重的计算。
  • 这里我们就可以使用数据结构unordered_map来进行存储。

伪代码如下：

//关键字和词频结构体的映射
std::unordered_map<std::string, word_cnt> word_map;
//关键字就能找到其对应的词频结构体
for(auto& word : title_word)
{
    // 一个关键词 对应 标题 中出现的次数
    word_map[word].title_cnt++; //吃（1）/葡萄（1）/吃葡萄（1）
}

//范围for进行遍历，对content中的词进行词频统计
for(auto& word : content_word)
{
    // 一个关键词 对应 内容 中出现的次数
    word_map[word].content_cnt++; //吃（1）/葡萄（1）/不吐（1）/葡萄皮（1）
}
  1. 自定义相关性

知道了在文档中，标题 和 内容 每个词出现的次数，接下来就需要我们自己来设计相关性了，伪代码如下：

//遍历刚才那个unordered_map<std::string, word_cnt> word_map;
for(auto& word : word_map)
{
    struct InvertedElem elem;//定义一个倒排拉链节点，然后填写相应的字段
    elem.doc_id = 123;
    elem.word = word.first;  // word.first-> 关键字
    elem.weight = 10*word.second.title_cnt + word.second.content_cnt ;//权重计算
    // 将关键字 对应的 倒排拉链节点 保存到 对应的倒排拉链这个 数组中
    inverted_index[word.first].push_back(elem);//最后保存到倒排索引的数据结构中
}
 
//倒排索引结构如下： 一个关键字 对应的 倒排拉链（一个或一组倒排节点）
//std::unordered_map<std::string, InvertedList> inverted_index;
 
//倒排索引结构体  -- 一个倒排拉链节点
struct InvertedElem
{
    uint64_t doc_id;   // 文档ID
    std::string word; // 文档相关关键字
    int weight;        // 文档权重
};
 
//倒排拉链
typedef std::vector<InvertedElem> InvertedList;

至此就是倒排索引比较完善的原理介绍和代码思路

3.1 cppjieba分词工具的安装和使用

获取链接：cppjieba 下载链接 里面有详细的教程

  • 我们这里可以使用 git clone，如下
  • git clone https://github.com/yanyiwu/cppjieba

  • 查看 cppjieba 目录，里面包含如下：

这是别人的写好的一个开源项目，我们来测试一下~

要注意头文件的路径，我们先来修改一下头文件的路径，它本身是要使用cppjieba/Jieba.hpp的，我们看一下这个头文件的具体路径：

路径是：cppjieba/include/cppjieba/Jieba.hpp

我们发现

我们可以找到开源项目中的测试文件来进行 test

引入这个头文件，我们不能直接引入，需要使用软连接：

尝试编译后发现

此时，我们还是需要对这个头文件进行软连接，我们通过查找，发现有这么一个路径：

但是里面什么东西都没有，这是我在联系项目中出现的问题，经过我去GitHub查找一番后，发现它在另外一个压缩包里：

下载好如下:

进入它里面，看是否有我们需要的内容

此时我们只需要将它 拷贝到 include/cppjieba/ 下即可

cp -r limonp/include/limonp/ test/cppjieba/include/cppjieba/

我们将路径都完善之后，接下来，我们 选取局部测试代码 编译运行一下

int main(int argc, char** argv) 
{
  cppjieba::Jieba jieba(DICT_PATH, HMM_PATH, USER_DICT_PATH, IDF_PATH, STOP_WORD_PATH);  
    vector<string> words;  // 接收切分的词
    string s;
    s = "小明硕士毕业于中国科学院计算所";
    cout << "原句：" << s << endl;
    jieba.CutForSearch(s, words);
    cout << "分词后：";
    for (auto& word : words)
    {
        cout << word << " | ";
    }
    cout << endl;
}

熟悉完上面的操作后，就可以在我们的项目中引入头文件，来使用cppjieba分词工具啦~

3.2 引入cppjieba到项目中

将软链接建立好之后，我们在util.hpp中编写一个jieba分词的类，主要是为了方便后期其他地方需要使用的时候，可以直接调用。

首先我们先看一下之前的测试代码： 可以发现分词用到的 词库和函数

我们在util.hpp中创建一个 JiebaUtil的分词工具类，建立软连接

util.hpp代码如下：

#pragma once
#include <iostream>
#include <string>
#include <fstream>
#include <vector>

#include <boost/algorithm/string.hpp>
#include "cppjieba/Jieba.hpp" 

 
namespace ns_util
{
    class FileUtil
    {                                                                                                                                                                                                                                                                                                                                                                        
    public:
        //输入文件名，将文件内容读取到out中
        static bool ReadFile(const std::string &file_path, std::string *out)
        {
            // 读取 file_path（一个.html文件） 中的内容  -- 打开文件
            std::ifstream in(file_path, std::ios::in);
            //文件打开失败检查
            if(!in.is_open())
            {
                std::cerr << "open file " << file_path << " error" << std::endl;
                return false;
            }
            //读取文件内容
            std::string line;
            //while(bool),getline的返回值istream会重载操作符bool，读到文件尾eofset被设置并返回false
            //如何理解getline读取到文件结束呢？？getline的返回值是一个&，while(bool), 本质是因为重载了强制类型转化
            while(std::getline(in, line)) // 每循环一次，读取的是文件的一行内容
            {
                *out += line;    // 将文件内容保存在 *out 里面
            }
            in.close(); // 关掉文件
            return true;
        }
    };

   class StringUtil
    {
    public:
        //切分字符串
        static void Splist(const std::string &target, std::vector<std::string> *out, const std::string &sep)
        {
            //boost库中的split函数
            boost::split(*out, target, boost::is_any_of(sep), boost::token_compress_on);
            }
    };
 //下面这5个是分词时所需要的词库路径
    const char* const DICT_PATH = "./dict/jieba.dict.utf8";    
    const char* const HMM_PATH = "./dict/hmm_model.utf8";    
    const char* const USER_DICT_PATH = "./dict/user.dict.utf8";    
    const char* const IDF_PATH = "./dict/idf.utf8";    
    const char* const STOP_WORD_PATH = "./dict/stop_words.utf8";  
 
 
    class JiebaUtil    
    {    
    private:    
        static cppjieba::Jieba jieba; //定义静态的成员变量（需要在类外初始化）   
    public:    
        static void CutString(const std::string &src, std::vector<std::string> *out)    
        {   
            //调用CutForSearch函数，第一个参数就是你要对谁进行分词，第二个参数就是分词后的结果存放到哪里
            jieba.CutForSearch(src, *out);    
        }     
    };
 
    //类外初始化，就是将上面的路径传进去，具体和它的构造函数是相关的，具体可以去看一下源代码
    cppjieba::Jieba JiebaUtil::jieba(DICT_PATH, HMM_PATH, USER_DICT_PATH, IDF_PATH, STOP_WORD_PATH);
}

倒排索引代码

构建倒排索引相对复杂一些，只要将上面倒排索引的原理和伪代码的思路；理解到位后，下面的代码就比较简单了。

//构建倒排索引
bool BuildInvertedIndex(const DocInfo &doc)    
{   
    //词频统计结构体 
    struct word_cnt    
    {    
        int title_cnt;    
        int content_cnt;    
        word_cnt():title_cnt(0), content_cnt(0){}    
    };    
    std::unordered_map<std::string, word_cnt> word_map; //用来暂存词频的映射表    
    
    //对标题进行分词    
    std::vector<std::string> title_words;    
    ns_util::JiebaUtil::CutString(doc.title, &title_words);      
    
    //对标题进行词频统计       
    for(auto s : title_words)     
    {    
        boost::to_lower(s); // 将我们的分词进行统一转化成为小写的    
        word_map[s].title_cnt++;//如果存在就获取，不存在就新建    
    }    
    
    //对文档内容进行分词    
    std::vector<std::string> content_words;    
    ns_util::JiebaUtil::CutString(doc.content, &content_words);    
      
    
    //对文档内容进行词频统计       
    for(auto s : content_words)      
    {    
        boost::to_lower(s); // 将我们的分词进行统一转化成为小写的    
        word_map[s].content_cnt++;    
    }    
    
#define X 10    
#define Y 1  
    //最终构建倒排  
    for(auto &word_pair : word_map)    
    {    
        InvertedElem item;    
        item.doc_id = doc.doc_id; //倒排索引的id即文档id   
        item.word = word_pair.first;    
        item.weight = X * word_pair.second.title_cnt + Y * word_pair.second.content_cnt;    
        InvertedList& inverted_list = inverted_index[word_pair.first];    
        inverted_list.push_back(std::move(item));    
     }    
     return true;    
}

下篇文章将继续对项目进行讲解~

补充：

写项目突然想到一个有意思的点~

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

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

相关文章

虚拟机安装麒麟v10、配置网络、安装docker

虚拟机安装麒麟v10、配置网络、安装docker

一、虚拟机安装麒麟v10 1、下载iso&#xff08;https://www.kylinos.cn/support/trial.html&#xff09; 2、虚拟机安装 3、选择 4、设置开机自动连接网络 参考地址&#xff1a;https://www.cnblogs.com/goding/p/18283912 安装好后发现屏幕分辨率毕竟低&#xff0c;点设置分…
阅读更多...
龙蟠科技业绩压力显著：资产负债率持续攀升，产能利用率也不乐观

龙蟠科技业绩压力显著：资产负债率持续攀升，产能利用率也不乐观

《港湾商业观察》施子夫 黄懿 去年十月至今两度递表后&#xff0c;10月17日&#xff0c;江苏龙蟠科技股份有限公司(以下简称&#xff0c;龙蟠科技&#xff1b;603906.SH&#xff0c;02465.HK)通过港交所主板上市聆讯。 很快&#xff0c;龙蟠科技发布公告称&#xff0c;公司全…
阅读更多...
缓存池（对象池）使用

缓存池（对象池）使用

框架介绍 对象池的实现是为了优化内存管理和提升性能&#xff0c;尤其是在创建和销毁大量对象时&#xff0c;通过复用已经创建的对象来减少垃圾回收的负担。 实现概述 开放公共方法 记忆已更新 这个对象池的实现是为了优化内存管理和提升性能&#xff0c;尤其是在创建和销…
阅读更多...
【Spring】详解SpringMVC，一篇文章带你快速入门

【Spring】详解SpringMVC，一篇文章带你快速入门

目录 一、初始MVC 二、SpringMVC 三、Spring MVC的运用 ⭕RequestMapping ⭕传递参数 1、传递单个参数 2、传递多个参数 3、参数重命名 4、传递数组与集合 5、获取路径参数 6、传递JSON数据 7、上传文件 一、初始MVC MVC&#xff08;Model-View-Controller&#…
阅读更多...
python 深度学习 项目调试 识别数学公式 LaTeX-OCR

python 深度学习 项目调试 识别数学公式 LaTeX-OCR

起因&#xff0c; 目的: 提取图片中的数学公式。 其实这个项目&#xff0c;我很久之前就做过。 而且,我还录了一个视频: https://www.bilibili.com/video/BV1nD421p7jS/?vd_source198e876d811b3ccea94908fd163c223f 简介: 项目来源: https://github.com/lukas-blecher/La…
阅读更多...
MongoDB简单学习

MongoDB简单学习

MongoDB 一、基本使用 1.1业务应用场景 传统的关系型数据库&#xff08;如Mysql&#xff09;&#xff0c;在数据库操作的“三高”需求以及对应web2.0的网站需求面前&#xff0c;显得力不从心 三高&#xff1a; High performance - 对数据库高并发读写的要求Huge Storage -…
阅读更多...
STM32--基于STM32F103C8T6的OV7670摄像头显示

STM32--基于STM32F103C8T6的OV7670摄像头显示

本文介绍基于STM32F103C8T6实现的OV7670摄像头显示设计&#xff08;完整资源及代码见文末链接&#xff09; 一、简介 本文实现的功能&#xff1a;基于STM32F103C8T6实现的OV7670摄像头模组实时在2.2寸TFT彩屏上显示出来 所需硬件&#xff1a; STM32F103C8T6最小系统板、OV76…
阅读更多...
[C++ 11] 列表初始化：轻量级对象initializer_list

[C++ 11] 列表初始化：轻量级对象initializer_list

C发展历史 C11是C语言的第二个主要版本&#xff0c;也是自C98以来最重要的一次更新。它引入了大量的新特性&#xff0c;标准化了已有的实践&#xff0c;并极大地改进了C程序员可用的抽象能力。在2011年8月12日被ISO正式采纳之前&#xff0c;人们一直使用“C0x”这个名称&#…
阅读更多...
10-1.idea中的项目结构，辅助快捷键，模块的操作

10-1.idea中的项目结构，辅助快捷键，模块的操作

idea中的项目结构和辅助快捷键 IDEA中项目结构 首先是创建项目&#xff0c;新建的项目中有子项目&#xff0c;我们可以创建模块 然后在模块中我们可以创建包&#xff0c;在包中的SRC中写我们的源代码&#xff0c;也就是类。 VScode写Java项目 如何你电脑比较卡的话&#…
阅读更多...
基于GPT的智能客服落地实践

基于GPT的智能客服落地实践

&#x1f4cd;前言 在日常生活中&#xff0c;「客服」这个角色几乎贯穿着我们生活的方方面面。比如&#xff0c;淘宝买东西时&#xff0c;需要客服帮你解答疑惑。快递丢失时&#xff0c;需要客服帮忙找回。报名参加培训课程时&#xff0c;需要客服帮忙解答更适合的课程…… 基…
阅读更多...
RTE 2024 隐藏攻略

RTE 2024 隐藏攻略

大家好&#xff01;想必今年 RTE 大会议程大家都了解得差不多了&#xff0c;这将是一场实时互动和多模态 AI builder 的年度大聚会。 大会开始前&#xff0c;我们邀请了参与大会策划的 RTE 开发者社区和超音速计划的成员们&#xff0c;分享了不同活动的亮点和隐藏攻略。 请收…
阅读更多...
InnoDB 存储引擎＜一＞InnoDB简介与MySQL存储架构及相关数据结构

InnoDB 存储引擎＜一＞InnoDB简介与MySQL存储架构及相关数据结构

目录 回顾MySQL架构 InnoDB简介 ​MySQL存储结构 回顾MySQL架构 对MySQL架构图的总结: MySQL服务器是以网络服务的方式对外提供数据库服务的&#xff0c;我们使用的应用程序以及客户端统称为外部程序。 外部程序通过发送网络请求的方式来连接MySQL服务器&#xff0c;这时首先每…
阅读更多...
SpringBoot启动报错java.nio.charset.MalformedInputException: Input length =1

SpringBoot启动报错java.nio.charset.MalformedInputException: Input length =1

启动springboot项目时&#xff0c;出现了以下报错&#xff1a; defaultPattern_IS_UNDEFINEDdefaultPattern_IS_UNDEFINEDdefaultPattern_IS_UNDEFINEDjava.lang.IllegalStateException: Failed to load property source from location classpath:/application-local.yamlat o…
阅读更多...
使用pytest单元测试框架执行单元测试

使用pytest单元测试框架执行单元测试

Pytest 是一个功能强大且灵活的 Python 单元测试框架&#xff0c;它使编写、组织和运行测试变得更加简单。以下是 Pytest 的一些主要特点和优点&#xff1a; 简单易用&#xff1a;Pytest 提供了简洁而直观的语法&#xff0c;使编写测试用例变得非常容易。它支持使用 assert 语…
阅读更多...
《皮革制作与环保科技》是什么级别的期刊？是正规期刊吗？能评职称吗？

《皮革制作与环保科技》是什么级别的期刊？是正规期刊吗？能评职称吗？

​问题解答 问&#xff1a;《皮革制作与环保科技》是不是核心期刊&#xff1f; 答&#xff1a;不是&#xff0c;是知网收录的正规学术期刊。 问&#xff1a;《皮革制作与环保科技》级别&#xff1f; 答&#xff1a;国家级。主管单位&#xff1a;中国轻工业联合会 …
阅读更多...
软考：CORBA架构

软考：CORBA架构

CORBA过时了吗 CORBA指南 个人小结&#xff1a; IPC&#xff0c;进程间通信&#xff0c;Socket应用在不同机器之间的通信 RPC是一种技术思想而非一种规范 但站在八九十年代的当口&#xff0c;简单来说&#xff0c;就是我在本地调用了一个函数&#xff0c;或者对象的方法&…
阅读更多...
uvm_info、uvm_warning，uvm_error、uvm_fatal

uvm_info、uvm_warning，uvm_error、uvm_fatal

1、warning/error/fatal调试语句 调试语句除了uvm_info&#xff0c;UVM内部根据问题的严重性&#xff08;severity&#xff09;由低到高&#xff0c;还引入了uvm_warning/uvm_error/uvm_fatal。 它们也是UVM预定义的宏&#xff0c;格式跟umv_info很像&#xff0c;只是不再需要…
阅读更多...
int main(int argc,char* argv[])详解

int main(int argc,char* argv[])详解

#include <stdio.h> //argc 是指命令行输入参数的个数; //argv[]存储了所有的命令行参数, //arg[0]通常指向程序中的可执行文件的文件名。在有些版本的编译器中还包括程序文件所在的路径。 //如:"d:\Production\Software\VC_2005_Test\Win32控制台应用程序\Vc_T…
阅读更多...
Kafka-Windows搭建全流程（环境，安装包，编译，消费案例，远程连接，服务自启，可视化工具）

Kafka-Windows搭建全流程（环境，安装包，编译，消费案例，远程连接，服务自启，可视化工具）

目录 一. Kafka安装包获取 1. 官网地址 2. 百度网盘链接 二. 环境要求 1. Java 运行环境 (1) 对 java 环境变量进行配置 (2) 下载完毕之后进行解压 三. 启动Zookeeper 四. 启动Kafka (1) 修改Conf下的server.properties文件&#xff0c;修改kafka的日志文件路径 (2)…
阅读更多...
软件分享丨Marktext 编辑器

软件分享丨Marktext 编辑器

Marktext是一款开源免费的Markdown编辑器&#xff0c;它具有简洁优雅的界面设计和强大的功能&#xff0c;支持多种Markdown语法&#xff0c;包括表格、流程图、甘特图、数学公式、代码高亮等。Marktext还支持导出HTML和PDF格式的文档&#xff0c;非常适合需要编写Markdown文档的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023