Rust 通过所有权系统管理内存，编译器在编译时会根据一系列规则进行检查，如果违反了这些规则，程序不能通过编译。在运行时，所有权系统的任何功能都不会减缓程序的运行

所有权规则

1. Rust 中的每一个值都有一个所有者
2. 值在任意时刻有且仅有一个所有者
3. 当所有者（变量）离开作用域，这个值将被丢弃

从 hello world 开始

创建一个 main.rs 文件，写入以下内容

1
2
3

fn main() {
    println!("Hello, world!");
}

• 使用以下命令进行编译运行

1
2
3

rustc main.rs
./main
Hello, world!

• 也可使用Cargo工具进行构建

1
2
3
4
5
6

cargo new  ${project_name}
cd ${project_name}
#这将会创建如下结构
${project_name}
	src/main.rs
	Cargo.toml

基础语法

关键字

PROJECT关键字

PROJECT(name)指定工程名称， 默认支持所有语言

PROJECT(name CXX)指定工程名称， 支持C++

会隐式定义两个变量

• ${name}_BINARY_DIR
• ${name}_SOURCE_DIR

修改工程名时会将这两个变量修改，可通过预定义两个变量PROJECT_BINARY_DIR以及PROJECT_SOURCE_DIR解决该问题

SET关键字

设定值，SET(SRC_LIST main.cpp a.cpp b.cpp)，即设定了SEC_LIST的值

MESSAGE关键字

输出自定义的信息，主要有三种

• SEND_ERROR，产生错误生成过程被跳过
• STAUS，显示普通的消息
• FATAL_ERROR，终止cmake过程

图的构成

顶点集合+边的集合：G = (V, E)，顶点集合V = {x | x属于某个数据对象及}是有穷非空集合

• E = {(x, y) | x, y属于V}或者E = {<x, y> | x, y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫边集合

• (x, y)表示x到y的一条双向通道，即(x, y)是无方向的，Path(x, y)表示从x到y的一条单向通路，即Path(x, y)是有方向的

顶点和边：图中节点成为顶点，第i个顶点记作vi， 两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边，图中第k条边记作ek，ek = (vi, vj)或ek = <vi, vj>

• 在有向图中，顶点对<x, y>是有序的，顶点对<x, y>称为顶点x到顶点y的一条边(弧)，<x, y>和<y ,x>是两条不同的边，如G3、G4
• 在无向图中，顶点对(x, y)是无序的，顶点对(x,y) 称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x, y)和(y，x)是同一条边，如G1、G2
• 注意：无向边(x, y)等于有向边<x, y>和<y, x>

总体思路

通过httplib库函数中的Post和Get方法来处理以下四种请求

• 注册 ：处理浏览器传来的数据，并调用数据库函数增加列
• 登录 ：处理浏览器传来的数据，在数据库中进行查询，登陆成功则生成sessionID用以后续使用
• 数据页面：处理浏览器传来的数据，使用sessionID查询当前登录的用户，在数据库中查询该用户信息并返回
• 数据提交：处理浏览器传来的数据，根据头部的sessionID查询登陆用户，切割正文提交的信息，插入数据库

前言

为了更方便的使用Boost库，于是想到实现一个基于Boost离线文档的搜索引擎，对离线的HTML文件进行分析，、并对查询词进行分词（借用第三方库），然后根据相关性（简陋的相关性公式）进行排序，最终将查询结果用JSON的数据格式进行组织打包，最终通过对外的http服务将查询结果返回

只能在堆上创建对象的类

1. 构造函数私有
2. 提供一个静态的堆上创建对象的方法
3. 防止拷贝（拷贝构造声明为私有且不实现，或者声明为delete）

列表初始化

C++11：支持内置类型与自定义类型的列表初始化，其中自定义类型不是天然支持列表初始化，需要显示定义参数类型为initiaizer_list的构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class A
{
public:
  A (int a, int b)
    : _a(a)
    , _b(b)
  { }
private:
  int _a;
  int _b;
};


int arr[] = {1, 2, 3, 4, 5};

int a = 1;
int b = { 1 };
int c{ 1 };
float d = { 1.2 };

vector<int> arr1{1, 2, 3, 4, 5};
vector<int> arr2 = {1, 2, 3};

pair<int, int> p = {1, 1};
map<int, int> m = { {1, 1}, {2, 2}, {3, 3} };

A a = {1, 2};
A a(1, 2);

无序关联容器

unordered_map

基本使用与map相同，迭代器无反向迭代器，无序map，其体现在遍历时无序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <unordered_map>

void testUMap()
{
	unordered_map<int, int> um;
	map<int, int> m;

	um.insert(make_pair(1, 1));
	um.insert(make_pair(10, 1));
	um.insert(make_pair(2, 1));
	um.insert(make_pair(15, 1));
	um.insert(make_pair(8, 1));

	um[100] = 100;//插入
	um[15] = 15;//修改

	um.at(2) = 2;//at无法插入，key不存在直接抛异常

	//遍历无序
	unordered_map<int, int>::iterator uit = um.begin();
	while (uit != um.end())
	{
		cout << uit->first << "-->" << uit->second << endl;
		uit++;
	}
  
  uit = um.find(100);//find找到返回指定位置迭代器，找不到则返回end迭代器
	cout << um.count(100) << endl;//count返回元素个数，1或0
	cout << uit->first << "-->" << uit->second << endl;
	uit = um.find(20);
	cout << um.count(20) << endl;
	cout << (uit == um.end()) << endl;
}

改造红黑树

关联式容器存储的是K， V键值对，故在改造红黑树时，K为key类型，对于V来说，如果是set，则其为K类型，如果是map则为

pair<K, V>，类型，除此之外，还需要一个仿函数类KeyOfValue来兼容map与set的大小比较，其迭代器也需要封装指针为一个类，迭代器的自加自减相当于红黑树的中序遍历