Category: Rust

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の使い所と書き方がわかりませんな…

Rustの基本的な文字列型は&strを使用する。

fn main(){
    let mut name: &str = "Yamada";

    println!("{}", name);

    name = "Tanaka";

    println!("{}", name);
}

ライブラリとして提供されている文字列にStringがある。

fn main(){
    let mut name = String::from("Yamada");

    name = "Tanaka".to_string();
    name.push_str(" Taro");
    println!("{}", name);
}

C++のchar型は1文字のみ

#include <stdio.h>

int main(void)
{
    char a = 'D';
    char b = 'N';
    char c = 'A';

    printf("%c%c%c\n", a, b, c);
    return 0;

}

複数文字は配列

#include <stdio.h>

int main(void)
{
    char str1[] = "DNA";

    printf("%s\n", str1);
    printf("%lu\n", sizeof(str1));

    return 0;

}

char型のポインタ

int main(void)
{
    const char* char_ptr = "DNA";

    printf("%s\n", char_ptr);

    return 0;

}

string型

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

int main(void)
{
    std::string str1 = "DNA";
    std::string str2 = "RNA";
    std::string str3 = str1 + str2;

    std::cout << str3 << std::endl;

    return 0;

}

fn main(){
    let s1 = String::from("ABC");
    let s2 = String::from("ABC");
    let s3 = String::from("XY");

    if(s1 == s2){
        println!("ABC == ABC");
    }
    if(s1 < s3) {
        println!("ABC < XY");
    }
}

String::fromが便利すぎる。。

ハッシュマップは文字列を添字に使用することができる。他の言語では連想配列と呼ばれる。

use std::collections::HashMap;

fn main(){
    let mut map = HashMap::new();
    map.insert("x", 10);
    map.insert("y", 20);
    map.insert("z", 30);

    println!("{} {} {}", map["x"], map["y"], map["z"]);

    for (k, v) in &map {
        println!("{} {}", k, v);
    }
}

C++

#include <iostream>
#include <map>
#include <string>

using namespace std;

int main()
{
    map<int, string> Players;

    Players.insert(std::pair<int, string>(2, "Lin Dan"));
    Players.insert(std::pair<int, string>(1, "Chen Long"));

    cout << "Number of Players " << Players.size() << endl;
    for(map<int, string>::iterator it = Players.begin(); it != Players.end();
        ++it){
            cout << (*it).first << ": " << (*it).second << endl;
        }

}

use std::collections::HashMap;

fn main(){
    let mut Players = HashMap::new();
    Players.insert(2, "Lin Dan");
    Players.insert(1, "Chen Long");

    println!("{}", Players.len());

    for (k, v) in &Players {
        println!("{}: {}", k, v);
    }
}

$ ./main
2
1: Chen Long
2: Lin Dan