整数型

整数型

符号なし整数型

型	ビット幅	範囲	ビット幅の取得	最小値の取得	最大値の取得
u8	8ビット	0 から 28 - 1	u8::BITS	u8::MIN	u8::MAX
u16	16ビット	0 から 216 - 1	u16::BITS	u16::MIN	u16::MAX
u32	32ビット	0 から 232 - 1	u32::BITS	u32::MIN	u32::MAX
u64	64ビット	0 から 264 - 1	u64::BITS	u64::MIN	u64::MAX
u128	128ビット	0 から 2128 - 1	u128::BITS	u128::MIN	u128::MAX
usize	計算機のワード長	0 から 232 - 1、 もしくは 0 から 264 - 1	usize::BITS	usize::MIN	usize::MAX

unsigned-integer-type/main.rs

fn main() {
    println!("   u8のビット幅:{:>4}、最小値:{:>2}、最大値:{:>40}",    u8::BITS,    u8::MIN,    u8::MAX);
    println!("  u16のビット幅:{:>4}、最小値:{:>2}、最大値:{:>40}",   u16::BITS,   u16::MIN,   u16::MAX);
    println!("  u32のビット幅:{:>4}、最小値:{:>2}、最大値:{:>40}",   u32::BITS,   u32::MIN,   u32::MAX);
    println!("  u64のビット幅:{:>4}、最小値:{:>2}、最大値:{:>40}",   u64::BITS,   u64::MIN,   u64::MAX);
    println!(" u128のビット幅:{:>4}、最小値:{:>2}、最大値:{:>40}",  u128::BITS,  u128::MIN,  u128::MAX);
    println!("usizeのビット幅:{:>4}、最小値:{:>2}、最大値:{:>40}", usize::BITS, usize::MIN, usize::MAX);
}

実行結果

   u8のビット幅:   8、最小値: 0、最大値:                                     255
  u16のビット幅:  16、最小値: 0、最大値:                                   65535
  u32のビット幅:  32、最小値: 0、最大値:                              4294967295
  u64のビット幅:  64、最小値: 0、最大値:                    18446744073709551615
 u128のビット幅: 128、最小値: 0、最大値: 340282366920938463463374607431768211455
usizeのビット幅:  64、最小値: 0、最大値:                    18446744073709551615

符号あり整数型

型	ビット幅	範囲	ビット幅の取得	最小値の取得	最大値の取得
i8	8ビット	- 27 から 27 - 1	i8::BITS	i8::MIN	i8::MAX
i16	16ビット	- 215 から 215 - 1	i16::BITS	i16::MIN	i16::MAX
i32	32ビット	- 231 から 231 - 1	i32::BITS	i32::MIN	i32::MAX
i64	64ビット	- 263 から 263 - 1	i64::BITS	i64::MIN	i64::MAX
i128	128ビット	- 2127 から 2127 - 1	i128::BITS	i128::MIN	i128::MAX
isize	計算機のワード長	- 231 から 231 - 1、 もしくは - 263 から 264 - 1	isize::BITS	isize::MIN	isize::MAX

signed-integer-type/main.rs

fn main() {
    println!("   i8のビット幅:{:>4}、最小値:{:>41}、最大値:{:>40}",    i8::BITS,    i8::MIN,    i8::MAX);
    println!("  i16のビット幅:{:>4}、最小値:{:>41}、最大値:{:>40}",   i16::BITS,   i16::MIN,   i16::MAX);
    println!("  i32のビット幅:{:>4}、最小値:{:>41}、最大値:{:>40}",   i32::BITS,   i32::MIN,   i32::MAX);
    println!("  i64のビット幅:{:>4}、最小値:{:>41}、最大値:{:>40}",   i64::BITS,   i64::MIN,   i64::MAX);
    println!(" i128のビット幅:{:>4}、最小値:{:>41}、最大値:{:>40}",  i128::BITS,  i128::MIN,  i128::MAX);
    println!("isizeのビット幅:{:>4}、最小値:{:>41}、最大値:{:>40}", isize::BITS, isize::MIN, isize::MAX);
}

実行結果

   i8のビット幅:   8、最小値:                                     -128、最大値:                                     127
  i16のビット幅:  16、最小値:                                   -32768、最大値:                                   32767
  i32のビット幅:  32、最小値:                              -2147483648、最大値:                              2147483647
  i64のビット幅:  64、最小値:                     -9223372036854775808、最大値:                     9223372036854775807
 i128のビット幅: 128、最小値: -170141183460469231731687303715884105728、最大値: 170141183460469231731687303715884105727
isizeのビット幅:  64、最小値:                     -9223372036854775808、最大値:                     9223372036854775807

整数リテラル

整数リテラルには数値の後ろに型を付ける。38u8はu8の値、4953isizeはisizeになる。また、0x、0o、0bを先頭に付けると、16進数、8進数、2進数のリテラルになる。

リテラル	型	10進数
52i8	i8	52
0xcafeu32	u32	51966
0b0001_0100	推論される	20
0o105	推論される	69

integer-literal/main.rs

fn main() {
    println!("{}", 52i8);
    println!("{}", 0xcafeu32);
    println!("{}", 0b0001_0100);
    println!("{}", 0o105);
}

実行結果

52
51966
20
69

バイトリテラル

バイトリテラルb’X’は文字Xに対するACSIIコードのu8の値となる。 バイトリテラルはb’\xHH’のように16進数で書くこともできる。HHは値を表す16進数2文字である。

文字	バイトリテラル	バイトリテラル（16進表記）	対応する数値リテラル
英小文字a	b’a’	b’\x61’	97u8
英小文字b	b’b’	b’\x62’	98u8
英小文字c	b’c’	b’\x63’	99u8
英大文字A	b’A’	b’\x41’	65u8
英大文字B	b’B’	b’\x42’	66u8
英大文字C	b’C’	b’\x43’	67u8
シングルクォート’	b’' ’	b’\x27’	39u8
バックスラッシュ\	b’\’	b’\x5C’	92u8
改行	b’\n’	b’\x0A’	10u8

byte-literal/main.rs

fn main() {
    println!("{},{},{}", b'a'   , b'b'   , b'c'   );
    println!("{},{},{}", b'A'   , b'B'   , b'C'   );
    println!("{},{},{}", b'\''  , b'\\'  , b'\n'  );
    println!("{},{},{}", b'\x61', b'\x62', b'\x63');
    println!("{},{},{}", b'\x41', b'\x42', b'\x43');
    println!("{},{},{}", b'\x27', b'\x5C', b'\x0A');
}

実行結果

97,98,99
65,66,67
39,92,10
97,98,99
65,66,67
39,92,10

整数型に定義されたメソッド

チェック付き演算

計算結果が その型で表現できる範囲を超えるかどうかを安全に確認しながら演算する ためのものです。 計算できるなら Some(値)、できないなら None を返す。

checked_add

u8

// u8::MAX - 1に1を足すとu8::MAXとなりオーバーフローは発生しないのでSome(u8::MAX)が返ります。
assert_eq!((u8::MAX - 1).checked_add(1), Some(u8::MAX));
// u8::MAX - 1に2を足すとu8::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u8::MAX - 1).checked_add(2), None);

u16

// u16::MAX - 1に1を足すとu16::MAXとなりオーバーフローは発生しないのでSome(u16::MAX)が返ります。
assert_eq!((u16::MAX - 1).checked_add(1), Some(u16::MAX));
// u16::MAX - 1に2を足すとu16::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u16::MAX - 1).checked_add(2), None);

u32

// u32::MAX - 1に1を足すとu32::MAXとなりオーバーフローは発生しないのでSome(u32::MAX)が返ります。
assert_eq!((u32::MAX - 1).checked_add(1), Some(u32::MAX));
// u32::MAX - 1に2を足すとu32::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u32::MAX - 1).checked_add(2), None);

u64

// u64::MAX - 1に1を足すとu64::MAXとなりオーバーフローは発生しないのでSome(u64::MAX)が返ります。
assert_eq!((u64::MAX - 1).checked_add(1), Some(u64::MAX));
// u64::MAX - 1に2を足すとu64::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u64::MAX - 1).checked_add(2), None);

u128

// u128::MAX - 1に1を足すとu128::MAXとなりオーバーフローは発生しないのでSome(u128::MAX)が返ります。
assert_eq!((u128::MAX - 1).checked_add(1), Some(u128::MAX));
// u128::MAX - 1に2を足すとu128::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u128::MAX - 1).checked_add(2), None);

i8

// i8::MAX - 1に1を足すとi8::MAXとなりオーバーフローは発生しないのでSome(i8::MAX)が返ります。
assert_eq!((i8::MAX - 1).checked_add(1), Some(i8::MAX));
// i8::MAX - 1に2を足すとi8::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i8::MAX - 1).checked_add(2), None);

i16

// i16::MAX - 1に1を足すとi16::MAXとなりオーバーフローは発生しないのでSome(i16::MAX)が返ります。
assert_eq!((i16::MAX - 1).checked_add(1), Some(i16::MAX));
// i16::MAX - 1に2を足すとi16::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i16::MAX - 1).checked_add(2), None);

i32

// i32::MAX - 1に1を足すとi32::MAXとなりオーバーフローは発生しないのでSome(i32::MAX)が返ります。
assert_eq!((i32::MAX - 1).checked_add(1), Some(i32::MAX));
// i32::MAX - 1に2を足すとi32::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i32::MAX - 1).checked_add(2), None);

i64

// i64::MAX - 1に1を足すとi64::MAXとなりオーバーフローは発生しないのでSome(i64::MAX)が返ります。
assert_eq!((i64::MAX - 1).checked_add(1), Some(i64::MAX));
// i64::MAX - 1に2を足すとi64::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i64::MAX - 1).checked_add(2), None);

i128

// i128::MAX - 1に1を足すとi128::MAXとなりオーバーフローは発生しないのでSome(i128::MAX)が返ります。
assert_eq!((i128::MAX - 1).checked_add(1), Some(i128::MAX));
// i128::MAX - 1に2を足すとi128::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i128::MAX - 1).checked_add(2), None);

checked_sub

u8

// u8::MIN - 1から1を引くとu8::MINとなりオーバーフローは発生しないのでSome(u8::MIN)が返ります。
assert_eq!((u8::MIN + 1).checked_sub(1), Some(u8::MIN));
// u8::MIN - 1から2を引くとu8::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u8::MIN + 1).checked_sub(2), None);

u16

// u16::MIN - 1から1を引くとu16::MINとなりオーバーフローは発生しないのでSome(u16::MIN)が返ります。
assert_eq!((u16::MIN + 1).checked_sub(1), Some(u16::MIN));
// u16::MIN - 1から2を引くとu16::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u16::MIN + 1).checked_sub(2), None);

u32

// u32::MIN - 1から1を引くとu32::MINとなりオーバーフローは発生しないのでSome(u32::MIN)が返ります。
assert_eq!((u32::MIN + 1).checked_sub(1), Some(u32::MIN));
// u32::MIN - 1から2を引くとu32::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u32::MIN + 1).checked_sub(2), None);

u64

// u64::MIN - 1から1を引くとu64::MINとなりオーバーフローは発生しないのでSome(u64::MIN)が返ります。
assert_eq!((u64::MIN + 1).checked_sub(1), Some(u64::MIN));
// u64::MIN - 1から2を引くとu64::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u64::MIN + 1).checked_sub(2), None);

u128

// u128::MIN - 1から1を引くとu128::MINとなりオーバーフローは発生しないのでSome(u128::MIN)が返ります。
assert_eq!((u128::MIN + 1).checked_sub(1), Some(u128::MIN));
// u128::MIN - 1から2を引くとu128::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u128::MIN + 1).checked_sub(2), None);

i8

// i8::MIN - 1から1を引くとi8::MINとなりオーバーフローは発生しないのでSome(i8::MIN)が返ります。
assert_eq!((i8::MIN + 1).checked_sub(1), Some(i8::MIN));
// i8::MIN - 1から2を引くとi8::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i8::MIN + 1).checked_sub(2), None);

i16

// i16::MIN - 1から1を引くとi16::MINとなりオーバーフローは発生しないのでSome(i16::MIN)が返ります。
assert_eq!((i16::MIN + 1).checked_sub(1), Some(i16::MIN));
// i16::MIN - 1から2を引くとi16::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i16::MIN + 1).checked_sub(2), None);

i32

// i32::MIN - 1から1を引くとi32::MINとなりオーバーフローは発生しないのでSome(i32::MIN)が返ります。
assert_eq!((i32::MIN + 1).checked_sub(1), Some(i32::MIN));
// i32::MIN - 1から2を引くとi32::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i32::MIN + 1).checked_sub(2), None);

i64

// i64::MIN - 1から1を引くとi64::MINとなりオーバーフローは発生しないのでSome(i64::MIN)が返ります。
assert_eq!((i64::MIN + 1).checked_sub(1), Some(i64::MIN));
// i64::MIN - 1から2を引くとi64::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i64::MIN + 1).checked_sub(2), None);

i128

// i128::MIN - 1から1を引くとi128::MINとなりオーバーフローは発生しないのでSome(i128::MIN)が返ります。
assert_eq!((i128::MIN + 1).checked_sub(1), Some(i128::MIN));
// i128::MIN - 1から2を引くとi128::MIN - 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i128::MIN + 1).checked_sub(2), None);

checked_mul

u8

// u8::MAXに1をかけるとu8::MAXとなりオーバーフローは発生しないのでSome(u8::MAX)が返ります。
assert_eq!((u8::MAX).checked_mul(1), Some(u8::MAX));
// u8::MAXに2をかけるとu8::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u8::MAX).checked_mul(2), None);

u16

// u16::MAXに1をかけるとu16::MAXとなりオーバーフローは発生しないのでSome(u16::MAX)が返ります。
assert_eq!((u16::MAX).checked_mul(1), Some(u16::MAX));
// u16::MAXに2をかけるとu16::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u16::MAX).checked_mul(2), None);

u32

// u32::MAXに1をかけるとu32::MAXとなりオーバーフローは発生しないのでSome(u32::MAX)が返ります。
assert_eq!((u32::MAX).checked_mul(1), Some(u32::MAX));
// u32::MAXに2をかけるとu32::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u32::MAX).checked_mul(2), None);

u64

// u64::MAXに1をかけるとu64::MAXとなりオーバーフローは発生しないのでSome(u64::MAX)が返ります。
assert_eq!((u64::MAX).checked_mul(1), Some(u64::MAX));
// u64::MAXに2をかけるとu64::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u64::MAX).checked_mul(2), None);

u128

// u128::MAXに1をかけるとu128::MAXとなりオーバーフローは発生しないのでSome(u128::MAX)が返ります。
assert_eq!((u128::MAX).checked_mul(1), Some(u128::MAX));
// u128::MAXに2をかけるとu128::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((u128::MAX).checked_mul(2), None);

i8

// i8::MAXに1をかけるとi8::MAXとなりオーバーフローは発生しないのでSome(i8::MAX)が返ります。
assert_eq!((i8::MAX).checked_mul(1), Some(i8::MAX));
// i8::MAXに2をかけるとi8::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i8::MAX).checked_mul(2), None);

i16

// i16::MAXに1をかけるとi16::MAXとなりオーバーフローは発生しないのでSome(i16::MAX)が返ります。
assert_eq!((i16::MAX).checked_mul(1), Some(i16::MAX));
// i16::MAXに2をかけるとi16::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i16::MAX).checked_mul(2), None);

i32

// i32::MAXに1をかけるとi32::MAXとなりオーバーフローは発生しないのでSome(i32::MAX)が返ります。
assert_eq!((i32::MAX).checked_mul(1), Some(i32::MAX));
// i32::MAXに2をかけるとi32::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i32::MAX).checked_mul(2), None);

i64

// i64::MAXに1をかけるとi64::MAXとなりオーバーフローは発生しないのでSome(i64::MAX)が返ります。
assert_eq!((i64::MAX).checked_mul(1), Some(i64::MAX));
// i64::MAXに2をかけるとi64::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i64::MAX).checked_mul(2), None);

i128

// i128::MAXに1をかけるとi128::MAXとなりオーバーフローは発生しないのでSome(i128::MAX)が返ります。
assert_eq!((i128::MAX).checked_mul(1), Some(i128::MAX));
// i128::MAXに2をかけるとi128::MAX * 2となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i128::MAX).checked_mul(2), None);

checked_div

u8

// 128u8を2で割ると64となりオーバーフローは発生しないので64が返ります。
assert_eq!(128u8.checked_div(2), Some(64u8));
// 0での除算はNoneが返ります。
assert_eq!(1u8.checked_div(0), None);

u16

// 128u16を2で割ると64となりオーバーフローは発生しないので64が返ります。
assert_eq!(128u16.checked_div(2), Some(64u16));
// 0での除算はNoneが返ります。
assert_eq!(1u16.checked_div(0), None);

u32

// 128u32を2で割ると64となりオーバーフローは発生しないので64が返ります。
assert_eq!(128u32.checked_div(2), Some(64u32));
// 0での除算はNoneが返ります。
assert_eq!(1u32.checked_div(0), None);

u64

// 128u64を2で割ると64となりオーバーフローは発生しないので64が返ります。
assert_eq!(128u64.checked_div(2), Some(64u64));
// 0での除算はNoneが返ります。
assert_eq!(1u64.checked_div(0), None);

u128

// 128u128を2で割ると64となりオーバーフローは発生しないので64が返ります。
assert_eq!(128u128.checked_div(2), Some(64u128));
// 0での除算はNoneが返ります。
assert_eq!(1u128.checked_div(0), None);

i8

// i8::MAXを-1で割るとi8::MIN + 1となりオーバーフローは発生しないのでSome(i8::MIN + 1)が返ります。
assert_eq!((i8::MAX).checked_div(-1), Some(i8::MIN + 1));
// i8::MINを-1で割るとi8::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i8::MIN).checked_div(-1), None);
// 0での除算はNoneが返ります。
assert_eq!((1i8).checked_div(0), None);

i16

// i16::MAXを-1で割るとi16::MIN + 1となりオーバーフローは発生しないのでSome(i16::MIN + 1)が返ります。
assert_eq!((i16::MAX).checked_div(-1), Some(i16::MIN + 1));
// i16::MINを-1で割るとi16::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i16::MIN).checked_div(-1), None);
// 0での除算はNoneが返ります。
assert_eq!((1i16).checked_div(0), None);

i32

// i32::MAXを-1で割るとi32::MIN + 1となりオーバーフローは発生しないのでSome(i32::MIN + 1)が返ります。
assert_eq!((i32::MAX).checked_div(-1), Some(i32::MIN + 1));
// i32::MINを-1で割るとi32::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i32::MIN).checked_div(-1), None);
// 0での除算はNoneが返ります。
assert_eq!((1i32).checked_div(0), None);

i64

// i64::MAXを-1で割るとi64::MIN + 1となりオーバーフローは発生しないのでSome(i64::MIN + 1)が返ります。
assert_eq!((i64::MAX).checked_div(-1), Some(i64::MIN + 1));
// i64::MINを-1で割るとi64::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i64::MIN).checked_div(-1), None);
// 0での除算はNoneが返ります。
assert_eq!((1i64).checked_div(0), None);

i128

// i128::MAXを-1で割るとi128::MIN + 1となりオーバーフローは発生しないのでSome(i128::MIN + 1)が返ります。
assert_eq!((i128::MAX).checked_div(-1), Some(i128::MIN + 1));
// i128::MINを-1で割るとi128::MAX + 1となりオーバーフローが発生するのでNoneが返ります。
assert_eq!((i128::MIN).checked_div(-1), None);
// 0での除算はNoneが返ります。
assert_eq!((1i128).checked_div(0), None);

checked_div_euclid

u8

u16

u32

u64

u128

i8

i16

i32

i64

i128

checked_rem

u8

u16

u32

u64

u128

i8

i16

i32

i64

i128

checked_rem_euclid

u8

u16

u32

u64

u128

i8

i16

i32

i64

i128

checked_shl

u8

u16

u32

u64

u128

i8

i16

i32

i64

i128

checked_shr

u8

u16

u32

u64

u128

i8

i16

i32

i64

i128

checked_pow

u8

u16

u32

u64

u128

i8

i16

i32

i64

i128

checked_neg

u8

u16

u32

u64

u128

i8

i16

i32

i64

i128

ラップ演算

ラッピング演算 は、整数の範囲を超えたときにエラーにせず、ビット幅に収まるように値を循環させる演算です。

飽和演算

計算結果が型の範囲を超えたとき、循環させずに 最小値または最大値で止める演算 です。 日本語では「 飽和演算 」と呼ばれることがあります。

オーバーフロー演算

計算結果そのものと、オーバーフローが起きたかどうかをセットで返す演算です。

演算の比較

項目	checked_*	wrapping_*	saturating_*	overflowing_*
範囲超過時	None	循環	端で止まる (結果, true)
戻り値	Option<T>	T	T	(T, bool)
結果値の扱い	失敗として捨てる	そのまま使う	端値に丸める	使いつつ検出できる
主な用途	厳密な計算	低レベル処理	上限下限のある値	フラグ付き演算