Rust 繰り返し(for, while, loop)

通常繰り返しにはfor文、while文、loop文を使用する。

fn main(){
	for i in 0..10 {
		println!("{}の2乗は{}", i, i*i);
	}
}

if文と同様に結果を返すことができる

fn main(){
	let x = for i in 0..10 {
		println!("{}の2乗は{}", i, i*i);
	};
	println!("{:?}", x);
}

for文の中にfor文を記述するネストもできる。

fn main(){
	for i in 0..10 {
		let mut v = 1;
		for j in 2..=i{
			v = v * j
		}
		println!("{}の階乗は{}", i, v);
	};
}

breakを使って繰り返し処理を終了することができる

fn main(){
	for i in 0..10 {
		if i > 5 {
			break
		}
		println!("{}", i);
	};
}

ラベルは先頭を単一引用符(‘)にする

fn main(){
'looptop:
	for i in 0..4 {
		for j in 0..4 {
			if i == 1 && j == 2 {
				break 'looptop;
			}
			println!("{} {}", i, j);
		}
	}
}

forループの中でcontinueを使うことで以降のコードを実行せずにループの先頭に戻ることができる。

fn main(){
	for i in 0..10 {
		if i % 2 == 0 {
			continue
		}
		println!("{}", i);
	}
}

配列の繰り返し

fn main(){
	let fruits = ["りんご", "みかん", "バナナ"];
	for x in fruits.iter(){
		println!("{}", x);
	}
}

ベクターでも同じようにイテレータを使うことができる

fn main(){
	let fruits = vec!["りんご", "みかん", "バナナ"];
	for x in fruits.iter(){
		println!("{}", x);
	}
}

3回出力する場合

fn main(){
	for _i in 1..4 {
		println!("Hello!");
	}
}
fn main(){
	for _ in 1..4 {
		println!("Hello!");
	}
}

While文

fn main(){
	let mut i = 0;
	while i < 10 {
		println!("{}", i);
		i = i + 1;
	}
}
fn main(){
	let mut i = 0;
	loop {
		println!("{}", i);
		i = i + 1;
		if i > 5 {
			break;
		}
	}
}

無限ループはbreakでループから抜けるか std::process::exit(1);で終了する

Rust if文, match文

条件分岐の式では、条件に応じて実行するコードを選択する
if expr {
statement
}

state_true, falseで実行するステートメントを分岐する
if is_even(n){
println!(“{}は偶数です”, n);
} else {
println!(“{}は奇数です”, n)
}

use std::io;

fn main(){
	println!("整数を入力してください。");

	let mut s = String::new();
	io::stdin().read_line(&mut s).ok();
	let x:i32 = s.trim().parse().ok().unwrap();

	if x > 0 {
		println!("{}は正の整数です。", x);
	} else if x < 0 {
		println!("{}は負の整数です。", x);
	} else {
		println!{"{}はゼロです。", x};
	}
}

値を返す場合はセミコロンを付けない

fn main(){
	let x = 0;

	let b = if x > 0 {
		println!("{}は正の値", x)
	} else {
		println!("{}はゼロまたは負の値", x)
	};

	println!("b={:?}", b);
}

### match文
match文は、式を評価して、結果に応じて処理を切り替える

fn main(){
	let n:i32 = 3;

	let x = n % 2;
	match x {
		0 => println!("{}は偶数です。", n),
		1 => println!("{}は奇数です。", n),
		_ => println!("{}は偶数でも奇数でもありません。", n),
	}
}

_のケースを記載しないとコンパイル時にエラーになる
その場合は、 _ => (),と書く

fn main(){
	let n:i32 = 3;

	match (n % 2) == 0 {
		true => println!("{}は偶数です。", n),
		false => println!("{}は奇数です。", n),
	}
}
fn main(){
	let n:u16 = 3;

	match n {
		0 => println!("{}はゼロです。", n),
		1..=9 => println!("{}は10未満の整数です。", n),
		_ => println!("{}は10以上の整数です。", n),
	}
}

「|」を使って条件式に複数の値を指定することもできる

fn main(){
	let n:u16 = 3;

	match n {
		0 => println!("{}はゼロです。", n),
		1|3|5|7|9 => println!("{}は10以下の奇数です。", n),
		2|4|6|8|10 => println!("{}は10以下の偶数です。", n),
		_ => println!("{}は11以上の整数です。", n),
	}
}

Rust コマンドライン引数

コマンドライン引数は、std::env::args().collect()で取得することができる
let argv: Vec = std::env::args().collect();

use std::env;

fn main(){
	let argv: Vec<String> = env::args().collect();
	let argc = argv.len();
	println!("arg={}", argc);
	println!("{:?}", argv);
}

コマンド名とコマンドライン引数を表示する例

use std::env;

fn main(){
	let argv: Vec<String> = env::args().collect();
	let argc = argv.len();

	if argc < 3 {
		println!("引数を2個指定してください。");
		std::process::exit(1);
	}

	println!("実行ファイル名:{}", argv[0]);
	println!("引数1:{}", argv[1]);
	println!("引数2:{}", argv[2]);
}

コマンドラインからファイル名を取得してファイルを読み込んで表示する1つのツールとして使えるプログラムにする

use std::env;
use std::io::BufReader;
use std::io::prelude::*;
use std::fs::File;

fn main() -> std::io::Result<()>{
	let argv: Vec<String> = env::args().collect();
	let argc = argv.len();

	let fname = &argv[1];

	if argc < 2 {
		println!("引数にファイル名を指定してください。");
		std::process::exit(1);
	}

	let f = File::open(fname)?;
	let reader = BufReader::new(f);

	for line in reader.lines(){
		println!("{}", line?);
	}
	Ok(())
}

Rust コンソール入力

キーボードから文字列や数値を入力する方法
read_line()を使う
典型的には std::io::stdin().read_line(&mut line).ok();

fn main(){
	println!("名前を入力してください。");

	let mut line = String::new();
	std::io::stdin().read_line(&mut line).ok();
	let name = line.trim().to_string();

	println!("こんにちは、{}さん!", name);
}

文字列として受け取ってから整数に変換
let n:i32 = s.trim().parse().ok().unwrap();

fn main(){
	println!("整数を入力してください。");

	let mut s = String::new();
	std::io::stdin().read_line(&mut s).ok();
	let n:i32 = s.trim().parse().ok().unwrap();

	println!("{}の2倍は{}", n, n*2);
}

use文を使って予め宣言しておくと、「std::」を省略することができる

use std::io;

fn main(){
	println!("整数を入力してください。");

	let mut s = String::new();
	io::stdin().read_line(&mut s).ok();
	let n:i32 = s.trim().parse().ok().unwrap();

	println!("{}の2倍は{}", n, n*2);
}

use chrono::Local;
use chrono::DateTime;
use chrono::Date;

use chrono::{Local, DateTime, Date};

matchは値に従って実行するコードを切り替える

use std::io;

fn main(){
	println!("整数を入力してください。");

	let mut s = String::new();
	let rslt = io::stdin().read_line(&mut s);
	match rslt {
		Ok(v) => println!("読み込み成功: {:?}", v),
		Err(e) => println!("読み込み失敗: {:?}", e),
	}
	let n:i32 = s.trim().parse().ok().unwrap();

	println!("{}の2倍は{}", n, n*2);
}

Rust コンソール出力

fn main(){
	print!("abc");
	print!("123");
	print!("xyz");
}

書式指定文字

fn main(){
	let name = "ワンコ犬";
	println!("こんにちは、{}{}", name, "さん。");
}

{}で出力できる型は基本的にはスカラー型や文字列などの単純な型の値で、println!()やprint!()で出力できるようにstd::fmt::Displayで実装されている

fn main(){
	let name = "ワンコ犬";
	let age = 16;
	let l = 168.5;
	println!("{}:年齢={} 身長={}", name, age, l);
}
fn main(){
	let name = "ワンコ犬";
	let age = 16;
	let l = 168.5;
	println!("{0}:年齢={2} 身長={1}({0})", name, l, age);
}

基数の書式
b: 2進数、o: 8進数、x: 16進数、e: 指数表現

fn main(){
	println!("{:b}", 123);
	println!("{:o}", 123);
	println!("{:x}", 123);
	println!("{:X}", 123);
	println!("{:e}", 123);
	println!("{:E}", 123);
}

右寄せ、中央揃えなどの指定
n, ^n, >0n, <0n [code] fn main(){ println!("[{0:<8}]", "Left"); println!("[{0:^8}]", "Center"); println!("[{0:>8}]", "Right"); println!("[{0:<08}][<{1:>8}]", 123,234); } [/code] 配列全体の出力 [code] fn main(){ let a = [0,1,2,3]; println!("a={:?}", a); } [/code] [code] fn main(){ let mut s = String::new(); s.insert_str(0, "Hello"); println!("{}", s); println!("{:?}", s); } [/code]

Rust 演算子

二項演算子は、演算子の左右の値に作用する
let c = a + b;
+, -, *, /, %, &, |, ^, <<, >>

fn main(){
	let a = 0b010010;
	let b = 0b000111;

	println!("{:08b}", a & b);
	println!("{:08b}", a | b);
	println!("{:08b}", a ^ b);
}

ビットのシフトは、各ビットを左または右にシフトする
右にシフトすると値が小さくなり、左にシフトすると値が大きくなる

fn main(){
	let n = 1;
	println!("{}", n << 1);
	println!("{}", n << 2);
	println!("{}", n << 3);

	let m = 300;
	println!("{}", m >> 1);
	println!("{}", m >> 2);
	println!("{}", m >> 3);
}

単項演算子は右側の値が左側の値に作用する
比較演算子は左右の値の比較
論理演算子は左右の値または右側の値に作業して論理値を返す
代入演算子は右の値を左の変数に代入する

参照と参照外し
&は変数の参照を表す。参照の値に「*」を付けると値そのものを指す

fn main(){
	let x:i32 = 456;
	let r = &x;

	println!("x={}, r={}, *r={:?}", x, r, *r);
}

値の型の出力にはtype_of()を使う

fn main(){
	let x:i32 = 456;
	let r = &x;

	println!("x={}, type={:?}", x, type_of(x));
	println!("r={}, type={:?}", r, type_of(r));
	println!("*r={}, type={:?}", *r, type_of(*r));
}

fn type_of<T>(_: T) -> &'static str {
	std::any::type_name::<T>()
}
fn main(){
	let x:i32 = 456;
	let ref r = x;

	println!("x={}, r={}, *r={:?}", x, r, *r);
}
fn main(){
	let mut x:i32 = 456;
	let y = &mut x;
	*y = 123;

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

Rustのその他の演算子
!, &, *, +, ,, -, -=, ->, ., .., ..=, …, /, /=, :, ;, =, =>, @, |, ?

演算子の結合順序
* / % << >> &
+ – | ^
== != < <= >= >=
&&
||

Rust 型の変換

fn main(){
	let n: i32 = 12;
	let v: f32 = n as f32;
	println!("{}->{}", n, v);
}
fn main(){
	let v = 123.45;
	let n = v as i32;
	println!("{}->{}", v, n);
}
let v = 12.56_f64;

let n = v.floor() as i32;
let m = v.ceil() as i32;
let l = v.round() as i32;

整数型から別の整数型への変換

fn main(){
	let n: i32 = 12;
	let v: i64 = n as i64;
	println!("{}->{}", n, v);
}
fn main(){
	let n: i64 = i64::MAX;
	let v: i32 = n as i32;
	println!("{}->{}", n, v);
}

実数型から別の実数型に変換するときもasを使う。この時に誤差が発生する場合がある

fn main(){
	let x: f32 = 7.6;
	let y: f64 = x as f64;
	println!("{}->{}", x, y);
}

7.6->7.599999904632568

文字列から数値へ変換するにはparse().unwrap()を使用する

fn main(){
	let s = "123";
	let v: u32 = s.parse().unwrap();
	println!("{}->{}", s, v);
}

あるいは parse::().unwrap()を使用する

fn main(){
	let s: &str = "123";
	let n: i32 = s.parse::<i32>().unwrap();

	println!("{:?}->{}", s, n);
}

文字列からバイト値に変換するにはas_bytes()を使用する

fn main(){
	let s: &str = "0";
	let n: &[u8] = s.as_bytes();

	println!("{}->{:?}", s, n);
}

数値から文字列への変換は to_string() を使用する

fn main(){
	let n: i32 = 123;
	let s = n.to_string();

	println!("{}->{}", n, s);
}

バイト値から文字列へ変換するにはstd::str::from_utf8().unwrap()を使用する

fn main(){
	let n: &[u8] = &[0x33];
	let s: &str = std::str::from_utf8(n).unwrap();

	println!("{:?}->{}", n, s);
}

Rust 文字リテラル

文字列リテラルは”~”で囲む
r”~”で囲んだ文字列をRaw文字列リテラルという
let msg:&str = r”Hello Dogs”;
b”~”で囲んだ文字列も[u8]のバイト列
let msg = b”Hello”;

fn main(){
	let msg:&str = r"Hello¥nDogs";

	println!("msg={}", msg);
}

エスケープシーケンス
¥b バックスペース
¥f フォームフィード
¥n 改行(line feed, newline)
¥r キャリッジリターン
¥t 水平タブ
¥v 垂直タブ
¥¥ バックスラッシュ
¥’ 単一引用符’
¥” 二重引用符”
¥xhh 2つの16進数
¥uhhhh 4つの16進数
¥Uhhhhhhhh 8つの16進数
¥ooo

水平タブ

fn main(){
	println!("12\tdef");
	println!("256\tmemory");
	println!("1024\tkiro");
}

### タプルと配列
タプルは複数の異なる型の値を1つのグループにすることができる複合型
配列は同じ型の要素を並べたもの

type: キーワードのtypeを使って型の別名(エイリアス)を定義することができる 別名の先頭は大文字にする。例えばu64にPopという別名を付けることができる

fn main(){
	type Pop = u64;
	let jp_pop: Pop = 123_456_789;
	let es_pop: Pop = 46_723_749;

	let total = jp_pop + es_pop + 456789_u64;

	println!("total={}", total);
}

### 変数と定数
不変の変数: let x = 10;
コンパイラが推測して決定することは型推論という
let zero: i64 = 0;
可変の変数を宣言するときはlet mutを使用する

fn main(){
	let mut x = 123;
	println!("x={}", x);

	x = 64;
	println!("x={}", x);
}
fn main(){
	let mut x = 123;
	println!("x={}", x);

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

	let x = "こんにちは";
	println!("x={}", x);
}

定数とはプログラムの実行中に内容が変わらない値に名前を付けたもの
const MAX_DATA: u32 = 100;
const HELL:&str = “Hello, Dogs”;

Rustには所有権という概念がある。これは変数は値を所有するという概念

fn main(){
	let s1 = String::from("hello Rust");
	let s2 = s1.clone();

	println!("s1={}, s2={}", s1, s2);
}

有効範囲
関数の中で宣言した定数や{~}の中で宣言した定数はその中で有効

fn main(){
	let x = 3;
	{
		let x = 12;
		println!("x={}", x);
	}
	let y = x * 2;

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

static変数は、モジュールのどこからでも参照できる変数
static mul VAL: i32 = 123;

static mut VAL: i32 = 123;

fn main(){
	unsafe {
		println!("VAL={}", VAL);
	}

	twice();

	unsafe {
		println!("VAL={}", VAL);
	}
}

fn twice(){
	unsafe {
		VAL = VAL * 2;
		println!("VAL in twice()={}", VAL);
	}
}

Rustのデータ型2

ブール値

fn main(){
	let t = true;
	let f: bool = false;

	println!("{} {}", t, f);
}

キャラクタ

fn main(){
	let c = 'z';
	let n:char = '0';
	let jp = 'あ';

	println!("{} {} {}", c, n, jp);
}

b’~’で囲んだASCII文字はバイト文字として扱われる
let chb = b’a’;
let ch = ‘a’;
let chjp = ‘あ’;

文字列
RustにはstrとStringの2種類がある。String型はプリミティブなデータ型ではない。strは文字列スライトという
let msg:&str = “Hello, Dogs!”;
let s = &msg[2..5];

fn main(){
	let msg:&str = "Hello, Dogs!";

	println!("msg.len()={}", msg.len());
	println!("msg={}", msg);
	println!("msg={}", &msg[2..5]);
}
fn main(){
	let dog = "ポチ";
	let msg = format!("{} ({}歳)", dog, 6);
	println!("{}", msg);
}
fn main(){
	let mut msg:String = String::from("Hello");
	msg = msg + " Rust!";

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

push_str, insert_str, +がある

fn main(){
	let mut msg = String::from("ポチ");
	msg.push_str("Good Dog");

	println!("{}", msg);
}
fn main(){
	let mut s = String::from("ポチ");
	s.insert_str(0, "Hello");

	println!("{}", s);
}
fn main(){
	let mut msg = String::from("ポチ");
	msg = msg + "Good Dog";

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

Rustのデータ型1

Rustのデータ型は整数(integer)、浮動小数点(floating-point number)、ブール値(Boolean)、キャラクタ(character)という4種類のスカラー型(scalar type)と、タプル(tuple)と配列(array)という2種類の複合型(Compound Type)などがある

### Rustのプリミティブ型
bool, char, f32(32ビット浮動小数点型), f64(64ビット浮動小数点型), fn(関数ポインタ), i8(8ビット符号付き整数), i16(16ビット符号付き整数), i32(32ビット符号付き整数),  i64(64ビット符号付き整数),  i128(128ビット符号付き整数), isize(ポインタのサイズの符号付き整数), str(文字列スライス型), tuple, u8(8ビット符号なし整数), u16(16ビット符号なし整数), u32(32ビット符号なし整数), u64(64ビット符号なし整数), u128(128ビット符号なし整数), usize(ポインタのサイズの符号なし整数), *const(ポインタ型(unsafe*)), *mut(ポインタ型(unsafe*)), &(参照型), スライス(スライス型), ()(unit型), !(never型), [](配列)

u8: 0~255
u16: 0~65535
u32: 0~4294967295
u64: 0~18446744073709551615
u128

i8: -128~127
i16: -32768~32767
i32: -2147483648 ~ -2147483647
i64: -9223372036854775808 ~ 9223372036854775807
i128
unsize, isize

整数
let x = 18;
桁の大きい10進数整数
const MAX_POINTS: u32 = 100_000;
16進数
let x = 0x12;
8進数
let x = 0o22;
2進数
let x = 0b010010;
桁の大きい2進数
let x = 0b01_0010;
let u b’A’; let a = b’;’; let a = b’あ’;
リテラルの型を明示
let n = 3_i16;

浮動小数点
f32: 32ビット浮動小数点数
f64: 64ビット浮動小数点数

fn main(){
	let x = 7.0;
	println!("{}", type_of(x));
}

fn type_of<T>(_: T) -> &'static str {
	std::any::type_name::<T>()
}

型を指定するときはf32, f64を使う

fn main(){
	let x: f32 = 7.0;
	let y: f64 = 0.3;

	println("x*y={}", x as f64 * y);
}
fn main(){
	let x: f32 = 7.0;
	let y = 3.2;

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