张欢的博客

Rust入门

Fri, 17 Jan 2025 00:00:00 +0000

1.安装

官网 https://www.rust-lang.org/learn/get-started

2.猜数字游戏

use std::io;
use rand::{thread_rng, Rng};
use std::cmp::Ordering;

fn main() {
    let secret_num = thread_rng().gen_range(1, 101);
    loop {
        println!("请猜一个数：");
    
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("无法读取");
        println!("您猜的数字是：{}",guess);

        let guess:u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue  
        };

        match guess.cmp(&secret_num){
            Ordering::Less => println!("Too small"),
            Ordering::Equal => {
                println!("you win!");
                break;
            },
            Ordering::Greater => println!("Too big"),
        }
    }
    
}

3.编程概念

3.1 变量可变性

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6;//报错，变量如果要修改需要用mut修饰
    println!("The value of x is: {x}");
}

//常量声明
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

//可以重复声明变量，后面的声明的变量覆盖前面的
let spaces = "   ";
let spaces = spaces.len();

3.2数据类型

3.2.1 整数

Rust 有四种主要标量类型：整数、浮点数、布尔值和字符。

长度	签名	未签名
8位	`i8`	`u8`
16位	`i16`	`u16`
32位	`i32`	`u32`
64位	`i64`	`u64`
128位	`i128`	`u128`

数字字面量	例子
十进制	`98_222`
十六进制	`0xff`
八进制	`0o77`
二进制	`0b1111_0000`
字节	`b'A'`

3.2.2 浮点数

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

3.2.3 布尔类型

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

3.2.4 字符类型

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '😻';
}

3.2.5 元组

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);
	//取值
    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

3.2.6 数组

当知道元素数量不需要更改时，数组会更有用。例如，如果您在程序中使用月份名称，您可能会使用数组而不是向量，因为您知道它始终包含 12 个元素：

let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

可以使用方括号、每个元素的类型、分号以及数组中元素的数量来编写数组的类型，如下所示：

let a: [i32; 5] = [1, 2, 3, 4, 5];

这里，i32是每个元素的类型。分号后面的数字5 表示数组包含五个元素。

还可以通过指定初始值、后跟分号、然后在方括号中指定数组的长度来初始化数组，使其每个元素包含相同的值，如下所示：

let a = [3; 5];

指定的数组a将包含5所有元素，这些元素将全部设置为 3最初的值。这与写作相同let a = [3, 3, 3, 3, 3];，但方式更简洁。

fn main() {
    let a = [1, 2, 3, 4, 5];
	//访问数组中的值
    let first = a[0];
    let second = a[1];
}

3.3函数

3.3.1 函数的参数

fn main() {
    another_function(5);
}

//必须声明参数的类型
fn another_function(x: i32) {
    println!("The value of x is: {x}");
}

3.3.2 有返回值参数

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {x}");
}

fn plus_one(x: i32) -> i32 {
    //默认返回值不用写分号，如果要提前返回则用return 返回值;
    x + 1
}

3.4流程控制

3.4.1 if和else

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

fn main() {
    let condition = true;
	//条件赋值
    let number = if condition { 5 } else { "six" };

    println!("The value of number is: {number}");
}

3.4.2 loop循环

fn main() {
    let mut counter = 0;
	//带返回值
    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

3.4.3 while循环

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

3.4.4 for循环

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

4.所有权

4.1 所有权规则

Rust 中的每个值都有一个所有者。
一次只能有一位所有者。
当所有者超出范围时，该值将被删除。

fn main() {
    let mut s = String::from("hello");

    s.push_str(", world!"); // push_str() appends a literal to a String

    //将s变量的值更换所有者为s1，更换后s将被销毁
    let s1 = s;
    println!("{s1}"); 
    
    {
        //将s1的值克隆一份给s2
        let s2 = s1.clone();
        println!("{s2}"); 
    }
    println!("{s1}"); 
}

4.2 变量不移动类型

let x = 5;
let y = x;

println!("x = {x}, y = {y}");

没有调用 clone，但x仍然有效并且没有移入y，该类型具有自动copy的特征

具有copy特征的类型

所有整数类型，例如u32.
布尔类型，bool具有值true和false。
所有浮点类型，例如f64.
字符类型，char.
元组，如果它们仅包含也实现Copy.例如， (i32, i32)实现Copy，但(i32, String)不实现。

4.3 引用

4.3.1 不可变引用

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{s1}' is {len}.");
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

4.3.2 可变引用

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

同一域内不可出现多个可变引用，但可出现多个不可变引用

4.3.3 悬空引用

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");
	//当代码dangle完成时，s将会被释放。但我们试图返回对它的引用。这意味着该引用将指向无效的String，故此处会报错
    &s
}

解决办法如下

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

4.4 切片

4.4.1 字符串切片

//切片参数为&str
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole
    let word = first_word(&my_string[0..6]);
    println!("{}",word);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s
    let word = first_word(&my_string);
    println!("{}",word);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or whole
    let word = first_word(&my_string_literal[0..6]);
    println!("{}",word);
    let word = first_word(&my_string_literal[..]);
    println!("{}",word);
    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
    println!("{}",word);
}

4.4.2 其他切片

fn main() {
    let a = [1, 2, 3, 4, 5];

    let slice = &a[1..3];

    assert_eq!(slice, &[2, 3]);
}

5.结构体

5.1 定义

#[derive(Debug)]
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    //实例化
    let mut user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };

    user1.email = String::from("anotheremail@example.com");

    println!("{:#?}",user1);
}

//元组方式定义
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

5.2 方法语法

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );

    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

6.枚举

6.1 定义

#[derive(Debug)]
enum IpAddr {
    V4(String),
    V6(String),
}

fn main() {

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));

    println!("{:#?}",home)
}

6.2 方法

#[derive(Debug)]
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

impl Message {
    fn call(&self) {
        // method body would be defined here
        println!("{:?}", self);
    }
}

fn main() {
    let m = Message::Write(String::from("hello"));
    m.call();
}

6.3 枚举Option

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);
    //let y: Option<i8> = None;

    if y.is_none() {
        println!("y is None");
        return;
    }
    let sum = x + y.unwrap();
    println!("Sum: {}", sum);
}

6.4 match

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        //None => None,
        Some(i) => Some(i + 1),
        //需要涵盖所有可能性
        _=> None
    }
}

fn main() {
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

6.5 if let

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn main() {
    let mut count = 0;
    let coin= Coin::Quarter;
    if let Coin::Quarter = coin {
        println!("this is quarter!");
    } else {
        count += 1;
    }
}

fn main() {
    let config_max = Some(3);
    if let Some(max) = config_max {
        println!("The maximum is configured to be {max}");
    }
}

7.自定义模块

创建模块

cargo new restaurant --lib

执行命令后会生成

└─restaurant
    │  Cargo.toml
    │
    └─src
            lib.rs

在lib.rs中写入

pub mod front_of_house {
    //仅仅pub修饰的才可被外部调用
    pub mod hosting {
        pub fn add_to_waitlist() {
            println!("excute add_to_waitlist!");
        }

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}

在最外层main方法中调用

//引入
include!("restaurant/src/lib.rs");

use front_of_house::hosting;

fn main() {
    // Relative path
    hosting::add_to_waitlist();
}

模块内容分文件存放

模块定义时，如果模块名后边是“；”，而不是代码块：

Rust会从与模块同名的文件中加载内容
模块树的结构不会变化

随着模块逐渐变大，该技术让你可以把模块的内容移动到其它文件中

8.集合

8.1 vector

fn main() {
    //使用Vec<T>创建一个新的空Vec<T>实例
    let v: Vec<i32> = Vec::new();
    //使用vec!宏创建一个包含特定值的Vec<T>实例
    let v = vec![1, 2, 3];

    //更新Vec<T>的值
    let mut v = Vec::new();
    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);

}

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    //这种方式会导致panic
    let does_not_exist = &v[100];
    //这种方式会返回None
    let does_not_exist = v.get(100);

}

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    let first = &v[0];

    //会报错，因为v.push(6)会导致内存重新分配，first指向的内存已经被释放
    v.push(6);

    println!("The first element is: {first}");

}

fn main() {
    let mut v = vec![100, 32, 57];
    //遍历
    for i in &mut v {
        *i += 50;
    }

}

fn main() {
    enum SpreadsheetCell {
        Int(i32),
        Float(f64),
        Text(String),
    }
    //使用枚举来储存不同类型的数据
    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Text(String::from("blue")),
        SpreadsheetCell::Float(10.12),
    ];

}

8.2 HashMap

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();

    // 插入键值对
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    let team_name = String::from("Blue");
    // 通过get方法获取值，如果存在则返回Some，否则返回None
    let score = scores.get(&team_name).copied().unwrap_or(0);

    // 通过for循环遍历HashMap
    for (key, value) in &scores {
        println!("{key}: {value}");
    }

    //更新值
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Blue"), 25);

    // 如果键对应的值不存在，则插入，否则更新
    scores.entry(String::from("Blue")).or_insert(50);
    
}

use std::collections::HashMap;

fn main() {
    //统计字符串中单词出现的次数

    let text = "hello world wonderful world";

    let mut map = HashMap::new();

    for word in text.split_whitespace() {
        let count = map.entry(word).or_insert(0);
        *count += 1;
    }

    println!("{map:?}");
}

9.错误处理

9.1 立即终止配置

Cargo.toml文件中添加

[profile.release]
panic = 'abort'

9.2 回溯环境变量

RUST_BACKTRACE=1 cargo run

设置RUST_BACKTRACE环境变量来获取导致错误的确切原因的回溯。回溯是为达到这一点而调用的所有函数的列表

9.3 match匹配Result

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {e:?}"),
            },
            other_error => {
                panic!("Problem opening the file: {other_error:?}");
            }
        },
    };
}

优化后

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error| {
                panic!("Problem creating the file: {error:?}");
            })
        } else {
            panic!("Problem opening the file: {error:?}");
        }
    });
}

9.4 unwrap和expect

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap();
}

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")
        .expect("hello.txt should be included in this project");
}

9.5 函数中错误传播

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    //使用？返回错误
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}

10.泛型、特征和生命周期

10.1 泛型

10.1.1 函数定义泛型

//PartialOrd is a trait that allows comparison between values of the same type.
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {result}");
}

10.1.2 结构体中定义泛型

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

10.1.3 枚举中定义泛型

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

10.2 特征

在lib.rs中写入

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

// Implementing the Summary trait on the NewsArticle struct
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

// Implementing the Summary trait on the Tweet struct
impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

在main.rs中调用

use hello::{Summary, Tweet};


fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        retweet: false,
    };

    println!("1 new tweet: {}", tweet.summarize());
}

作为参数使用

use std::fmt::{Display, Debug};

fn some_function<T, U>(t: &T, u: &U) -> i32
//use the where keyword to specify that both T must implement Display and Clone trait and U must implement Clone and Debug trait
where
    T: Display + Clone,
    U: Clone + Debug,
{
    1
}

10.3 生命周期

生命周期是我们已经使用过的另一种泛型。生命周期不是确保类型具有我们想要的行为，而是确保引用在我们需要的时间内有效。

//'a is a lifetime annotation
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

// 'static is a lifetime annotation, which means that this reference can live for the entire duration of the program.
let s: &'static str = "I have a static lifetime.";

11.自动化测试

$ cargo new adder --lib
     Created library `adder` project
$ cd adder

在src/lib.rs中会自动生成

pub fn add(left: usize, right: usize) -> usize {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

执行cargo test命令可进行测试

12.命令行程序案例

需求：输入命令 xx.exe query filename从文件中查找包含query的文本，并打印出来

lib.rs

use std::env;

pub struct Args {
    filename: String,
    query: String,
    case_sensitive: bool
}

impl Args {
    pub fn new(args: &[String]) -> Result<Args, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }
        let filename = args[2].clone();
        let query = args[1].clone();
        //获取环境变量
        let case_sensitive = env::var("CASE_SENSITIVE").is_ok();
        Ok(Args { filename, query , case_sensitive: case_sensitive})
    }
    
}

pub fn run(config: Args) -> Result<(), std::io::Error> {
    let contents = std::fs::read_to_string(config.filename)?;
    if config.case_sensitive {
        search(&config.query, &contents);
    } else {
        search_case_insensitive(&config.query, &contents);
    }
    Ok(())
}

pub fn search(query: &str, contents: &str) {
    //filter returns an iterator
    let result: Vec<String> = contents.lines().filter(|line| line.contains(query)).map(|s| s.to_string()).collect();
    println!("{:?}", result);
}

pub fn search_case_insensitive(query: &str, contents: &str) {
    let query = query.to_lowercase();
    let result: Vec<String> = contents.lines().filter(|line| line.to_lowercase().contains(&query)).map(|s| s.to_string()).collect();
    println!("{:?}", result);
}

main.rs

use std::env;
use hello::{run, Args};

fn main() {
    let args:Vec<String> = env::args().collect();    
    let args = Args::new(&args).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {}", err);
        std::process::exit(1);
    });
    if let Err(e) = run(args){
        eprintln!("Application error: {}", e);
        std::process::exit(1);
    };

}

13.闭包

13.1 定义闭包

fn main() {
    let mut list = vec![1, 2, 3];
    println!("Before defining closure: {list:?}");

    //相当于定义一个函数
    let mut borrows_mutably = || list.push(7);

    //执行
    borrows_mutably();
    println!("After calling closure: {list:?}");
}

13.2 转让所有权给闭包

use std::thread;

fn main() {
    let list = vec![1, 2, 3];
    println!("Before defining closure: {list:?}");

    //move关键字表示将list的所有权转移给闭包
    thread::spawn(move || println!("From thread: {list:?}"))
        .join()
        .unwrap();
}

13.3 排序

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let mut list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];

    let mut num_sort_operations = 0;
    //sort_by_key is a method of the Iterator trait
    list.sort_by_key(|r| {
        num_sort_operations += 1;
        r.width
    });
    println!("{list:#?}, sorted in {num_sort_operations} operations");
}

13.4 迭代器

fn main() {
    let v1: Vec<i32> = vec![1, 2, 3];

    //map returns an iterator
    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();

    assert_eq!(v2, vec![2, 3, 4]);
    println!("{:?}", v2);
}

14.智能指针

14.1 使用`Box`在堆上存储数据

fn main() {
    let b = Box::new(5);
    println!("b = {b}");
}

14.2 自定义智能指针

struct MyBox<T>(T);

use std::ops::Deref;

impl<T> Deref for MyBox<T> {
    type Target = T;

    // deref 方法返回一个引用，这样 * 运算符就可以使用在 MyBox<T> 值上了
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}
fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);

}

14.3 `drop`使用

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    // Drop trait is used to run some code when a value goes out of scope
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");
}

14.4 引用计数智能指针

enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    //统计引用计数，结果为1
    println!("count after creating a = {}", Rc::strong_count(&a));
    let b = Cons(3, Rc::clone(&a));
    //统计引用计数，结果为2
    println!("count after creating b = {}", Rc::strong_count(&a));
    {
        let c = Cons(4, Rc::clone(&a));
        //统计引用计数，结果为3
        println!("count after creating c = {}", Rc::strong_count(&a));
    }
    //统计引用计数，结果为2
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}

14.5 内部可变指针

pub trait Messenger {
    fn send(&self, msg: &str);
}

//定义触发器结构体
pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    //设置触发器的值
    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::cell::RefCell;

    //定义消息结构体
    struct MockMessenger {
        //RefCell<T>是一个智能指针，它允许在运行时而不是在编译时检查借用规则
        sent_messages: RefCell<Vec<String>>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: RefCell::new(vec![]),
            }
        }
    }

    impl Messenger for MockMessenger {
        //发送消息
        fn send(&self, message: &str) {
            //RefCell<T>的borrow_mut方法返回RefMut<T>智能指针类型，它记录了运行时借用检查
            self.sent_messages.borrow_mut().push(String::from(message));
            println!("{}", message);
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);
        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
    }
}

14.6 使用弱引用解决循环引用导致的内存泄漏问题

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
struct Node {
    value: i32,
    //parent字段是一个可变弱引用，用于指向父节点
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        //初始化一个Weak指针，指向一个空的Node
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    println!(
        "leaf strong = {}, weak = {}",
        //结果是1和0，因为leaf是唯一的Rc指针，没有其他指针指向它
        Rc::strong_count(&leaf),
        Rc::weak_count(&leaf),
    );

    {
        let branch = Rc::new(Node {
            value: 5,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![Rc::clone(&leaf)]),
        });

        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

        println!(
            "branch strong = {}, weak = {}",
            //结果是1和1，因为branch是唯一的Rc指针，但有一个Weak指针指向它
            Rc::strong_count(&branch),
            Rc::weak_count(&branch),
        );

        println!(
            "leaf strong = {}, weak = {}",
            //结果是2和0，因为leaf有两个Rc指针指向它
            Rc::strong_count(&leaf),
            Rc::weak_count(&leaf),
        );
    }

    //branch离开作用域后，leaf的唯一Rc指针被销毁
    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
    println!(
        "leaf strong = {}, weak = {}",
        //结果是1和0，因为branch离开作用域后，leaf的唯一Rc指针被销毁
        Rc::strong_count(&leaf),
        Rc::weak_count(&leaf),
    );
}

15.并发

15.1 多线程

use std::thread;
use std::time::Duration;

fn main() {
    // Creating a new thread
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {i} from the spawned thread!");
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {i} from the main thread!");
        thread::sleep(Duration::from_millis(1));
    }

    // Wait for the spawned thread to finish
    handle.join().unwrap();
}

15.2 与move一起使用

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    //move closure takes ownership of v
    let handle = thread::spawn(move || {
        println!("Here's a vector: {v:?}");
    });

    handle.join().unwrap();
}

15.3 线程间数据共享

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        //执行send方法后，val的所有权被转移给了接收者，所以这里不能再使用val
        tx.send(val).unwrap();
        //println!("val is {val}");
    });

    let received = rx.recv().unwrap();
    println!("Got: {received}");
}

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

//多个消息发送者
fn main() {
    let (tx, rx) = mpsc::channel();

    // Cloning the transmitter to send it to another thread
    let tx1 = tx.clone();
    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for val in vals {
            tx1.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

    thread::spawn(move || {
        let vals = vec![
            String::from("more"),
            String::from("messages"),
            String::from("for"),
            String::from("you"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

    for received in rx {
        println!("Got: {received}");
    }
}

15.4 线程间状态共享

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    //Arc是一个原子引用计数类型，可以安全的在线程间共享数据，mutex是一个互斥锁，可以保证在同一时刻只有一个线程访问数据
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

16.模式和匹配

16.1 if let

fn main() {
    let favorite_color: Option<&str> = None;
    let is_tuesday = false;
    let age: Result<u8, _> = "34".parse();

    if let Some(color) = favorite_color {
        println!("Using your favorite color, {color}, as the background");
    } else if is_tuesday {
        println!("Tuesday is green day!");
    } else if let Ok(age) = age {
        //这里会执行两次匹配，第一次匹配age是否是Ok，第二次匹配age的值是否大于30，结果是age的值是34，所以会输出Using purple as the background color
        if age > 30 {
            println!("Using purple as the background color");
        } else {
            println!("Using orange as the background color");
        }
    } else {
        println!("Using blue as the background color");
    }
}

16.2 while let

fn main() {
    let mut stack = Vec::new();

    stack.push(1);
    stack.push(2);
    stack.push(3);

    //结果是3 2 1
    while let Some(top) = stack.pop() {
        println!("{top}");
    }
}

16.3 if let

fn main() {
    let v = vec!['a', 'b', 'c'];

    for (index, value) in v.iter().enumerate() {
        println!("{value} is at index {index}");
    }
}

16.4 可反驳性

函数参数、let语句和for循环只能接受无可辩驳的模式，因为当值不匹配时程序无法执行任何有意义的操作。if letand表达式while let接受可反驳和不可反驳的模式，但编译器会警告不可反驳的模式，因为根据定义，它们旨在处理可能的失败：条件的功能在于其能够根据成功或失败执行不同的操作。

16.5 模式语法

16.5.1 配置值

fn main() {
    let x = 1;

    match x {
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        _ => println!("anything"),
    }
}

16.5.2 匹配命名变量

fn main() {
    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        //匹配到Some(y)时，将y的值绑定到y变量
        Some(y) => println!("Matched, y = {y}"),
        _ => println!("Default case, x = {x:?}"),
    }

    println!("at the end: x = {x:?}, y = {y}");

    //Matched, y = 5
    //at the end: x = Some(5), y = 10
}

16.5.3 多种模式

fn main() {
    let x = 1;

    match x {
        1 | 2 => println!("one or two"),
        3 => println!("three"),
        _ => println!("anything"),
    }
}

16.5.4 匹配返回

fn main() {
    let x = 5;

    match x {
        // 1..=5 is a range pattern that matches any number from 1 through 5
        1..=5 => println!("one through five"),
        _ => println!("something else"),
    }
}

16.5.5 解构

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x: a, y: b } = p;
    assert_eq!(0, a);
    assert_eq!(7, b);
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::ChangeColor(0, 160, 255);

    match msg {
        Message::Quit => {
            println!("The Quit variant has no data to destructure.");
        }
        Message::Move { x, y } => {
            println!("Move in the x direction {x} and in the y direction {y}");
        }
        Message::Write(text) => {
            println!("Text message: {text}");
        }
        Message::ChangeColor(r, g, b) => {
            println!("Change the color to red {r}, green {g}, and blue {b}")
        }
    }
}

16.5.6 忽略值

fn foo(_: i32, y: i32) {
    println!("This code only uses the y parameter: {y}");
}

fn main() {
    foo(3, 4);
}

fn main() {
    struct Point {
        x: i32,
        y: i32,
        z: i32,
    }

    let origin = Point { x: 0, y: 0, z: 0 };

    match origin {
        //忽略剩余的字段
        Point { x, .. } => println!("x is {x}"),
    }
}

16.5.7 match额外条件

fn main() {
    let num = Some(4);

    match num {
        //匹配Some中的值，如果是偶数则打印
        Some(x) if x % 2 == 0 => println!("The number {x} is even"),
        Some(x) => println!("The number {x} is odd"),
        None => (),
    }
}

17.高级特性

17.1 原始指针

fn main() {
    let mut num = 5;

    //创建原始指针
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    println!("r1: {:p}", r1);
    println!("r1: {:p}", r2);
}

17.2 不安全代码块中执行不安全方法

fn main() {
    unsafe fn dangerous() {println!("dangerous function");}

    unsafe {
        dangerous();
    }
}

use std::slice;

fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = values.len();
    let ptr = values.as_mut_ptr();

    assert!(mid <= len);

    // The slice::from_raw_parts_mut function is unsafe because it can create aliased mutable references.
    unsafe {
        (
            // slice::from_raw_parts_mut(ptr, mid) is equivalent to &mut values[..mid]
            slice::from_raw_parts_mut(ptr, mid),
            // slice::from_raw_parts_mut(ptr.add(mid), len - mid) is equivalent to &mut values[mid..]
            slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

fn main() {
    let mut v = vec![1, 2, 3, 4, 5, 6];

    let r = &mut v[..];

    let (a, b) = split_at_mut(r,3);

    assert_eq!(a, &mut [1, 2, 3]);
    assert_eq!(b, &mut [4, 5, 6]);
}

17.3 使用extern函数调用外部代码

extern "C" {
    // This is the C function that we want to call
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        // Call the C function
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}

17.4 C语言调用rust

#[no_mangle]
pub extern "C" fn call_from_c() {
    println!("Just called a Rust function from C!");
}

17.5 修改静态变量

static mut COUNTER: u32 = 0;

fn add_to_count(inc: u32) {
    unsafe {
        COUNTER += inc;
    }
}

fn main() {
    add_to_count(3);

    unsafe {
        println!("COUNTER: {COUNTER}");
    }
}

17.6 不安全trait

//定义一个 unsafe trait
unsafe trait Foo {
    fn foo(&self);
}

unsafe impl Foo for i32 {
    //实现foo方法
    fn foo(&self) {
        println!("Hello, world!");
    }
}

fn main() {
    let x = 42;
    //在unsafe块中调用foo方法
    unsafe {
        x.foo();
    }
}

17.7 默认运算符重载

use std::ops::Add;

#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    assert_eq!(
        Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
        Point { x: 3, y: 3 }
    );
}

use std::ops::Add;

struct Millimeters(u32);
struct Meters(u32);

impl Add<Meters> for Millimeters {
    type Output = Millimeters;

    fn add(self, other: Meters) -> Millimeters {
        Millimeters(self.0 + (other.0 * 1000))
    }
}


fn main() {
    let m = Millimeters(10) + Meters(1);
    println!("{}", m.0);
}

17.8 调用同名方法

trait Animal {
    fn baby_name() -> String;
}

struct Dog;

impl Dog {
    fn baby_name() -> String {
        String::from("Spot")
    }
}

impl Animal for Dog {
    fn baby_name() -> String {
        String::from("puppy")
    }
}

fn main() {
    //调用Dog的baby_name方法
    println!("A baby dog is called a {}", Dog::baby_name());
    //调用Animal的baby_name方法
    print!("A baby dog is called a {}", <Dog as Animal>::baby_name());
}

17.9 trait继承

use std::fmt;

//该trait继承了fmt::Display，所以我们可以使用to_string方法
trait OutlinePrint: fmt::Display {
    fn outline_print(&self) {
        let output = self.to_string();
        let len = output.len();
        println!("{}", "*".repeat(len + 4));
        println!("*{}*", " ".repeat(len + 2));
        println!("* {output} *");
        println!("*{}*", " ".repeat(len + 2));
        println!("{}", "*".repeat(len + 4));
    }
}
struct Point {
    x: i32,
    y: i32,
}

impl OutlinePrint for Point {}

//必须实现fmt::Display
impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 1, y: 2 };
    p.outline_print();
}

17.10 包装

//这是一个包装器类型，它包含一个 Vec<String>。我们想要实现 fmt::Display 来打印这个包装器类型，但是 Vec<T> 并不实现 fmt::Display。因此，Vec<T> 也不满足打印的要求。
struct Wrapper(Vec<String>);

impl fmt::Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{}]", self.0.join(", "))
    }
}

fn main() {
    let w = Wrapper(vec![String::from("hello"), String::from("world")]);
    println!("w = {w}");
}

17.11 类型别名

fn main() {
    //类型别名
    type Kilometers = i32;

    let x: i32 = 5;
    let y: Kilometers = 5;

    println!("x + y = {}", x + y);
}

fn main() {
    //定义类型别名来减少重复
    type Thunk = Box<dyn Fn() + Send + 'static>;

    let f: Thunk = Box::new(|| println!("hi"));

    //使用类型别名
    fn takes_long_type(f: Thunk) {
        // --snip--
    }

    fn returns_long_type() -> Thunk {
        Box::new(|| println!("hi"))
    }
}

17.12 永不反回类型

Rust 有一种特殊类型!，在类型理论术语中称为 空类型，因为它没有值。我们更喜欢将其称为never 类型 ，因为当函数永远不会返回时，它代表返回类型。

fn bar() -> ! {
    // --snip--
}

17.13 函数指针

fn add_one(x: i32) -> i32 {
    x + 1
}

//参数是一个函数
fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
    f(arg) + f(arg)
}

fn main() {
    let answer = do_twice(add_one, 5);

    println!("The answer is: {answer}");
}

fn main() {
    let list_of_numbers = vec![1, 2, 3];
    //传入一个闭包
    let list_of_strings: Vec<String> =
        list_of_numbers.iter().map(|i| i.to_string()).collect();
        println!("{:?}", list_of_strings);

    let list_of_numbers = vec![1, 2, 3];
    //传入一个函数
    let list_of_strings: Vec<String> =
    list_of_numbers.iter().map(ToString::to_string).collect();
    println!("{:?}", list_of_strings);
}

17.14 返回特征类型

//返回特征对象，不能直接返回闭包，因为闭包类型是匿名的
fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

fn main() {
    let closure = returns_closure();
    println!("{}", closure(5));
}

18.多线程web服务器案例

18.1 定义线程池和线程

//lib.rs
use std::{
    sync::{mpsc, Arc, Mutex},
    thread,
};

pub struct ThreadPool {
    //定义一个Worker结构体的数组
    workers: Vec<Worker>,
    //定义一个Option类型的mpsc::Sender<Job>，用于发送Job
    sender: Option<mpsc::Sender<Job>>,
}

type Job = Box<dyn FnOnce() + Send + 'static>;

impl ThreadPool {
    /// Create a new ThreadPool.
    ///
    /// The size is the number of threads in the pool.
    ///
    /// # Panics
    ///
    /// The `new` function will panic if the size is zero.
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);

        let (sender, receiver) = mpsc::channel();

        let receiver = Arc::new(Mutex::new(receiver));

        let mut workers = Vec::with_capacity(size);

        //创建size个Worker结构体，并将其放入workers数组中
        for id in 0..size {
            workers.push(Worker::new(id, Arc::clone(&receiver)));
        }

        ThreadPool {
            workers,
            sender: Some(sender),
        }
    }

    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);

        //将job发送给Worker
        self.sender.as_ref().unwrap().send(job).unwrap();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        drop(self.sender.take());

        for worker in &mut self.workers {
            println!("Shutting down worker {}", worker.id);

            if let Some(thread) = worker.thread.take() {
                thread.join().unwrap();
            }
        }
    }
}

struct Worker {
    id: usize,
    thread: Option<thread::JoinHandle<()>>,
}

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {

        //创建一个新的线程，用于接收Job
        let thread = thread::spawn(move || loop {
            let message = receiver.lock().unwrap().recv();

            match message {
                Ok(job) => {
                    println!("Worker {id} got a job; executing.");

                    job();
                }
                Err(_) => {
                    println!("Worker {id} disconnected; shutting down.");
                    break;
                }
            }
        });

        Worker {
            id,
            thread: Some(thread),
        }
    }
}

18.2 创建返回的html

hello.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Hello!</title>
  </head>
  <body>
    <h1>Hello!</h1>
    <p>Hi from Rust</p>
  </body>
</html>

404.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Hello!</title>
  </head>
  <body>
    <h1>Oops!</h1>
    <p>Sorry, I don't know what you're asking for.</p>
  </body>
</html>

18.3 在main方法中实现web服务器

use hello::ThreadPool;
use std::{
    fs,
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
    thread,
    time::Duration,
};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    //创建一个线程池，线程数为4
    let pool = ThreadPool::new(4);

    for stream in listener.incoming().take(2) {
        let stream = stream.unwrap();

        //将stream放入线程池中
        pool.execute(|| {
            handle_connection(stream);
        });
    }

    println!("Shutting down.");
}

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&stream);
    let request_line = buf_reader.lines().next().unwrap().unwrap();

    let (status_line, filename) = match &request_line[..] {
        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
        "GET /sleep HTTP/1.1" => {
            thread::sleep(Duration::from_secs(5));
            ("HTTP/1.1 200 OK", "hello.html")
        }
        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
    };

    let contents = fs::read_to_string(filename).unwrap();
    let length = contents.len();

    let response =
        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");

    stream.write_all(response.as_bytes()).unwrap();
    
}

c++基础

Sat, 22 Jun 2024 00:00:00 +0000

内存分区模型、引用的基本语法、三种参数传递方式、引用的本质、const修饰参数防止被修改、函数默认值、占位参数、函数重载、面向对象、浅拷贝带来问题、友元、运算符重载、继承、文件读写、模板、STL、函数对象、算法

内存分区模型

c++程序在执行中，将内存分为4个区域

代码区：存放函数体的二进制代码，由操作系统进行管理
全局区：存放全局变量和静态变量以及常量
栈区：由编译器自动分配释放，存放函数的函数值，局部变量等
堆区：由程序员分配和释放，若程序员不释放，程序结束后由操作系统回收

注意事项：

不要返回局部变量的地址
堆区数据利用new关键字进行开辟，使用完需要手动释放，用delete关键字
数组类型数据释放内存，delete[]，如果只用delete只会释放数据的第一数据的内存

引用的基本语法

#include <iostream>

using namespace std;

void main() {
	int a = 10;
	int &b = a;
	cout << (int) & a << endl;
	cout << (int) & b << endl;
}

注意：

引用必须初始化
一旦初始化后就不允许进行改变

三种参数传递方式

#include <iostream>

using namespace std;

void swap01(int a,int b) {
	int temp = a;
	a = b;
	b = temp;
}

void swap02(int *a, int *b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}

void swap03(int &a, int &b) {
	int temp = a;
	a = b;
	b = temp;
}

void main() {
	int a;
	int b;

	a = 10;
	b = 20;
	//1.值传递
	//形参不会修饰实参
	swap01(a, b);
	cout << a << endl;
	cout << b << endl;

	a = 10;
	b = 20;
	//2.地址传递
	//形参会修饰实参
	swap02(&a, &b);
	cout << a << endl;
	cout << b << endl;

	a = 10;
	b = 20;
	//3.引用传递
	//形参会修饰实参
	swap03(a, b);
	cout << a << endl;
	cout << b << endl;
}

引用的本质

#include <iostream>

using namespace std;

//发现是引用，转换成 int* const ref = &a;
void func(int& ref) {
	ref = 100; //ref是引用，转换成*ref=100
}
void main() {
	int a = 10;

	//自动转换成int* const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a;
	ref = 20; //ref是引用，转换成*ref=20

	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;

	func(a);
}

const修饰参数防止参数被修改

#include <iostream>

using namespace std;

//引用使用的场景，通常用来修饰形参，防止形参被修改
void showValue(const int& v) {
	//v += 10; 不可以修改
	cout << v << endl;
}
void main() {

	//编译器优化 int temp = 10;const int& ref  = temp;
	const int& ref = 10;

	int a = 10;
	showValue(10);

}

函数默认值

#include <iostream>

using namespace std;

//1.如果某个位置参数有默认值，那么从这个位置往后，必须都要有默认值
//2.如果函数声明有默认值，函数实现的时候就不能有默认参数
int func(int a, int b = 10, int c = 1);
int func(int a, int b, int c) {
	return a + b + c;
}

void main() {

	int res = func(1);
	cout << res << endl;

}

占位参数

#include <iostream>

using namespace std;

//占位参数如果没有默认值，调用时必传
int func(int a, int, int =10) {
	return a;
}

void main() {

	int res = func(1,1);
	cout << res << endl;

}

函数重载

同一个作用域下
函数名相同
参数类型不同，或者个数不同，或者顺序不同
函数的返回值不可以作为函数重载的条件

#include <iostream>

using namespace std;

//引用重载案例
int func(int &a) {//int &a = 10;不合法
	return a;
}

int func(const int& a) {
	return a;
}

void main() {

	int res = func(1);//走第二个函数
	cout << res << endl;

}

面向对象

创建类并实例化

#include <iostream>

using namespace std;

class Circle {
	public:
		int r;
		double getRound() {
			return 2 * 3.14 * r;
		}
};

void main() {

	//实例化
	Circle circle;
	circle.r = 10;
	cout << circle.getRound() << endl;

}

构造方法

分为有参、无参、拷贝，必须是public修饰的方法，方法名和类名一致
调用无参构造方法创建对象时，不要用括号方式，因为编译器会把它当作是一个函数的声明
不要利用拷贝构造函数初始化匿名对象，编译器会认为是 Person(p3) 等价于 Person p3; ``` #include #include

using namespace std;

class Person { private: string name; public: Person() { cout « “无参构造函数执行” « endl; } Person(int a) { cout « “有参构造函数执行” « endl; } Person(const Person& p) { cout « “拷贝构造函数执行” « endl; name = p.name; } ~Person() { cout « “析构函数执行” « endl; } };

void main() { //显式法 Person p1; Person p2 = Person(10);//有参构造 Person p3 = Person(p2);//拷贝构造

Person(10);//匿名对象，执行结束后立马被析构掉

//隐式法
Person p4 = 10;//相当于Person p4 = Person(10)
Person p5 = p4;//相当于Person p5 = Person(p4) } ``` ## 构造函数调用规则 默认情况下，c++编译器至少给一个类加3个函数 1.默认构造函数（无参，函数体为空） 2.默认析构函数（无参，函数体为空） 3.默认拷贝构造函数

构造函数调用规则如下：

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，c++不再提供其他构造函数

浅拷贝带来的问题

对象中存在堆申请空间的代码，其复制的对象和原对象指向堆中同一个对象，在堆区数据释放时会重复释放导致报错，所以对象中包含在堆区申请空间的代码，应该手动创建拷贝构造函数，将浅拷贝变成深拷贝

类的初始化列表

#include <iostream>

using namespace std;
class Person{
    public:
        int a;
        int b;
        int c;
        Person(int a,int b,int c):a(a),b(b),c(c)
        {
            
        }
};

int main()
{
    Person person(10,20,30);
    std::cout << person.a << endl;
    std::cout << person.b << endl;
    std::cout << person.c << endl;
    return 0;
}

类对象作为成员

#include <iostream>
#include <string>

using namespace std;

class Phone{
    public:
        string name;
        Phone(string name){
            this->name = name;
        }
};
class Person{
    public:
        string name;
        //当其他对象作为本类成员时。先构成其他类对象，再构造本类对象，析构顺序相反
        Phone phone;
        Person(string name,string phone):name(name),phone(phone)
        {
            
        }
};

int main()
{
    Person person("zhang","IPhoneX");
    std::cout << person.name << endl;
    std::cout << person.phone.name << endl;
    return 0;
}

静态成员

#include <iostream>
#include <string>

using namespace std;

class Person{
    public:
        //静态变量所有对象共享，可以通过对象访问也可以通过类直接访问
        static int a;
};

int Person::a = 1;//声明方式初始化静态属性
int main()
{
    Person::a = 10;
    std::cout << Person::a << endl;
    return 0;
}

常函数和常对象

#include <iostream>
#include <string>

using namespace std;

class Person{
    public:
        //this本质是指针常量 Person * const this 指针指向不可以修改
        //const 修饰的成员函数，修饰的是 this 相当于 const Person * const this，this指向的值也不可以修改
        void showPerson() const
        {
            //this->name = "zhanghuan1"; 不可执行
        
            this->a = 10; //该成员属性使用mutable修饰，故可以修改
        }
        void func(){
            
        }
        Person(){
            
        }
        mutable int a;
        string name;
};

int main()
{
    Person p;
    p.showPerson();
    std::cout << p.name << endl;
    std::cout << p.a << endl;
    
    //定义常对象
    const Person p1;
    p1.showPerson();//只能执行常函数
    //p1.func();无法执行
    
    return 0;
}

友元

全局函数作友元

#include <iostream>
#include <string>

using namespace std;


class Building{
    //将全局函数做友元
    friend void goodGay(Building *building);
    public:
        Building(){
            this->meetingRoom = "客厅";
            this->bedRoom = "卧室";
        }
        string meetingRoom;
    private:
        string bedRoom;
};

//全局函数
void goodGay(Building *building){
    cout << "好基友在访问" << building->meetingRoom << endl;
    cout << "好基友在访问" << building->bedRoom << endl;//可访问私有属性
}
int main()
{
    Building building;
    goodGay(&building);
    return 0;
}

类作为友元

#include <iostream>
#include <string>

using namespace std;


class Building{
    //将类做友元
    friend class GoodGay;
    public:
        Building(){
            this->meetingRoom = "客厅";
            this->bedRoom = "卧室";
        }
        string meetingRoom;
    private:
        string bedRoom;
};

class GoodGay{
    public:
        Building *building;
        GoodGay(){
            this->building = new Building;
        }
        void visit(){
            cout << "好基友在访问" << building->meetingRoom << endl;
            cout << "好基友在访问" << building->bedRoom << endl;//可访问私有属性
        }
};

int main()
{
    GoodGay goodGay;
    goodGay.visit();
    return 0;
}

成员函数作友元

#include <iostream>
#include <string>

using namespace std;

class Building;
class GoodGay{
    public:
        Building *building;
        GoodGay();
        void visit();
};

class Building{
    //将成员函数做友元
    friend void GoodGay::visit();
    public:
        Building();
        string meetingRoom;
    private:
        string bedRoom;
};



void GoodGay::visit(){
    cout << "好基友在访问" << building->meetingRoom << endl;
    cout << "好基友在访问" << building->bedRoom << endl;//可访问私有属性
}

GoodGay::GoodGay(){
    this->building = new Building;
}

Building::Building(){
    this->meetingRoom = "客厅";
    this->bedRoom = "卧室";
}





int main()
{
    GoodGay goodGay;
    goodGay.visit();
    return 0;
}

运算符重载

加号运输符重载

#include <iostream>
#include <string>

using namespace std;

class Person{
    public:
        Person(){
            
        }
        Person(int a):a(a){
            
        }
        //成员函数重载加号
        Person operator+(Person p){
            int temp = p.a + this->a;
            Person p1;
            p1.a = temp;
            return p1;
        }
        int a;
};

class Man{
    public:
        Man(){
            
        }
        Man(int a){
            this->a = a;
        }
        int a;
};

//全局函数重载加号
Man operator+(Man &man1,Man &man2){
    int temp = man1.a + man2.a;
    Man man(temp);
    return man;
}

//运算符重载也可以函数重载
Man operator+(Man &man1,int num){
    int temp = man1.a + num;
    Man man(temp);
    return man;
}

int main()
{
    Person p1(10);
    Person p2(20);
    Person p3 = p1 + p2;
    cout << p3.a << endl;
    
    Man man1(10);
    Man man2(20);
    Man man3 = man1 + man2;
    cout << man3.a << endl;
    
    Man man4 = man3 + 20;
    cout << man4.a << endl;
    
    return 0;
}

左移运算符重载

#include <iostream>
#include <string>

using namespace std;

class Person{
    friend ostream& operator<<(ostream &cout,Person &p);
    public:
        Person(){
            
        }
        Person(int a,int b){
            this->a = a;
            this->b = b;
        }
    private:
        int a;
        int b;
};

//重载左移运算符
ostream& operator<<(ostream &cout,Person &p){
    cout << "a=" << p.a << ",b=" << p.b;
    return cout;
}

int main()
{
    Person p(10,20);
    cout << p << endl;
    
    return 0;
}

递增运算符重载

#include <iostream>
#include <string>

using namespace std;

class MyInteger{
    friend ostream& operator<<(ostream& cout,MyInteger myInteger);
    public:
        MyInteger(){
            this->num = 0;
        }
        MyInteger(int num){
            this->num = num;
        }
        //定义前置递增
        MyInteger& operator++(){
            this->num++;
            return *this; 
        }
        //定义后置递增
        MyInteger operator++(int){
            //拷贝构造函数创建一个新对象
            MyInteger temp = *this;
            this->num++;
            return temp; 
        }
    private:
        int num;
};

ostream& operator<<(ostream& cout,MyInteger myInteger){
    cout << myInteger.num;
    return cout;
}


int main()
{
    MyInteger myInteger(10);
    cout << myInteger << endl;
    
    cout << ++myInteger << endl; //11
    cout << myInteger++ << endl; //11
    return 0;
}

赋值运算符重载

#include <iostream>
#include <string>

using namespace std;

class MyInteger{
    friend ostream& operator<<(ostream& cout,MyInteger& myInteger);
    public:
        MyInteger(){
            this->num = new int(0);
        }
        MyInteger(int num){
            this->num = new int(num);
        }
        ~MyInteger(){
            if(this->num != NULL){
                delete this->num;
                this->num = NULL;
            }
        }
       MyInteger& operator=(MyInteger& myInteger){
           //清空
           if(this->num != NULL){
               delete this->num;
               this->num = NULL;
           }
           //深拷贝
           this->num = new int(*myInteger.num);
           return *this;
       }
    private:
        int *num;
};

ostream& operator<<(ostream& cout,MyInteger& myInteger){//myInteger如果不传指向析构函数会执行两次，除非重写拷贝构造函数
    cout << *myInteger.num;
    return cout;
}


int main()
{
    MyInteger myInteger1(10);
    MyInteger myInteger2(20);
    MyInteger myInteger3(30);
    myInteger3 = myInteger2 = myInteger1;
    
    cout << myInteger1 << endl;
    cout << myInteger2 << endl;
    cout << myInteger3 << endl;
    return 0;
}

关系运算符重载

#include <iostream>
#include <string>

using namespace std;

class Person{
    public:
        Person(string name){
            this->name = name;
        }
        bool operator==(Person& person){
            if(person.name == this->name){
                return true;
            }
            return false;
        }
        bool operator!=(Person& person){
            if(person.name != this->name){
                return true;
            }
            return false;
        }
        string name;
};

int main()
{
    Person p1("zhang");
    Person p2("zhang1");
    std::cout << (p1 == p2) << endl; //0
    std::cout << (p1 != p2) << endl; //1
    return 0;
}

函数调用运算符重载

#include <iostream>
#include <string>

using namespace std;

class Myadd{
    public:
        int operator()(int a,int b){
            return a + b;
        }
};

int main()
{
    Myadd myadd1;
    int res1 = myadd1(10,10);
    cout << res1 << endl;
    
    //匿名对象调用
    cout << Myadd()(10,20) << endl;
    return 0;
}

继承

三种继承方式

#include <iostream>
#include <string>

using namespace std;

class Base{
    public:
        Base(){
            a = 10;
            b = 20;
            c = 30;
        }
        int a;
    protected:
        int b;
    private:
        int c;
};

//3中继承方式

class Son1:public Base{
    //继承过来的所有公共属性仍然为公共属性
};

class Son2:protected Base{
    //继承过来的所有公共属性变成保护属性
};

class Son3:private Base{
    //继承过来的所有公共属性、保护属性都变成私有属性
};


int main()
{
    Son1 son1;
    cout << son1.a << endl;
    
    return 0;
}

同名属性访问

#include <iostream>
#include <string>

using namespace std;

class Base{
    public:
        Base(){
            a = 10;
            b = 20;
            c = 30;
        }
        int a;
    protected:
        int b;
    private:
        int c;
};


class Son:public Base{
    public:
        Son(){
            a = 110;
        }
        int a;
};


int main()
{
    Son son;
    //默认访问子类的属性a
    cout << son.a << endl;
    //范围父类的属性a
    cout << son.Base::a << endl;
    
    return 0;
}

多继承语法

#include <iostream>
#include <string>

using namespace std;

class Base1{
    public:
        Base1(){
            a = 10;
        }
        int a;
};

class Base2{
    public:
        Base2(){
            a = 20;
        }
        int a;
};

//多继承语法
class Son:public Base1,public Base2{
    public:
        Son(){
            a = 110;
        }
        int a;
};


int main()
{
    Son son;
    
    cout << son.a << endl;
    cout << son.Base1::a << endl;
    cout << son.Base2::a << endl;
    
    return 0;
}

菱形继承

#include <iostream>
#include <string>

using namespace std;

class Animal{
    public:
     int a;
};

//通过虚继承解决子类继承的a属性的指向不明问题
class Sheep:virtual public Animal{
    
};

class Tuo:virtual public Animal{
    
};

class SheepTuo:public Sheep,public Tuo{
    
};


int main()
{
    SheepTuo sheepTuo;
    sheepTuo.a = 1;
    cout << sheepTuo.Sheep::a << endl; //1
    cout << sheepTuo.Tuo::a << endl; //1
    cout << sheepTuo.a << endl; //1
    
    return 0;
}

多态

多态分两类

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态:派生类和虚函数实现运行时多态

静态多态和动态多态区别

静态多态的函数地址早绑定，编译阶段确定函数地址
动态多态的函数地址晚绑定，运行阶段确定函数地址

#include <iostream>
#include <string>

using namespace std;

class Animal{
    public:
     //使用虚函数
     virtual void speak(){
         cout << "动物在说话" << endl;
     }
};

class Cat:public Animal{
    public:
     void speak(){
         cout << "猫在说话" << endl;
     }
};

class Dog:public Animal{
    public:
     void speak(){
         cout << "狗在说话" << endl;
     }
};

void doSpeak(Animal &animal){
    animal.speak();
}

int main()
{
    Cat cat;
    doSpeak(cat); //猫在说话
    
    Dog dog;
    doSpeak(dog); //狗在说话
    
    return 0;
}

虚函数原理

类中有虚函数，内的内部会有一个虚函数表记录虚函数的地址，当子类重写父类的虚函数时，子类的虚函数表内部会替换成子类函数的地址，从而实现多态

纯虚函数

语法 virtual 返回值类型虚函数名 (参数列表) = 0

但类中有了纯虚函数，这个类就是抽象类

抽象类特点

无法实例化对象

子类必须重写抽象类中的虚函数，否则也属于抽象类

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么弗雷指针子啊释放时无法调用到子类的析构代码，导致内存泄漏解决方式：将父类中的析构函数改为虚析构或者纯虚析构

案例

#include <iostream>
#include <string>

using namespace std;

class Cpu{
    public:
        virtual void calculate() = 0;
        virtual ~Cpu(){};
};

class DisplayCard{
    public:
        virtual void display() = 0;
        virtual ~DisplayCard(){};
};

class Storage{
    public:
        virtual void store() = 0;
        virtual ~Storage(){};
};

class IntelCpu:public Cpu{
    public:
        virtual void calculate(){
            cout << "IntelCpu 开始计算" << endl;
        }
        ~IntelCpu(){
            cout << "IntelCpu 析构函数执行" <<endl;
        }
};

class NvdCard:public DisplayCard{
    public:
        virtual void display(){
            cout << "NvdCard 开始工作" << endl;
        }
        ~NvdCard(){
            cout << "NvdCard 析构函数执行" <<endl;
        };
};

class SamSungDisk:public Storage{
    public:
        virtual void store(){
            cout << "三星硬盘 开始工作" << endl;
        }
        ~SamSungDisk(){
            cout << "三星硬盘 析构函数执行" <<endl;
        };
};

class Computer{
    public:
        Computer(Cpu *cpu,DisplayCard *displayCard,Storage *storage){
            this->cpu = cpu;
            this->displayCard = displayCard;
            this->storage = storage;
        }
        void doWork(){
            cpu->calculate();
            displayCard->display();
            storage->store();
        }
        ~Computer(){
            cout << "Computer 析构函数执行" << endl;
            if(cpu != NULL){
                delete cpu;
                cpu = NULL;
            }
            if(displayCard != NULL){
                delete displayCard;
                displayCard = NULL;
            }
            if(storage != NULL){
                delete storage;
                storage = NULL;
            }
        }
    private:
        Cpu *cpu;
        DisplayCard *displayCard;
        Storage *storage;
};

int main()
{
    Computer *computer = new Computer(new IntelCpu(),new NvdCard(),new SamSungDisk());
    computer->doWork();
    
    delete computer;
    /**
     *  IntelCpu 开始计算
        NvdCard 开始工作
        三星硬盘 开始工作
        Computer 析构函数执行
        IntelCpu 析构函数执行
        NvdCard 析构函数执行
        三星硬盘 析构函数执行
     * /
    return 0;
}

文件读写

普通方式文件读写

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

using namespace std;


void test1() {
    //写入
    ofstream ofs;
    ofs.open("test.txt", ios::out);

    ofs << "姓名：张三" << endl;
    ofs << "性别：男" << endl;
    ofs << "年龄：23" << endl;

    ofs.close();  
}

void test2() {
    //读取
    ifstream ifs;
    ifs.open("test.txt", ios::in);
    if (!ifs.is_open()) {
        cout << "文件打开失败" << endl;
        return;
    }

    char buf[1024] = { 0 };

    //方式一
    /**
    while (ifs >> buf) {
        cout << buf << endl;
    }
    **/

    //方式二
    /**
    while (ifs.getline(buf, sizeof(buf))) {
        cout << buf << endl;
    }
    **/

    //方式三
    /**
    string bf;
    while (getline(ifs, bf)) {
        cout << bf << endl;
    }
    **/

    //方式四
    char c;
    while ( (c = ifs.get()) != EOF) {
        cout << c;
    }
    ifs.close();
}


void main() {
    test2();
}

二进制方式读写

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

using namespace std;

class Person {
public:
    string name;
    int age;
};

void test1() {
    //写入
    ofstream ofs;
    ofs.open("person.txt", ios::out | ios::binary);

    Person p = { "zhanghuan",22 };

    ofs.write((const char*)&p, sizeof(p));

    ofs.close();  
}

void test2() {
    //读取
    ifstream ifs;
    ifs.open("person.txt", ios::in | ios::binary);
    if (!ifs.is_open()) {
        cout << "文件打开失败" << endl;
        return;
    }
    Person p;

    ifs.read((char*)&p, sizeof(Person));

    cout << p.name << endl;

    cout << p.age << endl;
    
    ifs.close();
}


int main() {
    //test1();
    test2();
    return 0;
}

模板

基本使用

#include <cstdio>

template<typename T>
void swap(T &a, T &b)
{ 
    T t = a;
    a = b;
    b = t;
}

int main()
{
    int x = 3, y = 6;
    printf("%d %d\n", x, y);
    swap<int>(x, y);//制定类型，可不传int则会自动推导
    printf("%d %d\n", x, y);
    return 0;
}

注意事项

自动类型推导，必须推导出一致数据类型T才可以使用
模板必须要确定出T的数据类型，才可以使用

选择排序案例

#include <cstdio>

template<typename T>
void swap(T &a, T &b)
{ 
    T t = a;
    a = b;
    b = t;
}

template<typename T>
void printArray(T arr[],int len){
    printf("[");
    for (int i = 0; i < len; ++i) {
        printf("%d", arr[i]);
        if (i < len - 1) {
            printf(", ");
        }
    }
    printf("]\n");
}

template<typename T>
void mySort(T arr[],int len){
    for(int i=0;i<len;i++){
        int maxIndex = i;
        for (int j = i+1; j < len; j++) {
            if(arr[maxIndex] < arr[j]){
                maxIndex = j;
            }
        }
        if(i != maxIndex){
            swap(arr[i],arr[maxIndex]);
        }
    }
}

int main()
{
    int arr[] = {1,2,4,6,3};
    int len = sizeof(arr)/sizeof(int);
    printArray(arr,len);
    mySort(arr,len);
    printArray(arr,len);//64321
}

类模板成员函数创建时机

在运行时创建

类模板与继承

#include <iostream>
using namespace std;

template<class T>
class Base{
	T obj1;
};

class Son1:public Base<int>{//必须要知道父类中T的类型才可以继承
};

template<class T1,class T2>
class Son2:public Base<T1>{
	T2 obj2;
};
	
int main()
{
   cout << "Hello World1";
   return 0;
}

类模板成员函数类外实现

#include <iostream>
#include <string>
using namespace std;

template<class T1,class T2>
class Person{
	public:
		T1 name;
		T2 age;
		Person(T1 name,T2 age);
		void showPerson();
};

template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age){
	this->name = name;
	this->age = age;
}

template<class T1,class T2>
void Person<T1,T2>::showPerson(){
	cout << "姓名：" << name << ",年龄：" << age << endl;
}

	
int main()
{
	
	Person<string,int> p("zh",22);
	p.showPerson();
	return 0;
}

类模板分文件编写

直接包含源文件
将.h和.cpp的内容写到一起，将后缀名改为.hpp

类模板与友元

#include <iostream>
#include <string>

using namespace std;

template<class T1,class T2>
class Person;

template<class T1,class T2>
void printPerson2(Person<T1,T2> p){
    cout << "name:" << p.name << " age:" << p.age << endl;
}

template<class T1,class T2>
class Person{
    //在类中定义全局函数
    friend void printPerson1(Person p){
        cout << "name:" << p.name << " age:" << p.age << endl;
    }
    
    //类外实现全局函数
    friend void printPerson2<>(Person<T1,T2> p);
    public:
        Person(T1 name,T2 age){
            this->name = name;
            this->age = age;
        }
    private:
        T1 name;
        T2 age;
};


int main()
{
    Person<string,int> p("zhang",22);
    
    printPerson1(p);
    printPerson2(p);
    return 0;
}

自定义数组

#pragma
#include <iostream>

using namespace std;

template<class T>
class MyArray {
public:
    T* array;
    int len;
    int capacity;
    MyArray(int capacity) {
        this->capacity = capacity;
        this->array = new T[this->capacity];
        this->len = 0;
    }
    MyArray(const MyArray& myArray) {
        this->capacity = myArray.capacity;
        this->array = new T[myArray.capacity];
        this->len = myArray.len;
        for (int i = 0; i < len; ++i) {
            this->array[i] = myArray.array[i];
        }
    }
    ~MyArray() {
        delete[] array;
    }
    MyArray& operator =(const MyArray& myArray) {
        if (this->array != NULL){
            delete[] this->array;
            this->array = NULL;
        }
        this->len = myArray.len;
        this->array = new T[len];
        this->capacity = myArray.capacity;
        for (int i = 0; i < len; ++i) {
            this->array[i] = myArray.array[i];
        }
        return *this;
    }
    T& operator [](int i) {
        return this->array[i];
    }
    void push(const T& t) {
        if (len == capacity) {
            return;
        }
        this->array[len] = t;
        this-> len ++;
    }
    void pop() {
        if (len == 0) {
            return;
        }
        this->len --;
    }
    int getLength() {
        return this->len;
    }
    int getCapacity() {
        return this->capacity;
    }
};

STL

在 C++ 中，STL（Standard Template Library）是一个非常重要的组成部分，它提供了大量的通用模板类和函数，用于处理常见的数据结构和算法。STL 是 C++ 标准库的一部分，并且被广泛用于各种 C++ 程序中。

STL 主要由以下几个组件组成：

容器（Containers）：STL 提供了多种类型的容器，如向量（std::vector）、列表（std::list）、双端队列（std::deque）、集合（std::set）、映射（std::map）等。这些容器类模板用于存储和管理数据元素。迭代器（Iterators）：迭代器提供了一种访问容器中元素的方式，它们类似于指针，但更为通用。迭代器可以遍历容器中的所有元素，并允许我们读取或修改这些元素的值。算法（Algorithms）：STL 提供了大量用于操作容器中元素的算法，如排序（std::sort）、查找（std::find）、复制（std::copy）等。这些算法通常与容器和迭代器一起使用，以实现对容器中数据的复杂操作。函数对象（Function Objects）：函数对象（也称为仿函数或函数子）是 STL 中一个重要的概念。它们是可以像函数一样被调用的对象，通常用于作为算法的参数，以定义算法的行为。适配器（Adapters）：适配器用于修改容器或迭代器的行为，以适应不同的算法需求。例如，std::stack 和 std::queue 是基于其他容器（如 std::deque）的适配器，它们提供了栈和队列的接口。分配器（Allocators）：分配器用于管理容器中元素的内存分配和释放。虽然大多数程序员不需要直接使用分配器，但它们为 STL 提供了高度的灵活性和可定制性。通过使用 STL，程序员可以更加高效地编写 C++ 代码，因为 STL 中的组件已经经过了优化和测试，并且与 C++ 标准库的其他部分紧密集成。此外，STL 的模板特性使得代码更加通用和可重用，减少了编写重复代码的需要。

vector

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    vector<int> v;
    v.push_back(11);
    v.push_back(15);
    v.push_back(7);

    for (size_t i = 0; i < v.size(); ++i) {
        cout << v[i] << " ";
    }
    cout << endl; // 输出: 11 15 7

    // 使用迭代器遍历vector
    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl; // 输出: 11 15 7

    //排序
    sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

    for (size_t i = 0; i < v.size(); ++i) {
        cout << v[i] << " ";
    }
    cout << endl; // 输出: 7 11 15
    return 0;
}

使用swap压缩空间

#include <iostream>
#include <vector>

using namespace std;

int main()
{

    vector<int> v;
    for (int i = 0; i < 17; ++i) {
        v.push_back(i);
    }
    v.pop_back();
    v.pop_back();
    v.pop_back();
    v.pop_back();
    v.pop_back();

    cout << "capacity: " << v.capacity() << endl; //32
    
    //创建匿名对象，将匿名对象和原来的对象交换，达到压缩空间的目的
    vector<int> (v).swap(v);

    cout << "capacity: " << v.capacity() << endl; //12

    return 0;
}

预分配空间

#include <iostream>
#include <vector>

using namespace std;

int main()
{

    vector<int> v;
    int num = 0;
    int* ptr = NULL;
    for (int i = 0; i < 17; ++i) {
        v.push_back(i);
        if (ptr != &v[0]){
            ptr = &v[0];
            num++;
        }
    }

    //查看扩容次数 6-1=5
    cout << "num: " << num << endl;

    vector<int> v1;
    v1.reserve(20);//预先申请20容量，避免多次扩容消耗性能
    int num1 = 0;
    int* ptr1 = NULL;
    for (int i = 0; i < 17; ++i) {
        v1.push_back(i);
        if (ptr1 != &v1[0]){
            ptr1 = &v1[0];
            num1++;
        }
    }

    //查看扩容次数 1-1=0
    cout << "num1: " << num1 << endl;

    return 0;
}

deque

基础

#include <iostream>
#include <deque>
#include <algorithm>

using namespace std;

//打印
void printDq(const deque<int>& d){
    for (deque<int>::const_iterator it = d.begin();it != d.end();it++ ) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    deque<int> dq;
    for (int i = 0; i < 5; ++i) {
        dq.push_back(i);
    }

    printDq(dq);

    //赋值
    deque<int> d1 = dq;
    printDq(d1);

    //传入开始结束
    deque<int> d2(dq.begin(),dq.end());
    printDq(d2);

    //10个100
    deque<int> d3(10,100);
    printDq(d3);

    //构造函数赋值
    deque<int> d4(d3);
    printDq(d4);

    //assign方式赋值
    deque<int> d5;
    d5.assign(d4.begin(),d4.end());
    printDq(d5);

    //10个10
    deque<int> d6;
    d6.assign(10,10);
    printDq(d6);


    cout << "长度：" << d6.size() << endl;

    //重新设置长度
    d6.resize(5);
    printDq(d6);
    //默认补0
    d6.resize(10);
    printDq(d6);
    //指定补5
    d6.resize(15,5);
    printDq(d6);

    //插入
    d6.push_back(100);
    d6.push_front(1);
    printDq(d6);//1 10 10 10 10 10 0 0 0 0 0 5 5 5 5 5 100
    //区间插入
    d2.insert(d2.begin(),d1.begin(),d1.end());
    printDq(d2);//0 1 2 3 4 0 1 2 3 4

    //头删除
    d3.pop_front();
    printDq(d3);
    //尾删除
    d3.pop_back();
    printDq(d3);

    //指定删除
    deque<int>::iterator it = d2.begin();
    it ++;
    d2.erase(it);
    printDq(d2);//0 2 3 4 0 1 2 3 4

    //清空，相当于clear
    d2.erase(d2.begin(),d2.end());
    printDq(d2);

    //排序，默认从小到大
    sort(d6.begin(),d6.end());
    printDq(d6);

    return 0;
}

案例

创建5名选手，放到vector中
遍历vector容器，取出每一个选手，进行10个打分放到deque中
sort算法堆deque容器中分数排序，去掉最高分和最低分
计算每个选手deque中的平均分

#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <string>
#include <ctime>

using namespace std;

class Person{
public:
    Person(string name){
        this->name = name;
    }
    void setAvgScore(int score){
        this->avgScore = score;
    }
    string getName(){
        return this->name;
    }
    int getAvgScore(){
        return this->avgScore;
    }
private:
    string name;
    int avgScore;
};

int main() {

    //随机种子
    srand((unsigned int) time(NULL));

    //创建5名选手
    string names = "ABCDE";
    vector<Person> persons;
    for (int i = 0; i < 5; ++i) {
        string  name = "选手";
        name += names[i];
        Person p(name);
        persons.push_back(p);
    }

    //给每个选手打分
    for (int i=0;i<persons.size();i++) {
        Person& person = persons[i];

        deque<int> scores;
        for (int j = 0; j < 10; ++j) {
            int score = rand()%41 + 60;
            scores.push_back(score);
        }
        //排序
        sort(scores.begin(),scores.end());
        //去掉最高分和最低分
        scores.pop_back();
        scores.pop_front();
        //计算平均分
        int sum = 0;
        for (int j = 0; j < scores.size(); ++j) {
            sum += scores[j];
        }
        int avg = sum/scores.size();
        person.setAvgScore(avg);
    }

    //打印5名选手的分数
    for (int i = 0; i < persons.size(); ++i) {
        Person person = persons[i];
        cout << "姓名：" <<person.getName() << " 得分：" << person.getAvgScore() << endl;
    }
    return 0;
}

栈

#include <iostream>
#include <stack>

using namespace std;

int main() {

    stack<int> s;

    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    s.push(5);

    while (!s.empty()){
        cout << "栈顶： " << s.top() << endl;
        cout << "栈大小： " << s.size() << endl;
        //出栈
        s.pop();
    }

    return 0;
}

队列

#include <iostream>
#include <queue>
#include <string>
using namespace std;

class Person{
public:
    Person(string name,int age){
        this->name = name;
        this->age = age;
    }
    string name;
    int age;
    void print(){
        cout << "姓名： " << name << " 年龄： " << age << endl;
    }
};

int main() {

    queue<Person> q;

    Person p1("唐僧",30);
    Person p2("孙悟空",1000);
    Person p3("猪八戒",900);
    Person p4("沙僧",800);

    q.push(p1);
    q.push(p2);
    q.push(p3);
    q.push(p4);

    while (!q.empty()){
        q.front().print();
        q.pop();
    }

    return 0;
}

list

构造函数

#include <iostream>
#include <list>
using namespace std;

void printList(list<int>& ls){
    for (list<int>::iterator it = ls.begin();it != ls.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    list<int> l1;
    l1.push_back(1);
    l1.push_back(2);
    l1.push_back(3);
    l1.push_back(4);

    printList( l1);

    list<int> l2(l1.begin(),l1.end());
    printList(l2);

    list<int> l3(l2);
    printList(l3);

    list<int> l4(10,100);
    printList(l4);

    return 0;
}

赋值和交换

#include <iostream>
#include <list>
#include <algorithm>
#include <string>
using namespace std;

void printList(list<int>& ls){
    for (list<int>::iterator it = ls.begin();it != ls.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    list<int> l1;
    l1.push_back(1);
    l1.push_back(2);
    l1.push_back(3);
    l1.push_back(4);

    printList( l1);

    //=赋值
    list<int> l2 = l1;
    printList(l2);

    //assign 赋值
    list<int> l3;
    l3.assign(l1.begin(),l1.end());
    printList(l3);

    list<int> l4;
    l4.assign(10,100);
    printList(l4);

    //交换
    cout << "交换前" << endl;
    printList(l1);
    printList(l4);

    l4.swap(l1);

    cout << "交换后" << endl;
    printList(l1);
    printList(l4);

    return 0;
}

指定大小

#include <iostream>
#include <list>

using namespace std;

void printList(list<int>& ls){
    for (list<int>::iterator it = ls.begin();it != ls.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    list<int> l1;
    l1.push_back(1);
    l1.push_back(2);
    l1.push_back(3);
    l1.push_back(4);

    if (l1.empty()){
        cout << "为空" << endl;
    }else{
        cout << "不为空" << endl;
        cout << "长度为：" << l1.size() << endl;
    }

    //重新指定大小
    l1.resize(10);
    printList(l1);

    //缩小时，多余元素会被删除
    l1.resize(2);
    printList(l1);

    return 0;
}

插入和删除

#include <iostream>
#include <list>

using namespace std;

void printList(list<int>& ls){
    for (list<int>::iterator it = ls.begin();it != ls.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    list<int> l1;
    l1.push_back(1);
    l1.push_back(2);
    l1.push_back(3);
    l1.push_back(4);

    //头插入
    l1.push_front(10);
    l1.push_front(20);
    printList(l1);//20 10 1 2 3 4

    //insert插入
    list<int>::iterator it = l1.begin();
    l1.insert(++it,1000);
    printList(l1);//20 1000 10 1 2 3 4

    //删除
    it = l1.begin();
    l1.erase(it);
    printList(l1);//1000 10 1 2 3 4

    //移除 删除所有满足条件的数据
    l1.push_back(10000);
    l1.push_back(10000);
    l1.push_back(10000);
    l1.push_back(10000);
    l1.push_back(10000);
    l1.remove(10000);
    printList(l1); //1000 10 1 2 3 4

    //清空
    l1.clear();
    printList(l1);

    return 0;
}

数据存取

#include <iostream>
#include <list>
#include <algorithm>
#include <string>
using namespace std;

void printList(list<int>& ls){
    for (list<int>::iterator it = ls.begin();it != ls.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    list<int> l1;
    l1.push_back(1);
    l1.push_back(2);
    l1.push_back(3);
    l1.push_back(4);

    //list是链表，不支持随机范围，[]和at都不可用

    cout << "第一个元素：" << l1.front() << endl;
    cout << "最后一个元素：" << l1.back() << endl;
    
    list<int>::iterator it = l1.begin();
    it++;
    it--;
    //不支持it+1

    return 0;
}

排序和反转

#include <iostream>
#include <list>
#include <string>
using namespace std;

void printList(list<int>& ls){
    for (list<int>::iterator it = ls.begin();it != ls.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

bool compare(int v1,int v2){
    return v1 > v2;
}

int main() {

    list<int> l1;
    l1.push_back(5);
    l1.push_back(2);
    l1.push_back(3);
    l1.push_back(4);

    cout << "排序前" << endl;
    printList(l1);
    l1.sort();
    cout << "排序后" << endl;
    printList(l1);

    //从大到校排序，需要自定义排序函数
    l1.sort(compare);
    cout << "从大到小排序后：" << endl;
    printList(l1);

    //反转
    l1.reverse();
    printList(l1);

    return 0;
}

排序案例

将Person进行排序，对象属性为姓名、年龄、身高
排序规则，按照年龄升序，如果年龄相同安装身高降序

#include <iostream>
#include <list>
#include <string>
using namespace std;

class Person{
public:
    Person(string name,int age,int height){
        this->name = name;
        this->age = age;
        this->height = height;
    }
    string name;
    int age;
    int height;
};

void printList(list<Person>& ls){
    for (list<Person>::iterator it = ls.begin();it != ls.end();it++) {
        cout << " 姓名：" << it->name << " 年龄：" << it->age << " 身高：" << it->height << endl;
    }
}

bool compare(Person& p1,Person& p2){
    if (p1.age == p2.age){
        return p1.height > p2.height;
    } else{
        return p1.age < p2.age;
    }
}

int main() {

    list<Person> ls;

    Person p1("刘备",35,175);
    Person p2("曹操",45,180);
    Person p3("孙权",40,170);
    Person p4("赵云",25,190);
    Person p5("张飞",35,160);
    Person p6("关羽",35,200);

    ls.push_back(p1);
    ls.push_back(p2);
    ls.push_back(p3);
    ls.push_back(p4);
    ls.push_back(p5);
    ls.push_back(p6);

    cout << "排序前：" << endl;
    printList(ls);

    ls.sort(compare);

    cout << "排序后：" << endl;
    printList(ls);

    return 0;
}

set

构造和赋值

#include <iostream>
#include <set>
#include <string>
using namespace std;


void printSet(set<int>& s){
    for (set<int>::iterator it = s.begin();it != s.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    set<int> s;

    s.insert(10);
    s.insert(40);
    s.insert(30);
    s.insert(20);
    s.insert(30);

    printSet(s);//10 20 30 40

    //拷贝构造
    set<int> s2(s);

    return 0;
}

容器大小和交换

#include <iostream>
#include <set>
#include <string>
using namespace std;


void printSet(set<int>& s){
    for (set<int>::iterator it = s.begin();it != s.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    set<int> s;

    s.insert(10);
    s.insert(40);
    s.insert(30);
    s.insert(20);
    s.insert(30);

    if (s.empty()){
        cout << "容器是空的" << endl;
    }else{
        cout << "大小：" << s.size() << endl;
    }

    set<int> s1;

    s1.insert(100);
    s1.insert(400);

    cout << "交换前" << endl;
    printSet(s);
    printSet(s1);
    s.swap(s1);
    cout << "交换后" << endl;
    printSet(s);
    printSet(s1);

    return 0;
}

插入和删除

#include <iostream>
#include <set>
#include <string>
using namespace std;


void printSet(set<int>& s){
    for (set<int>::iterator it = s.begin();it != s.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    set<int> s;

    s.insert(10);
    s.insert(40);
    s.insert(30);
    s.insert(20);
    s.insert(30);

    //删除
    s.erase(s.begin());
    printSet(s);//20 30 40

    s.erase(30);
    printSet(s);//20 30 40

    s.erase(s.begin(),s.end());
    s.clear();

    return 0;
}

查找和统计

#include <iostream>
#include <set>
#include <string>
using namespace std;


void printSet(set<int>& s){
    for (set<int>::iterator it = s.begin();it != s.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    set<int> s;

    s.insert(10);
    s.insert(40);
    s.insert(30);
    s.insert(20);
    s.insert(30);

    //查找
    set<int>::iterator it = s.find(30);
    if (it != s.end()){
        cout << "找到了" << endl;
    }else{
        cout << "没找到" << endl;
    }

    //统计
    int num = s.count(30);
    cout << num << endl;//1

    multiset<int> ms;
    ms.insert(1);
    ms.insert(1);
    ms.insert(1);
    ms.insert(1);

    int num1 = ms.count(1);
    cout << num1 << endl;//4

    return 0;
}

pair

#include <iostream>
#include <string>
using namespace std;



int main() {
    //第一种方式
    pair<string,int> p("zh",12);
    cout << "姓名： " << p.first << " 年龄： " << p.second << endl;

    //第二种方式
    pair<string,int> p2 = make_pair("zh",13);
    cout << "姓名： " << p2.first << " 年龄： " << p2.second << endl;

    return 0;
}

指定排序规则

#include <iostream>
#include <set>
#include <string>
using namespace std;


class MyCompare{
public:
    bool operator()(int v1,int v2) const{
        return v1 > v2;
    }
};

int main() {
    set<int,MyCompare> s;

    s.insert(10);
    s.insert(40);
    s.insert(30);
    s.insert(20);
    s.insert(30);

    for (set<int,MyCompare>::iterator it = s.begin();it != s.end();it++) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}

map

构造和赋值

#include <iostream>
#include <map>
#include <string>
using namespace std;


void printMap(map<int,int> &m){
    for (map<int,int>::iterator it = m.begin();it != m.end();it++){
        cout << "key=" << it->first << " value=" << it->second << endl;
    }
}

int main() {
    map<int,int> m;

    m.insert(pair<int,int>(1,1));
    m.insert(pair<int,int>(2,1));

    printMap(m);

    //拷贝构造
    map<int,int> m2(m);
    printMap(m2);

    //赋值
    map<int,int> m3;
    m3 = m2;
    printMap(m3);

    return 0;
}

容器大小和交换

#include <iostream>
#include <map>
#include <string>
using namespace std;


void printMap(map<int,int> &m){
    for (map<int,int>::iterator it = m.begin();it != m.end();it++){
        cout << "key=" << it->first << " value=" << it->second << endl;
    }
}

int main() {
    map<int,int> m;
    m.insert(pair<int,int>(1,1));

    if (m.empty()){
        cout << "空的map" << endl;
    }else{
        cout << m.size() << endl;
    }

    map<int,int> m1;
    m1.insert(pair<int,int>(2,1));

    cout << "交换前：" << endl;
    printMap(m);
    printMap(m1);

    m.swap(m1);
    cout << "交换后：" << endl;
    printMap(m);
    printMap(m1);

    return 0;
}

插入和删除

#include <iostream>
#include <map>
#include <string>
using namespace std;


void printMap(map<int,int> &m){
    for (map<int,int>::iterator it = m.begin();it != m.end();it++){
        cout << "key=" << it->first << " value=" << it->second << endl;
    }
}

int main() {
    map<int,int> m;

    //插入
    m.insert(pair<int,int>(1,1));
    m.insert(make_pair(2,1));
    m.insert(map<int,int>::value_type (3,1));
    m[4] = 4;

    printMap(m);

    //删除
    m.erase(m.begin());
    printMap(m);

    m.erase(3);
    printMap(m);

    m.clear();
    printMap(m);
    
    return 0;
}

查找和统计

#include <iostream>
#include <map>
#include <string>
using namespace std;


void printMap(map<int,int> &m){
    for (map<int,int>::iterator it = m.begin();it != m.end();it++){
        cout << "key=" << it->first << " value=" << it->second << endl;
    }
}

int main() {
    map<int,int> m;

    m.insert(pair<int,int>(1,1));
    m.insert(pair<int,int>(2,1));
    m.insert(pair<int,int>(3,1));

    //查找
    map<int,int>::iterator pos = m.find(3);
    if (pos != m.end()){
        cout << "key=" << pos->first << " value=" << pos->second << endl;
    }else{
        cout << "未找到元素" << endl;
    }

    //统计
    int num = m.count(3);
    cout << "num=" << num << endl;
    
    return 0;
}

排序

#include <iostream>
#include <map>
#include <string>
using namespace std;

class MyCompare{
public:
    bool operator()(int v1,int v2) const{
        return v1 > v2;
    }
};

void printMap(map<int,int,MyCompare> &m){
    for (map<int,int>::iterator it = m.begin();it != m.end();it++){
        cout << "key=" << it->first << " value=" << it->second << endl;
    }
}

int main() {
    map<int,int,MyCompare> m;

    m.insert(pair<int,int>(1,1));
    m.insert(pair<int,int>(2,1));
    m.insert(pair<int,int>(3,1));

    printMap(m);

    return 0;
}

函数对象

函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递

#include <iostream>
#include <string>
using namespace std;

class MyAdd{
public:
    int operator()(int v1,int v2) const{
        return v1 + v2;
    }
};

int main() {

    MyAdd myAdd;
    int num = myAdd(1,2);
    cout << num << endl;

    return 0;
}

谓词

返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫一元谓词
如果operator()接受两个个参数，那么叫二元谓词

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

class GreaterFive{
public:
    bool operator()(int v1) const{
        return v1 > 5;
    }
};

int main() {

    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }

    vector<int>::iterator it = find_if(v.begin(),v.end(),GreaterFive());
    if (it == v.end()){
        cout << "未找到" << endl;
    } else{
        cout << *it << endl;
    }

    return 0;
}

内建仿函数

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

void test1(){
    negate<int> n;
    cout << n(50) << endl;

    plus<int> p;
    cout << p(10,10) << endl;
}

void test2(){
    vector<int> v;
    v.push_back(2);
    v.push_back(4);
    v.push_back(3);
    v.push_back(5);
    v.push_back(1);

    for (vector<int>::iterator it =v.begin();it != v.end();it++) {
        cout << *it << " ";
    }
    cout << endl;

    sort(v.begin(),v.end(),greater<int>());
    for (vector<int>::iterator it =v.begin();it != v.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

void test3(){
    vector<bool> v;
    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);

    for (vector<bool>::iterator it =v.begin();it != v.end();it++) {
        cout << *it << " ";
    }
    cout << endl;

    vector<bool> v1;
    v1.resize(v.size());
    transform(v.begin(),v.end(),v1.begin(),logical_not<bool>());

    for (vector<bool>::iterator it =v1.begin();it != v1.end();it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {

    //算术反函数
    test1();

    //关系仿函数
    test2();

    //逻辑仿函数
    test3();

    return 0;
}

算法

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Person{
public:
    Person(string name, int age) {
        this->name = name;
        this->age = age;
    }
    bool operator==(const Person &p)
    {
        if (this->age == p.age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string name;
    int age;
};

void test1(vector<Person> v1){
    //帅选出年龄大于25的第一个对象
    vector<Person>::iterator it = find_if(v1.begin(),v1.end(),[](Person &p){
        return p.age > 25;
    });
    if (it != v1.end()){
        cout << "找到了" << endl;
        cout << "姓名：" << it->name << " 年龄：" << it->age << endl;
    }else{
        cout << "未找到" << endl;
    }
}

void test2(vector<Person> v1){
    //相邻两个对象，第一个大于第二个的年龄
    vector<Person>::iterator it = adjacent_find(v1.begin(),v1.end(),[](Person &p1,Person &p2){
        return p1.age > p2.age;
    });
    if (it != v1.end()){
        cout << "找到了" << endl;
        cout << "姓名：" << it->name << " 年龄：" << it->age << endl;
    }else{
        cout << "未找到" << endl;
    }
}

void test3(vector<int> v1){
    sort(v1.begin(),v1.end(),less<int>());
    //只能对排好序的容器进行查找
    bool  b = binary_search(v1.begin(),v1.end(),2);
    if (b){
        cout << "找到了" << endl;
    }else{
        cout << "未找到" << endl;
    }
}

void test4(vector<Person> v1,Person &p){
    //统计对象个数
    int num = count(v1.begin(), v1.end(), p);
    cout << num << endl;
}

void test5(vector<Person> v1){
    int num = count_if(v1.begin(),v1.end(),[](Person &p){
        return p.age > 25;
    });
    cout << num << endl;
}

void test6(vector<int> v1,vector<int> v2){
    vector<int> result(v1.size() + v2.size());
    std::merge(v1.begin(), v1.end(),v2.begin(),v2.end(),result.begin());
    for_each(result.begin(),result.end(),[](int num){
        cout << num << endl;
    });
}

void test7(vector<Person> v1){
    reverse(v1.begin(),v1.end());
    for_each(v1.begin(),v1.end(),[&](Person p){
        cout << "姓名：" << p.name << " 年龄：" << p.age << endl;
    });
}

void test8(){
    vector<int> source = {1, 2, 3, 4, 5};
    vector<int> destination(source.size());

    copy(source.begin(), source.end(), destination.begin());

    // 输出复制后的容器
    for (int num : destination) {
        cout << num << " ";
    }
    cout << endl;
}

void test9(){
    vector<int> source = {1, 2, 3, 4, 5};
    replace(source.begin(),source.end(),2,200);
    for (int num : source) {
        cout << num << " ";
    }
    cout << endl;
}

void test10(){
    vector<int> source = {1, 2, 3, 4, 5};
    replace_if(source.begin(),source.end(),[](int num){
        return num > 2;
    },200);

    for (int num : source) {
        cout << num << " ";
    }
    cout << endl;
}

void test11(){
    vector<int> v1 = {1, 2, 3, 4, 5};
    vector<int> v2 = {10, 20, 30, 40, 50};
    swap(v1,v2);
    for (int num : v1) {
        cout << num << " ";
    }
    cout << endl;
    for (int num : v2) {
        cout << num << " ";
    }
    cout << endl;
}

void test12(){
    vector<int> v1;
    v1.resize(10);
    fill(v1.begin(),v1.end(),100);
    for (int num : v1) {
        cout << num << " ";
    }
    cout << endl;
}

void test13(){
    cout << "test13" << endl;
    //两个源容器必须有序，且顺序一致
    vector<int> v1 = {1, 2, 3, 4, 5};
    vector<int> v2 = {3,4,5,6,7};
    vector<int> v3;
    v3.resize(min(v1.size(),v2.size()));
    vector<int>::iterator v3End = set_intersection(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin());
    for_each(v3.begin(),v3End,[](int num){
       cout << num << endl;
    });
}

void test14(){
    cout << "test14" << endl;
    //两个源容器必须有序，且顺序一致
    vector<int> v1 = {1, 2, 3, 4, 5};
    vector<int> v2 = {3,4,5,6,7};
    vector<int> v3;
    v3.resize(min(v1.size(),v2.size()));
    vector<int>::iterator v3End = set_difference(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin());
    for_each(v3.begin(),v3End,[](int num){
        cout << num << endl;
    });//1,2
}

void test15(){
    cout << "test15" << endl;
    //两个源容器必须有序，且顺序一致
    vector<int> v1 = {1, 2, 3, 4, 5};
    vector<int> v2 = {3,4,5,6,7};
    vector<int> v3;
    v3.resize(min(v1.size(),v2.size()));
    vector<int>::iterator v3End = set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin());
    for_each(v3.begin(),v3End,[](int num){
        cout << num << endl;
    });
}



int main()
{

    vector<Person> v1;
    Person p1("刘备", 35);
    Person p2("关羽",35);
    Person p3("张飞", 35);
    Person p4("赵云", 30);
    Person p5("曹操", 40);
    //将人员插入到容器
    v1.push_back(p1);
    v1.push_back(p2);
    v1.push_back(p3);
    v1.push_back(p4);
    v1.push_back(p5);

    for_each(v1.begin(),v1.end(),[](Person &p){
        cout << "姓名：" << p.name << " 年龄：" << p.age << endl;
    });

    //find_if
    test1(v1);

    //adjacent_find
    test2(v1);

    //binary_search
    test3({1,3,9,5,4,2});

    //count
    test4(v1,p1);

    //count_if
    test5(v1);
    cout << "--------------" << endl;

    //merge
    test6({1,3,4},{2,5,7});

    //reverse
    test7(v1);

    //copy
    test8();

    //replace
    test9();

    //replace_if
    test10();

    //swap
    test11();

    //fill
    test12();

    //交集
    test13();

    //差集
    test14();

    //并集
    test15();
    
    return 0;
}

flink-cdc使用

Fri, 22 Dec 2023 00:00:00 +0000

应用场景、上手体验

应用场景

Flink CDC (Change Data Capture) 是一种用于捕获和处理数据源中的变化的流处理技术。它可以实时地将数据源中的增量更新捕获到流处理作业中，使得作业可以实时响应数据变化。以下是 Flink CDC 的一些常见应用场景：

数据仓库和实时分析：Flink CDC 可以用于从事务型数据库或消息队列中捕获变化，并将这些变化实时地传输到数据仓库或实时分析系统中。这可以帮助实时分析、报表生成、指标计算等业务在数据更新时立即得到更新的结果，带来实时性和洞察力。
实时ETL和数据同步：Flink CDC 可以实时地捕获源数据变化，并将其转换成目标数据模型，然后将这些转换后的数据输送到其他系统或存储位置，实现实时ETL（Extract, Transform, Load）或数据同步的功能。这种能力可以在不中断服务的情况下对数据进行实时转换、整合和迁移。
反应式应用程序：Flink CDC 可以用于构建反应式应用程序，即根据数据源中的实时变化来实时响应和处理数据。这对于实时监测、告警系统、实时推荐等具有快速响应时间要求的应用非常有用。
数据集成和流数据处理：Flink CDC 可以捕获不同数据源中的变化，并将其转化为流数据进行实时处理。这为数据集成、变换和处理提供了一个强大的工具，使得企业可以更高效地利用和组织分散在不同数据源中的数据。
增量更新索引和搜索引擎：Flink CDC 可以捕获关系数据库中的变化，并将这些变化应用于搜索引擎或索引系统，以保持索引和数据的同步更新。这对于实时搜索、内容检索和全文搜索等场景非常有用。

总之，Flink CDC 提供了将数据源中的变更实时捕获到流处理作业中的能力，使得企业可以实时地处理和响应数据变化。这为实时分析、实时ETL、反应式应用程序等多个场景提供了强大的支持。

上手体验

依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.airtu</groupId>
  <artifactId>airtu-cdc</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
   <flink-version>1.17.0</flink-version>
  </properties>

  <dependencies>

    <!--        flink connector 基础包-->
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-connector-base</artifactId>
      <version>${flink-version}</version>
    </dependency>

    <!--        CDC mysql 源-->
    <dependency>
      <groupId>com.ververica</groupId>
      <artifactId>flink-sql-connector-mysql-cdc</artifactId>
      <version>2.4.2</version>
    </dependency>

    <!--        Flink Steam流处理-->
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-streaming-java</artifactId>
      <version>${flink-version}</version>
    </dependency>

    <!--        flink java客户端-->
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-clients</artifactId>
      <version>${flink-version}</version>
    </dependency>

    <!--        开启webui支持，默认是8081，默认没有开启-->
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-runtime-web</artifactId>
      <version>${flink-version}</version>
    </dependency>

    <!--        Flink Table API和SQL API使得在Flink中进行数据处理变得更加简单和高效
    通过使用Table API和SQL API，可以像使用传统的关系型数据库一样，通过编写SQL语句或者使用类似于
    Java的API进行数据处理和分析-->
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-table-runtime</artifactId>
      <version>${flink-version}</version>
    </dependency>

    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.2.11</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>2.0.6</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.75</version>
    </dependency>

    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-core</artifactId>
      <version>5.8.23</version>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <version>3.3.0</version>
        <configuration>
          <archive>
            <manifest>
              <addClasspath>true</addClasspath>
              <classpathPrefix>lib/</classpathPrefix>
              <mainClass>com.airtu.saas.FlinkCDC</mainClass>
            </manifest>
          </archive>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <source>8</source>
          <target>8</target>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <version>3.6.0</version>
        <executions>
          <execution>
            <id>copy-dependencies</id>
            <phase>package</phase>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <outputDirectory>${project.build.directory}/lib</outputDirectory>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

</project>

定义原始数据解析器

该类是将原始的JSON数据，挑选出有用的部分组装成信息的JSON

package com.airtu.saas;

import com.alibaba.fastjson.JSONObject;
import com.ververica.cdc.connectors.shaded.org.apache.kafka.connect.data.Field;
import com.ververica.cdc.connectors.shaded.org.apache.kafka.connect.data.Struct;
import com.ververica.cdc.connectors.shaded.org.apache.kafka.connect.source.SourceRecord;
import com.ververica.cdc.debezium.DebeziumDeserializationSchema;
import org.apache.flink.api.common.typeinfo.BasicTypeInfo;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.util.Collector;

public class CommonStringDebeziumDeserializationSchema implements DebeziumDeserializationSchema<String> {

    private String host;
    private int port;
    
    public CommonStringDebeziumDeserializationSchema(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void deserialize(SourceRecord record, Collector<String> out){

        //打印原始的数据
        System.out.println(record);

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("host",host);
        jsonObject.put("port",port);
        jsonObject.put("file", record.sourceOffset().get("file"));
        jsonObject.put("pos", record.sourceOffset().get("pos"));
        jsonObject.put("ts_sec", record.sourceOffset().get("ts_sec"));

        String[] name = record.valueSchema().name().split("\\.");
        jsonObject.put("db", name[1]);
        jsonObject.put("table", name[2]);

        Struct value = ((Struct) record.value());
        String operatorType = value.getString("op");
        jsonObject.put("operator_type", operatorType);

        // insert update
        if (!"d".equals(operatorType)) {
            Struct after = value.getStruct("after");
            jsonObject.put("after", parseRecord(after));
        }
        // update & delete
        if ("u".equals(operatorType) || "d".equals(operatorType)) {
            Struct source = value.getStruct("before");
            jsonObject.put("before", parseRecord(source));
        }
        jsonObject.put("parse_time", System.currentTimeMillis() / 1000);

        out.collect(jsonObject.toString());
    }

    private JSONObject parseRecord(Struct after) {
        JSONObject jsonObject = new JSONObject();
        for (Field field : after.schema().fields()) {
            Object o = after.get(field.name());
            jsonObject.put(field.name(),o);
        }

        return jsonObject;
    }

    public TypeInformation<String> getProducedType() {
        return BasicTypeInfo.STRING_TYPE_INFO;
    }
}

测试代码

package com.airtu.saas;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.ververica.cdc.connectors.mysql.MySqlSource;
import com.ververica.cdc.connectors.mysql.table.StartupOptions;
import com.ververica.cdc.debezium.DebeziumSourceFunction;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.configuration.RestOptions;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Properties;


public class FlinkCDC {

    public static void main(String[] args) throws Exception {

        //启动webui，绑定本地web-ui端口号
        Configuration configuration=new Configuration();
        configuration.setInteger(RestOptions.PORT,8081);

        //获取配置文件
        Properties properties = new Properties();
        String currentDir = System.getProperty("user.dir");
        String configFilePath = currentDir + File.separator + "application.properties";
        File file = new File(configFilePath);
        if (!file.exists()){
            ClassLoader classLoader = FlinkCDC.class.getClassLoader();
            URL resourceUrl = classLoader.getResource("application.properties");
            configFilePath = resourceUrl.getPath();
        }

        System.out.println("配置文件：" + configFilePath);
        try (FileInputStream configFile = new FileInputStream(configFilePath)) {
            properties.load(configFile);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        Object syncTime = properties.get("syncTime");
        DateTime dateTime = DateUtil.parse((String) syncTime, "yyyy-MM-dd HH:mm:ss");

        //获取Flink 执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(configuration);
        env.setParallelism(1);//设置并行度为1


        //通过FlinkCDC构建SourceFunction
        DebeziumSourceFunction<String> sourceFunction = MySqlSource.<String>builder()
                .hostname("192.168.0.215")
                .port(33306)
                .username("root")
                .password("123456")
                .databaseList("test2")
                .tableList("test2.tb_user")
                .deserializer(new CommonStringDebeziumDeserializationSchema("192.168.0.215",33306)) //设置序列化器
                .startupOptions(StartupOptions.timestamp(dateTime.getTime())) //可以选择从头开始、最新的、指定时间戳位置
                .build();
        DataStreamSource<String> dataStreamSource = env.addSource(sourceFunction);

        dataStreamSource.addSink(new RichSinkFunction<String>() {
            @Override
            public void invoke(String value, Context context) throws Exception {

                //打印出重新组装的JSON数据
                System.out.println("json->: "+value);
                super.invoke(value, context);
            }
        });

        //启动任务
        env.execute("FlinkCDC");

    }

}

application.properties

syncTime=2023-12-22 14:00:00

执行结果

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See https://www.slf4j.org/codes.html#noProviders for further details.
SLF4J: Class path contains SLF4J bindings targeting slf4j-api versions 1.7.x or earlier.
SLF4J: Ignoring binding found at [jar:file:/Users/applemima1234/Desktop/a/lib/logback-classic-1.2.11.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See https://www.slf4j.org/codes.html#ignoredBindings for an explanation.
配置文件：/Users/applemima1234/Desktop/a/application.properties
十二月 22, 2023 5:24:47 下午 com.github.shyiko.mysql.binlog.BinaryLogClient connect
警告: Binary log position adjusted from 0 to 4
十二月 22, 2023 5:24:47 下午 com.github.shyiko.mysql.binlog.BinaryLogClient connect
信息: Connected to 192.168.0.215:33306 at /4 (sid:5642, cid:62998)
SourceRecord{sourcePartition={server=mysql_binlog_source}, sourceOffset={transaction_id=null, ts_sec=1703228128, file=mysql-bin.000003, pos=8068, row=1, server_id=1, event=2}} ConnectRecord{topic='mysql_binlog_source.test2.tb_user', kafkaPartition=null, key=null, keySchema=null, value=Struct{after=Struct{name=oo,age=25},source=Struct{version=1.6.4.Final,connector=mysql,name=mysql_binlog_source,ts_ms=1703228128000,db=test2,table=tb_user,server_id=1,file=mysql-bin.000003,pos=8204,row=0},op=c,ts_ms=1703237088440}, valueSchema=Schema{mysql_binlog_source.test2.tb_user.Envelope:STRUCT}, timestamp=null, headers=ConnectHeaders(headers=)}
json->: {"ts_sec":1703228128,"file":"mysql-bin.000003","port":33306,"pos":8068,"parse_time":1703237088,"host":"192.168.0.215","after":{"name":"oo","age":25},"db":"test2","table":"tb_user","operator_type":"c"}

logstash和filebeat使用

Tue, 05 Dec 2023 00:00:00 +0000

应用场景、组件介绍、logstash启动、filebeat启动

应用场景

分布式场景中，不同服务器的服务日志集中收集管理，方便排查问题

组件介绍

logstash

日志收集器，将接受到的日志存储到ES中

fielbeat

日志解析器，将日志解析后通过网络发送给日志收集器

logstash启动

下载

https://www.elastic.co/cn/downloads/past-releases/logstash-7-17-15

修改配置文件

编辑logstash.conf

input {
  beats {
    port => 5044
  }
}
filter {
      mutate {
        rename => { "@tags" => "channel" }
      }
        ruby {
                code => "event.set('timestamp', event.get('@timestamp').time.localtime + 8*60*60)"
        }
        ruby {
                code => "event.set('@timestamp',event.get('timestamp'))"
        }
        mutate {
                remove_field => ["timestamp"]
        }
 
    }
output {
  elasticsearch {
    hosts => ["http://localhost:9200"]
    index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
    #user => "elastic"
    #password => "changeme"
  }
}

启动

./bin/logstash -f ./config/logstash.conf

filebeat启动

下载

https://www.elastic.co/cn/downloads/past-releases/filebeat-7-17-15

修改配置文件

修改filebeat.yml

filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /opt/javaService/filebeat-7.17.15-linux-x86_64/logs/*.log
  fields:
    type: test
  fields_under_root: true


output.logstash:
  hosts: ["localhost:5044"]

配置项含义

filebeat.inputs：Filebeat输入配置的起始标记。

type: log：指定输入类型为日志文件类型，这告诉Filebeat将读取指定路径下的日志文件。

tail_files: true：设置为true，使得Filebeat在读取日志文件时跟随文件尾部的新内容。

backoff: "1s"：在出现错误时重试读取文件的时间间隔。

paths：设置要监控的日志文件路径。示例中的配置分别指定了/var/logs/applog/*.txt和/var/logs/appjson/*.json路径下的文件。

fields：为读取的每个事件添加自定义字段，这里设置了一个名为"type"的字段，并为每个输入类型分别设置为"apptxt"和"appjson"。

fields_under_root: true：将所有自定义字段放置在根级别而非在fields下。这样做可以使得自定义字段在Elasticsearch中更容易进行检索和处理。

multiline.pattern: '^[[:space:]]'：设置正则表达式模式，用于匹配日志文件中新的一行。这里的模式是以空白字符开头的行。

multiline.negate: false：设置是否对匹配的行进行取反操作。在这里，设置为false，意味着只有匹配模式的行才会进行合并。

multiline.match: after：指定多行日志合并的方式。在这里，设置为"after"，表示合并匹配行之后的内容。也就是说，将匹配行的下一行以及后续的行与该行合并为一条完整的事件。

通过以上配置，Filebeat将监控指定路径下的.txt和.json文件，并读取它们的内容。每读取一行日志，Filebeat会将其发送到指定的输出（可在配置文件中定义），并添加自定义字段以供后续处理和索引。

启动

./filebeat -e -c filebeat.yml

canal使用

Thu, 10 Aug 2023 00:00:00 +0000

工作原理、mysql开启二进制日志、启动服务端、启动客户端

工作原理

canal 模拟 MySQL slave 的交互协议，伪装自己为 MySQL slave ，向 MySQL master 发送dump 协议
MySQL master 收到 dump 请求，开始推送 binary log 给 slave (即 canal )
canal 解析 binary log 对象(原始为 byte 流)

mysql开启二进制日志

1）定义docker-compose.yml文件

version: '3'
services:
  master:
    image: mysql:8.0.28
    container_name: mysql-master
    ports:
    - '33306:3306'
    restart: always
    hostname: mysql-master
    environment:
      MYSQL_ROOT_PASSWORD: "123456"
      ADMIN_USER: "root"
      ADMIN_PASSWORD: "123456"
      TZ: "Asia/Shanghai"
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: 1
    healthcheck:
      test: ["CMD","mysqladmin","-uroot","-p$${MYSQL_ROOT_PASSWORD}","ping","-h","localhost"]
      timeout: 2s
      interval: 10s
      retries: 5
      start_period: 5s
    logging:
      options:
        max-file: '1'
        max-size: '128k'
    command:
    -  "--server-id=1"
    -  "--character-set-server=utf8mb4"
    -  "--collation-server=utf8mb4_unicode_ci"
    -  "--log-bin=mysql-bin"
    -  "--sync_binlog=1"
    -  "--binlog-ignore-db=mysql"
    -  "--binlog-ignore-db=sys"
    -  "--binlog-ignore-db=performance_schema"
    -  "--binlog-ignore-db=information_schema"
    -  "--sql_mode=NO_AUTO_VALUE_ON_ZERO,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION,PIPES_AS_CONCAT,ANSI_QUOTES"
    volumes:
    - ./data:/var/lib/mysql

2）查看状态

SHOW MASTER STATUS;
show variables like '%log_bin%';

3）创建用户

CREATE USER 'repl'@'%' IDENTIFIED BY '123456';

GRANT ALL PRIVILEGES ON *.* TO 'repl'@'%' WITH GRANT OPTION;

FLUSH PRIVILEGES;

其他知识点

主从复制需要在从库配置文件中写入以下配置

MASTER_SYNC_USER: “root” #设置脚本中定义的用于同步的账号

MASTER_SYNC_PASSWORD: “123456” #设置脚本中定义的用于同步的密码

ALLOW_HOST: “10.10.%.%” #允许同步账号的host地址

启动canal服务端

1）下载并解压

https://github.com/alibaba/canal/releases/tag/canal-1.1.7

2）修改配置文件

vi conf/example/instance.properties

## mysql serverId
canal.instance.mysql.slaveId = 1234
#position info，需要改成自己的数据库信息
canal.instance.master.address = 127.0.0.1:3306 
canal.instance.master.journal.name = 
canal.instance.master.position = 
canal.instance.master.timestamp = 
#canal.instance.standby.address = 
#canal.instance.standby.journal.name =
#canal.instance.standby.position = 
#canal.instance.standby.timestamp = 
#username/password，需要改成自己的数据库信息
canal.instance.dbUsername = canal  
canal.instance.dbPassword = canal
canal.instance.defaultDatabaseName =
canal.instance.connectionCharset = UTF-8
#table regex
canal.instance.filter.regex = .\*\\\\..\*

3）启动

sh bin/startup.sh

启动客户端

1）引入依赖

<dependency>
	<groupId>com.alibaba.otter</groupId>
	<artifactId>canal.client</artifactId>
	<version>1.1.0</version>
</dependency>

2）客户端代码

package com.example.test;
import java.net.InetSocketAddress;
import java.util.List;


import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.common.utils.AddressUtils;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.protocol.CanalEntry.Column;
import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
import com.alibaba.otter.canal.protocol.CanalEntry.RowData;

public class SimpleCanalClientExample {

    public static void main(String args[]) {
        // 创建链接
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.0.215",
                11111), "example", "", "");
        int batchSize = 1000;

        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            while (true) {
                Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                    }
                } else {
                    // System.out.printf("message[batchId=%s,size=%s] \n", batchId, size);
                    printEntry(message.getEntries());
                }

                connector.ack(batchId); // 提交确认
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }

        } finally {
            connector.disconnect();
        }
    }

    private static void printEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
                continue;
            }

            RowChange rowChage = null;
            try {
                rowChage = RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
                        e);
            }

            EventType eventType = rowChage.getEventType();
            System.out.println(String.format("================&gt; binlog[%s:%s] , name[%s,%s] , eventType : %s",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                    eventType));

            for (RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == EventType.DELETE) {
                    //删除数据
                    printColumn(rowData.getBeforeColumnsList());
                } else if (eventType == EventType.INSERT) {
                    //新增数据
                    printColumn(rowData.getAfterColumnsList());
                } else {
                    //更新数据
                    System.out.println("-------&gt; before");
                    printColumn(rowData.getBeforeColumnsList());
                    System.out.println("-------&gt; after");
                    printColumn(rowData.getAfterColumnsList());
                }
            }
        }
    }

    private static void printColumn(List<Column> columns) {
        for (Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }
}

springboot中使用es

Tue, 20 Jun 2023 00:00:00 +0000

依赖、配置、定义索引对象、操作、其他

依赖

<!-- Maven -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

配置

spring:
  elasticsearch:
    rest:
      uris: http://localhost:9200

定义索引对象

package vip.xiaonuo;


import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

@Data
@Document(indexName = "sysmenu")
public class SysMenuEs {

    @Id
    private String id;

    /** 父id */
    @Field(store = true, type = FieldType.Keyword)
    private String parentId;

    /** 标题 */
    @Field(store = true, type = FieldType.Keyword)
    private String title;

    /** 别名 */
    @Field(store = true, type = FieldType.Keyword)
    private String name;

    /** 编码 */
    @Field(store = true, type = FieldType.Keyword)
    private String code;

    /** 分类 */
    @Field(store = true, type = FieldType.Keyword)
    private String category;

    /** 模块 */
    @Field(store = true, type = FieldType.Keyword)
    private String module;

    /** 菜单类型 */
    @Field(store = true, type = FieldType.Keyword)
    private String menuType;

    /** 路径 */
    @Field(store = true, type = FieldType.Keyword)
    private String path;

    /** 组件 */
    @Field(store = true, type = FieldType.Keyword)
    private String component;

    /** 图标 */
    @Field(store = true, type = FieldType.Keyword)
    private String icon;

    /** 颜色 */
    @Field(store = true, type = FieldType.Keyword)
    private String color;

    /** 是否可见 */
    @Field(store = true, type = FieldType.Keyword)
    private String visible;

    /** 排序码 */
    @Field(store = true, type = FieldType.Integer)
    private Integer sortCode;

    /** 扩展信息 */
    @Field(store = true, type = FieldType.Keyword)
    private String extJson;
}

定义mapper

package vip.xiaonuo.mapper;

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import vip.xiaonuo.entitiy.SysMenuEs;

public interface SysMenuEsMapper extends ElasticsearchRepository<SysMenuEs,String> {
}

操作

package vip.xiaonuo;

import cn.hutool.core.bean.BeanUtil;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.Criteria;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.test.context.junit4.SpringRunner;
import vip.xiaonuo.entitiy.SysMenuEsMapper;
import vip.xiaonuo.sys.modular.resource.entity.SysMenu;
import vip.xiaonuo.sys.modular.resource.service.SysMenuService;

import java.util.List;
import java.util.stream.Collectors;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class MainTest {

    @Autowired
    SysMenuService sysMenuService;

    @Autowired
    SysMenuEsMapper sysMenuEsMapper;

    @Autowired
    private ElasticsearchOperations elasticsearchOperations;

    @Test
    public void test() {
        List<SysMenu> list = sysMenuService.list();
        for (SysMenu sysMenu : list) {
            SysMenuEs sysMenuEs = new SysMenuEs();
            BeanUtil.copyProperties(sysMenu,sysMenuEs);

            //新增
            sysMenuEsMapper.save(sysMenuEs);
        }
    }


    @Test
    public void test1(){
        //查询

        Sort sort = Sort.by("sortCode").ascending();
        Pageable pageable = PageRequest.of(1,10,sort);

        Criteria criteria = new Criteria("title").contains("管理")
                .and("sortCode").lessThan(60);

        Query query = new CriteriaQuery(criteria,pageable);
        SearchHits<SysMenuEs> searchHits = elasticsearchOperations.search(query, SysMenuEs.class);
        List<SearchHit<SysMenuEs>> searchHitList = searchHits.getSearchHits();
        List<SysMenuEs> sysMenuEsList = searchHitList.stream().map(SearchHit::getContent).collect(Collectors.toList());
        System.out.println(sysMenuEsList);
    }
}

其他

在 Elasticsearch 中，fuzzy、matches 和 contains 是不同的查询操作符，它们用于在搜索中进行模糊匹配和字符串查询。

Fuzzy（模糊匹配）： fuzzy() 方法用于在查询时进行模糊匹配，即在搜索时考虑词项的拼写错误。该方法接受一个 String 参数作为搜索词项，并默认进行最大编辑距离为2的模糊匹配查询。

例如：criteria.fuzzy("fieldName").value("apple").boost(1.0f) 将会在 "fieldName" 字段内搜索与 "apple" 类似的词项，允许最大编辑距离为 2，同时可以通过 boost() 方法设置查询的权重。

Matches（匹配）： matches() 方法用于进行全文匹配查询，可以匹配词项的全文内容。该方法接受一个 String 参数作为搜索词项，并会对该词项进行全文匹配。

例如：criteria.matches("fieldName").value("apple").boost(1.0f) 将会在 "fieldName" 字段内搜索与 "apple" 完全匹配的词项，并可以通过 boost() 方法设置查询的权重。

Contains（包含）： contains() 方法用于检查字段是否包含指定的子字符串。该方法接受一个 String 参数作为子字符串，并会在字段中进行部分匹配。

例如：criteria.contains("fieldName").value("apple").boost(1.0f) 将会在 "fieldName" 字段内搜索包含子字符串 "apple" 的词项，并可以通过 boost() 方法设置查询的权重。

总结来说，fuzzy 是一种模糊匹配的查询方式，允许拼写错误，而 matches 和 contains 则是对词项进行全文或部分匹配的查询方式。你可以根据具体的查询需求和数据特点选择合适的查询操作符。

elasticsearch使用

Thu, 11 May 2023 00:00:00 +0000

索引操作、数据操作

索引操作

索引的创建、删除等

创建索引

PUT /shopping

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "shopping"
}

获取索引详细信息

GET /_cat/indices?v

health status index                           uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   shopping                        Hv0juGrISIaJ__RszyAHJA   1   1          0            0       283b           283b

删除索引

DELETE /shopping

数据操作

添加数据

POST /shopping/_doc
{
	"title":"小米手机",
	"category":"小米",
	"price":3999.00
}

指定id添加数据

POST /shopping/_doc/100
{
	"title":"小米手机",
	"category":"小米",
	"price":3999.00
}

PUT /shopping/_doc/101
{
	"title":"小米手机",
	"category":"小米",
	"price":3999.00
}

POST /shopping/_create/102
{
	"title":"小米手机",
	"category":"小米",
	"price":3999.00
}

查询1条数据

GET /shopping/_doc/102

查看所有数据

GET /shopping/search

局部更新数据

POST /shopping/_update/102
{
	"doc":{
		"title":"华为手机"
	}
}

删除1条数据

DELETE /shopping/_doc/102

条件查询

1）指定字段分页查询并排序

GET /shopping/_search
{"query": {
    "match": {
        "title":"小米"
    }
 },
 "_source": "title", 
 "from": 0,
 "size":1,
 "sort": [
   {
     "price": {
       "order": "desc"
     }
   }
 ]
}

{
  "took" : 17,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 3,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "shopping",
        "_type" : "_doc",
        "_id" : "qLmnhYgBDnKcjmGSyRGG",
        "_score" : null,
        "_source" : {
          "title" : "小米手机"
        },
        "sort" : [
          3999.0
        ]
      }
    ]
  }
}

2）多条件查询

GET /shopping/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "category": "小米"
          }
        },
        {
          "match": {
            "price": 3999
          }
        }
      ],
      "filter": {
        "range": {
          "price": {
            "gt": 1000
          }
        }
      }
    }
  }
}

must相当于and，should相当于or

{
  "took" : 13,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : 1.1740228,
    "hits" : [
      {
        "_index" : "shopping",
        "_type" : "_doc",
        "_id" : "qLmnhYgBDnKcjmGSyRGG",
        "_score" : 1.1740228,
        "_source" : {
          "title" : "小米手机",
          "category" : "小米",
          "price" : 3999.0
        }
      },
      {
        "_index" : "shopping",
        "_type" : "_doc",
        "_id" : "100",
        "_score" : 1.1740228,
        "_source" : {
          "title" : "小米手机",
          "category" : "小米",
          "price" : 3999.0
        }
      },
      {
        "_index" : "shopping",
        "_type" : "_doc",
        "_id" : "101",
        "_score" : 1.1740228,
        "_source" : {
          "title" : "小米手机",
          "category" : "小米",
          "price" : 3999.0
        }
      },
      {
        "_index" : "shopping",
        "_type" : "_doc",
        "_id" : "102",
        "_score" : 1.1740228,
        "_source" : {
          "title" : "华为手机",
          "category" : "小米",
          "price" : 3999.0
        }
      }
    ]
  }
}

3）完全匹配

GET /shopping/_search
{
  "query": {
    "match_phrase": {
      "title": "小米"
    }
  }
}

skywalking基本使用

Wed, 03 May 2023 00:00:00 +0000

服务探针配置、服务安装

服务配置探针

无侵入配置

1.下载agent并解压

skywalking-agent
├── LICENSE
├── NOTICE
├── activations
├── bootstrap-plugins
├── config
├── licenses
├── logs
├── optional-plugins
├── optional-reporter-plugins
├── plugins
└── skywalking-agent.jar

2.vm参数中修改

-javaagent:C:\Users\zhanghuan\Desktop\practice\skywalking\skywalking-agent2\skywalking-agent.jar
-DSW_AGENT_NAME=auth
-DSW_AGENT_COLLECTOR_BACKEND_SERVICES=127.0.0.1:11800

注意：每个服务和agent一一对应，不能多个服务共用agent

3.配置日志服务

选配，配置后会将应用程序的日志通过grpc发送给OAP服务

1）依赖

        <dependency>
            <groupId>org.apache.skywalking</groupId>
            <artifactId>apm-toolkit-logback-1.x</artifactId>
            <version>8.5.0</version>
        </dependency>

2）修改logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <!-- 日志存放路径 -->
	<property name="log.path" value="logs/ruoyi-system" />
   <!-- 日志输出格式 -->
	<property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />

    <!-- 控制台输出 -->
	<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
	</appender>

    <!-- 系统日志输出 -->
	<appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
	    <file>${log.path}/info.log</file>
        <!-- 循环政策：基于时间创建日志文件 -->
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志文件名格式 -->
			<fileNamePattern>${log.path}/info.%d{yyyy-MM-dd}.log</fileNamePattern>
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
		</rollingPolicy>
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
		<filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 -->
            <level>INFO</level>
            <!-- 匹配时的操作：接收（记录） -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作：拒绝（不记录） -->
            <onMismatch>DENY</onMismatch>
        </filter>
	</appender>

    <appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
	    <file>${log.path}/error.log</file>
        <!-- 循环政策：基于时间创建日志文件 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志文件名格式 -->
            <fileNamePattern>${log.path}/error.%d{yyyy-MM-dd}.log</fileNamePattern>
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 -->
            <level>ERROR</level>
			<!-- 匹配时的操作：接收（记录） -->
            <onMatch>ACCEPT</onMatch>
			<!-- 不匹配时的操作：拒绝（不记录） -->
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 发送给OAP服务  -->
    <appender name="grpc-log" class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.log.GRPCLogClientAppender">
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.mdc.TraceIdMDCPatternLogbackLayout">
                <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{tid}] [%thread] %-5level %logger{36} -%msg%n</Pattern>
            </layout>
        </encoder>
    </appender>

    <!-- 系统模块日志级别控制  -->
	<logger name="com.ruoyi" level="info" />
	<!-- Spring日志级别控制  -->
	<logger name="org.springframework" level="warn" />

	<root level="info">
    <!-- 发送给OAP服务  -->
        <appender-ref ref="grpc-log"/>
		<appender-ref ref="console" />
	</root>

	<!--系统操作日志-->
    <root level="info">
        <appender-ref ref="file_info" />
        <appender-ref ref="file_error" />
    </root>
</configuration>

安装服务

1.下载apache-skywalking-apm-bin安装包

apache-skywalking-apm-bin
├── LICENSE
├── LICENSE.tpl
├── NOTICE
├── README.txt
├── bin
├── config
├── config-examples
├── licenses
├── logs
├── oap-libs
├── tools
└── webapp

2.配置服务的数据库

修改apache-skywalking-apm-bin\config\application.yml

storage:
  selector: ${SW_STORAGE:mysql}
  mysql:
    properties:
      jdbcUrl: ${SW_JDBC_URL:"jdbc:mysql://localhost:3307/sw?rewriteBatchedStatements=true"}
      dataSource.user: ${SW_DATA_SOURCE_USER:root}
      dataSource.password: ${SW_DATA_SOURCE_PASSWORD:123456}

3.启动

运行bin目录下startup

ruby入门

Fri, 02 Dec 2022 00:00:00 +0000

第一个程序、定义类、打印方法、判断是否有方法属性、放开属性、数组、注释、字符串操作、字典、类型转换、静态方法、继承、模块、流程控制、循环、异常处理

第一个程序

def sayHello
    puts 'hello word'
end

sayHello

定义类

# 类名第一个字母必须大写
class Player
    def initialize(name = "zhanghuan")
        @name = name
    end
    def show()
        puts "hello,#{@name}"
    end
end

p = Player.new()
p.show()

打印方法

puts Player.instance_methods(false)

判断是否有方法、属性

if p.respond_to?("show")
    p.send("show")
end

放开属性

class Game
    attr_accessor :price,:title #开放属性，外部可以访问
    def initialize(title = "game1", price = 200)
        @title = title
        @price = price
    end
    def show()
        puts "标题：#{@title}"
        puts "价格：#{@price}"
    end
end

g = Game.new()

puts g.title #可访问

g.title = "game2"

puts g.title #可修改

数组

games = ["绝地求生","怪物猎人","埃尔登法环"]

# 输出
puts games

# 遍历
games.each do |game|
    puts "我爱 #{game}"
end

games.each_with_index do |game,i|
    puts "我爱 #{i} #{game}"
end

# 连接
puts games.join(",")

# 判断是否是数组
puts games.respond_to?("each")

注释

# 行注释

=begin
多行注释
=end

__END__
结束语

字符串操作

a = "hello"
b = "word"

# 字符串带入，相当于a = a + b
a << b
puts a

# 字符串重复
puts a * 4 

# 单引号和双引号的区别和shell脚本类似

字典

dic1={
    "a":1,
    "b":2
}

dic2={
    name:"zhanghuan",
    age:"20"
}
puts dic1[:a]
puts dic2[:name]

类型转换

a = "1"
b = "2"
c = "3"

puts a + b + c
# 字符串转数字
puts a.to_i + b.to_i + c.to_i
# 数字转字符串
puts (a.to_i + b.to_i + c.to_i).to_s + "AAA"

静态方法

class Game
    def initialize(name = "zhanghuan")
        @name = name
    end
    def show()
        puts @name.to_s
    end
    # 定义静态方法
    def self.toStr()
        puts "aaaaaa"
    end
end

game = Game.new()
game.show()
# game.toStr() 不可以这样写，因为实例hi无法调用静态方法的

Game.toStr()
Game::toStr()

继承

class SteamGame < Game
    def info
        puts "G胖"
    end
end

game = SteamGame.new()
game.info()

模块

module BaseFunc
    Version = "1.0"
    def v
        return Version
    end
    def add(a,b)
        return a + b
    end
    def self.showVersion
        return Version 
    end
    # 定义静态方法
    module_function :v
end

puts BaseFunc.v
puts BaseFunc.showVersion
puts BaseFunc::Version
# BaseFunc.add(10,20) 不可用


class BaseClass include BaseFunc
end

# 类包含模块后，模块中的方法不可直接用，要实例化后才可用
#puts BasClass.v 不可用
#puts BasClass::showVersion 不可用
puts BaseClass::Version

myCls = BaseClass.new
puts myCls.add(10,20)
# puts myCls.v 不可用

流程控制

point_per_game = 30

if point_per_game >= 30
    puts "3500万美元年薪"
elsif point_per_game >= 20
    puts "2500万美元年薪"
else
    puts "1500万美元年薪"
end

case point_per_game
    when 30
        puts "正好30"
    when 20
        puts "正好20"
    else
        puts "??"
    end

循环

languages = ["java","python","ruby"]

for item in languages do
    puts item
end

languages.each{
    |item|
    puts item
}

languages.each_with_index do |item,i|
    puts i.to_s + "." + item
end

# times循环
5.times do |i|
    puts i
end

# step循环
1.step(10,2) do |i|
    puts i
end

# upto
2.upto(5) do |i|
    puts i
end

# downto
5.downto(2) do |i|
    puts i
end

# 包含5
for i in 1..5 do
    puts i
end

# 不包含5
for i in 1...5 do
    puts i
end

index = 0
while index < 5 do
    puts index
    index += 1
end

index = 0
until index == 5 do
    puts index
    index += 1
end

异常处理

begin #try
    a = 1/0
rescue => e #catch
    puts e
else # 鸡肋
    puts "正常处理"
ensure # finally
    puts "扫尾"
end

ruby基础

Tue, 22 Nov 2022 00:00:00 +0000

目录服务、目录书概念、LDAP、docker-compose方式安装、springboot中访问

目录服务

1）目录服务是一个特殊的数据库.用来保存描述性的、基于属性的详细信息，支持过滤功能。 2）是动态的，灵活的，易扩展的。如：人员组织管理，电话箱，地址簿。

目录树概念

1）目录树：在一个目录服务系统中，整个目录信息集可以表示为一个目录信息树，树中的每个节点是一个条目。 2）条目：每个条目就是一条记录，每个条目有自己的唯一可区别的名称(DN)。 3）对象类：与某个实体类型对应的一组屈性，对象类是可以继承的，这样父类的必须属性也会被继承下来。 4.属性：描述条目的某个方面的信息。一个属性由一个属性类型和一个或多个属性值组成，属性有必须属性和非必须属性。

LDAP

LDAP (Light Directory Access Portocol),它是基于X.50O标准的轻录级目录访问协议. 目录是一个为查询、测览和搜索而优化的数据库，它成树状结构组织数据，类以文件目录一样。目录数据库和关系数据库不同，它有优异的读性能.但写性能差，并且没有事务处理、回滚等复杂功能，不适于存储修改频繁的数据。所以目录天生是用来查询的就好象它的名字一样。 LDAP目录服务是由目录数据库和一套访问协议组成的系统。

关键词	英文简称	含义
uid	User ld	用户ID songtao.xu(一条记录的lD)
ou	Organization Unit	组织单位，组织单位可以包含其他各种对象（包括其他组织单元）
cn	Common Name	公共名称，如Thomas Johansson(一条记录的名称)
sn	Surname	姓，如“许”
dn	Distinguished Name	“uid=songtao.xu,ou=oa，dc=example,dc=com”,一条记录的位置（唯一）相对辨别名，类似于文件系统中的相对路径，它是与目录树结构无关的部分，

docker-compose方式安装

version: "3"
services:
  # 1.安装openldap
  openldap:
    container_name: openldap
    image: osixia/openldap:1.4.0
    restart: always
    environment:
      LDAP_ORGANISATION: "test openldap"
      LDAP_DOMAIN: "koal.com"
      LDAP_ADMIN_PASSWORD: "12345678"
      LDAP_CONFIG_PASSWORD: "12345678"
    volumes:
      - /data/openldap/data:/var/lib/ldap
      - /data/openldap/config:/etc/ldap/slapd.d
    ports:
      - '389:389'
  # 2.安装phpldapadmin
  phpldapadmin:
    container_name: phpldapadmin
    image: osixia/phpldapadmin:latest
    restart: always
    environment:
      PHPLDAPADMIN_HTTPS: "false"
      PHPLDAPADMIN_LDAP_HOSTS: openldap
    ports:
      - '30004:80'
    depends_on:
      - openldap
      # cn=admin,dc=test,dc=com 密码：123456

springboot中访问

1）依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-ldap</artifactId>
</dependency>

2）配置

这里从数据库中取，也可以从配置变量中取

import cn.hutool.json.JSONObject;
import com.koal.modules.sys.service.SysConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.core.support.LdapContextSource;

import java.util.HashMap;
import java.util.Map;

/**
 * LDAP 的自动配置类
 *
 * 完成连接 及LdapTemplate生成
 */
@Configuration
public class LdapConfiguration {

    @Autowired
    SysConfigService sysConfigService;

    @Bean
    public LdapContextSource getContextSource() {
        LdapContextSource contextSource = new LdapContextSource();
        Map<String, Object> config = new HashMap();

        String ldapConfString = sysConfigService.getValue("SYS_NORMAL_CONFIG_KEY");
        JSONObject ldapConf = new JSONObject(ldapConfString);

        contextSource.setUrl((String) ldapConf.getByPath("ldap.urls"));
        contextSource.setBase((String) ldapConf.getByPath("ldap.base"));
        contextSource.setUserDn( (String) ldapConf.getByPath("ldap.username"));
        contextSource.setPassword((String) ldapConf.getByPath("ldap.password"));

        //  解决 乱码 的关键一句
        config.put("java.naming.ldap.attributes.binary", "objectGUID");

        contextSource.setPooled(true);
        contextSource.setBaseEnvironmentProperties(config);
        return contextSource;
    }


    @Bean
    public LdapTemplate getLdapTemplate() {
        return new LdapTemplate(getContextSource());
    }

}

3）自定义实体类

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.ldap.odm.annotations.Attribute;
import org.springframework.ldap.odm.annotations.Entry;
import org.springframework.ldap.odm.annotations.Id;

import javax.naming.Name;
import java.util.List;

/**
 * @author sunjinchen
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entry(objectClasses = {"inetOrgPerson", "userSecurityInformation", "person"})
public class UserLdap {
    @Id
    @JsonIgnore
    private Name dn;
    /**
     * uid
     */
    private String uid;
    /**
     * 名
     */
    private String givenName;
    /**
     * 姓
     */
    private String sn;
    /**
     * 地区
     */
    private String street;
    /**
     * 部门
     */
    private String ou;
    /**
     * 组名（多个组，需要创建多个employeeType属性）
     */
    @Attribute(name="employeeType")
    private List<String> employeeType;

    @Attribute(name="objectClass")
    private List<String> objectClass;
    /**
     * 登录名
     */
    @Attribute(name="displayName")
    private String displayName;
    /**
     * 电子邮件
     */
    @Attribute(name="mail")
    private String mail;
    /**
     * 姓名
     */
    private String cn;
    /**
     * 状态 2000 - 正常 -1000 停用
     */
    private String st;
    /**
     * 岗位（编号）
     */
    private String businessCategory;
}

4）操作

package com.koal;

import com.koal.modules.ldap.entity.UserLdap;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.core.NameAwareAttribute;
import org.springframework.ldap.query.LdapQueryBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import javax.naming.InvalidNameException;
import javax.naming.Name;
import javax.naming.directory.DirContext;
import javax.naming.directory.ModificationItem;
import javax.naming.ldap.LdapName;
import java.util.ArrayList;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Test {
    @Autowired
    LdapTemplate ldapTemplate;

    /**
     * 查询
     */
    @org.junit.Test
    public void test1(){
        List<UserLdap> list= ldapTemplate.find(LdapQueryBuilder.query().where("displayName").like("zhanghuan"), UserLdap.class);
        System.out.println(list);
    }

    /**
     * 修改
     * @throws InvalidNameException
     */
    @org.junit.Test
    public void test2() throws InvalidNameException {
        Name name = new LdapName("cn=redmine, ou=KMISTR");
        ModificationItem[] modificationItems = new ModificationItem[1];
        NameAwareAttribute nameAwareAttribute = new NameAwareAttribute("employeeType");
        nameAwareAttribute.add("test");
        nameAwareAttribute.add("test1");
        modificationItems[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                nameAwareAttribute);

        ldapTemplate.modifyAttributes(name,modificationItems);
    }

    /**
     * 修改
     */
    @org.junit.Test
    public void test3(){
        List<UserLdap> list= ldapTemplate.find(LdapQueryBuilder.query().where("cn").is("redmine"),UserLdap.class);
        System.out.println(list);
        if(list.size()>0){
            UserLdap userLdap = list.get(0);
            List<String> employeeType = new ArrayList<>();
            employeeType.add("test000");
            userLdap.setEmployeeType(employeeType);
            ldapTemplate.update(userLdap);
        }
    }

    /**
     * 新增
     * @throws InvalidNameException
     */
    @org.junit.Test
    public void test4() throws InvalidNameException {
        UserLdap userLdap = new UserLdap();
        Name dn = new LdapName("cn=test,ou=KMISTR");
        userLdap.setSn("test");
        userLdap.setDn(dn);
        userLdap.setOu("KMISTR");
        ldapTemplate.create(userLdap);
    }

    /**
     * 删除
     * @throws InvalidNameException
     */
    @org.junit.Test
    public void test5() throws InvalidNameException {
        Name dn = new LdapName("cn=test,ou=KMISTR");
        UserLdap userLdap = ldapTemplate.findByDn(dn,UserLdap.class);
        ldapTemplate.delete(userLdap);
    }
}

张欢的博客

Rust入门

1.安装

2.猜数字游戏

3.编程概念

3.1 变量可变性

3.2数据类型

3.3函数

3.4流程控制

4.所有权

4.1 所有权规则

4.3 引用

4.4 切片

5.结构体

5.1 定义

5.2 方法语法

6.枚举

6.1 定义

6.2 方法

6.3 枚举Option

6.4 match

6.5 if let

7.自定义模块

8.集合

8.1 vector

8.2 HashMap

9.错误处理

9.1 立即终止配置

9.2 回溯环境变量

9.3 match匹配Result

9.4 unwrap和expect

9.5 函数中错误传播

10.泛型、特征和生命周期

10.1 泛型

10.2 特征

10.3 生命周期

11.自动化测试

12.命令行程序案例

13.闭包

13.1 定义闭包

13.2 转让所有权给闭包

13.3 排序

13.4 迭代器

14.智能指针

14.1 使用Box在堆上存储数据

14.2 自定义智能指针

14.3 drop使用

14.4 引用计数智能指针

14.5 内部可变指针

14.6 使用弱引用解决循环引用导致的内存泄漏问题

15.并发

15.1 多线程

15.2 与move一起使用

15.3 线程间数据共享

15.4 线程间状态共享

16.模式和匹配

16.1 if let

16.2 while let

16.3 if let

16.4 可反驳性

16.5 模式语法

17.高级特性

17.1 原始指针

17.2 不安全代码块中执行不安全方法

17.3 使用extern函数调用外部代码

17.4 C语言调用rust

17.5 修改静态变量

17.6 不安全trait

17.7 默认运算符重载

17.8 调用同名方法

17.9 trait继承

17.10 包装

17.13 函数指针

17.14 返回特征类型

18.多线程web服务器案例

18.1 定义线程池和线程

18.2 创建返回的html

18.3 在main方法中实现web服务器

c++基础

内存分区模型

14.1 使用`Box`在堆上存储数据

14.3 `drop`使用