ソフトウェアエンジニアの技術ブログ：Software engineer tech blog

thread::spawn関数で新規スレッドを生成する。

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

fn main(){
    let th = thread::spawn (|| {
        for _i in 1..10 {
            println!("A");
            thread::sleep(Duration::from_millis(500));
        }
    });
    th.join().unwrap();
    println!("Finished");
}

スレッドからスレッド外変数を参照するにはmoveを使用する。

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

fn main(){
    let str = String::from("ABC");
    let th = thread::spawn (move|| {
        for _i in 1..10 {
            println!("{}", str);
            thread::sleep(Duration::from_millis(100));
        }
    });
    th.join().unwrap();
    println!("Finished");
}

C/C++ で新しいスレッドを立ち上げる

#include <thread>
#include <cstdio>
#include <cstdint>

uint32_t end_flag_;
uint32_t msg_;

void ThreadA()
{
    int32_t input = 0;
    while(end_flag_){
        printf("数字を入力してください\n");
        printf("0...スレッドBにメッセージを送信します\n");
        printf("1...プロセスを終了します\n");
        scanf("%d", &input);

        switch(input){
            case 0:
                msg_ = 1;
                break;
            case 1:
                end_flag_ = 0;
                break;
            default:
                printf("0か1を入力してください。\n");
                break;
        }
    }
    printf("スレッドA終了\n");
}

void ThreadB()
{
    while(end_flag_){
        if(msg_){
            printf("スレッドAからメッセージを受信しました\n");
            msg_ = 0;
        }
    }
    printf("スレッドB終了\n");
}

int main() {
    msg_ = 0;
    end_flag_ = 1;

    std::thread th_a(ThreadA);
    std::thread th_b(ThreadB);

    th_a.join();
    th_b.join();

    return 0;
}

Rustで書いてみる

use std::thread;

fn main(){
    let mut msg_ : u32 = 0;
    let mut end_flag_ : u32 = 1;

    let thA = thread::spawn (move|| {
        while end_flag_ != 0 {
            println!("数字を入力してください");
            println!("1...スレッドBにメッセージを送信します");
            println!("2...プロセスを終了します");
            let mut word = String::new();
            std::io::stdin().read_line(&mut word).ok();
            let num: i32 = word.trim().parse().ok().unwrap();
            println!("入力値: {}", num);
            match num {
                1 => { msg_ = 1}
                2 => { end_flag_ = 0}
                _ => println!("0か1を入力してください"),
            }
        }
    });

    let thB = thread::spawn (move|| {
        while end_flag_ != 0 {
            if msg_ == 1 {
                println!("スレッドAからメッセージを受信しました。");
                msg_ = 0;
            }
        }
    });
    thA.join().unwrap();
    thB.join().unwrap();
}

スレッドは二つ立っているんだけど、moveで所有権が移転すると、変数msg_がもう読み込まれなくなる。なるほど、難しいね。

トレイトを実装するオブジェクトをイテレータと呼ぶ
イテレータとは、連続したオブジェクトを順番に取り扱うための機能を提供するオブジェクト

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    
    // methods with default implementations elided
}

イテレータにはmap、filter、collectなどのメソッドがある。

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

    while let Some(item) = iter.next() {
        println!("{}", item);
    }
}

struct Counter {
    max: u32,
    count: u32,
}

impl Counter {
    fn new(max: u32) -> Counter {
        Counter {max: max, count: 0}
    }
}

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<Self::Item>{
        self.count += 1;
        if self.count < self.max {
            Some(self.count)
        } else {
            None
        }
    }
}

fn main(){
    let counter = Counter::new(10);
    for c in counter {
        println!("{}", c);
    }
}

C++

#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<int>a = {1, 2, 3, 5};
    auto itr = find(a.begin(), a.end(), 3);

    if (itr == a.end()) {
        cout << "not found" << endl;
    } else {
        int idx = distance(a.begin(), itr);
        cout << "a[" << idx << "] =" << *itr << endl;
    }
}

fn main(){
    let a = vec![1, 2, 4, 6, 8];
    let mut iter = a.iter();

    let mut counter = 0;
    while let Some(item) = iter.next() {
        counter = counter + 1;
        if *item == 3 {
            println!("idx {}", counter);
            break;
        } 
        if counter == a.len() {
            println!("not found");
        }
    }
}

毎回、もうちょっと上手い書き方が絶対にあると思う。。

インプリメンテーションとは構造体にメソッドを追加するもの。Rustにクラスはない。

struct Rect { width: u32, height: u32}

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

fn main(){
    let r = Rect {width: 200, height: 300};
    println!("{}", r.area());
}

C++のclass

#include <iostream>
#include <string>

class Car {
    public:
        std::string owner;
        std::string color;
        int number;
};

auto main(void) -> int {
    auto a = Car();
    a.owner = "山田";
    a.color = "blue";
    a.number = 1234;
    std::cout << "a.owner =" << a.owner << ", a.color =" << a.color 
        << ", a.number =" << a.number << std::endl;
}

rustでimplを使ってclassを書く

struct Car { 
    owner: String, 
    color: String,
    number: u32,
}

impl Car {
    fn prnt(&self) {
        println!("{} {} {}", self.owner, self.color, self.number);
    }
}

fn main(){
    let c = Car {owner: "山田".to_string(), color: "blue".to_string(), number: 1234};
    c.prnt();
}

$ ./main
山田 blue 1234

なるほど〜

変数に保存したり、引数として他の関数に渡すことができる匿名関数。無名関数やラムダ式に似ている。

fn main(){
    let square = | x: i32 | {
        x * x
    };
    println!("{}", square(9));
}

moveでクロージャー外変数をクロージャー内に移動することができる。

fn main(){
    let msg = String::from("Hello");
    let func = move || {
        println!("{}", msg);
    };
    func();
}

#include <iostream>

auto func() {
    int x = 0;
    return [=]() mutable -> void {
        ++x;
        std::cout << x << std::endl;
    };
}

int main()
{
    auto f1 = func();
    f1();
    f1();
    f1();
    f1();

    auto f2 = func();
    f2();
    f2();
    f2();
    f2();
}

fn main(){
    let mut i = 0;
    let make_counter = | mut x:i32 | {
        i = x + 1;
        println!("{}", i);
    };

    make_counter(i);
    make_counter(i);
}

クロージャの中でグローバル変数は
3 | let make_counter = | mut x:i32 | {
| ————- `i` is borrowed here
4 | i = x + 1;
| – borrow occurs due to use of `i` in closure

fn main(){
    let mut i: i32 = 1;
    let make_counter = | mut x:i32 | {
        x = x + 1;
        println!("{}", x);
        return x;
    };

    i = make_counter(i);
    i = make_counter(i);
}

スマートな書き方ではありませんね。。
クロージャの値をうまく保持し続けたい時の書き方が知りたい。。

fn add(x: i32, y: i32) -> i32 {
    return x + y;
}

fn main(){
    let r = add(4, 7);
    println!("{}", r);
}

C++で関数を使って書いてみる

#include <iostream>
#include <stdio.h>
#include <string>
#include <map>

int total(std::map<std::string, int> &cart){
    int price = 0;
    for(auto i : cart){
        price = price + i.second;
    }
    std::cout << "※合計:　" << price << "円" << std::endl;
    return price;
}

int tax(int price) {
    int tax_price = price * 0.1;
    std::cout << "※税:　" << tax_price << "円" << std::endl;
    return tax_price;
}

void cashier(std::map<std::string, int> &cart) {
    for(auto i: cart) {
        std::cout << i.first << ": " << i.second << "円" << std::endl;
    }

    int price = total(cart);
    int tax_price = tax(price);
    
    std::cout << "お会計:　" << price + tax_price << "円" << std::endl;
}

int main()
{
    std::map<std::string, int> cart;

    cart["Crab mayoo"] = 2280;
    cart["Salad"] = 780;
    cart["Cola"] = 190;

    cashier(cart);
    
    return 0;
}

上記をRustで記述する。

use std::collections::HashMap;

fn total(cart :HashMap<&str, u32> )-> u32 {
    let mut price: u32 = 0;
    for (key, value) in cart.iter() {
        price = price + value;
        println!("{} : {}円", key, value);
    }
    println!("※合計 {}円", price);
    return price;
}

fn tax(price: u32) -> u32 {
    let tax: u32 = price / 10;
    println!("※税 {}円", tax);
    return tax;
}

fn cashier(cart :HashMap<&str, u32>) {
    let price: u32 = total(cart);
    let tax_price = tax(price);
    println!("合計 {}円", price + tax_price);
}

fn main(){
    let mut cart = HashMap::new();
    cart.insert("Crab mayoo", 2280);
    cart.insert("Salad", 780);
    cart.insert("Cola", 190);

    cashier(cart);
}

なるほど、u32 * floatはできないので、price * 0.1とするとエラーになる。
Rustは型指定が結構大変だなぁ

ヒープ領域とは、プログラム実行時に動的にメモリを割り当てるための領域
ヒープ領域は関数が終わっても存在することができ、所有者が居なくなった時点で解放される

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

fn main(){
    let p: Box<Point> = Box::new(Point {x:100, y:200});
    println!("{} {}", p.x, p.y);
}

new演算子、std::vectorはヒープ領域を使用している。

#include <iostream>
#include <limits>
#include <exception>

int main()
{
    std::cout << std::hex << std::numeric_limits<uintptr_t>::max() << std::end;

    try {
        char* temp= new char[std::numeric_limits<uintptr_t>::max()];
        std::cout << temp << "\n";
    }
    catch(std::bad_alloc& e){
        std::cout << e.what() << "\n";
    }

    return 0;
}

#include <iostream>
#include <limits>
#include <exception>

int main()
{
    int* array = new int[5];

    for(int i = 0; i < 5; ++i){
        array[i] = i*i;
    }

    delete[] array;
    array = nullptr;
    return 0;
}

いまいちboxの使い所と書き方がわかりませんな…