リテラルと演算子

リテラル：コードに直接記述され、一目で値が分かる定数データのことで、プログラムの最も基礎的なデータ表現形式です。

値は固定で変化しない、コードに直書きされ実行中に変更できません。計算や変数の解釈も不要で、文字通り「字面の値」という意味です。

例：下記の13、3.14がリテラルに該当し、他言語では値リテラルと呼ぶこともあります。

fn main() {
    println!("{}", 13);
    println!("{}", 3.14);
}Code language: JavaScript (javascript)

学習しやすいよう、公式がオンラインRustエディタを提供しています。ローカル環境をインストールせず、ブラウザ上でRustの基礎文法を練習可能です。下記リンクをクリックしてください

Rust Playground

リテラル

Rustは整数、浮動小数点数、文字、文字列、真偽値、ユニット(unit)型のリテラルに対応しています。

• 整数：11
• 文字：'a'（シングルクォーテーション）
• 文字列："abc"（ダブルクォーテーション）
• 真偽値：true / false
• ユニット型：()

整数の各進数記述方法

接頭辞で進数を区別し、整数のみに使用できます。

• 16進数：0x 先頭、例：0x1F
• 8進数：0o 先頭、例：0o77
• 2進数：0b 先頭、例：0b1010

数値区切りアンダースコア

数値リテラル内にアンダースコア _を挿入し可読性を高められます。実際の数値に影響はありません。

• 整数：1_000 = 1000
• 浮動小数点数：0.000_001 = 0.000001

指数表記

浮動小数点数はEによる指数表記に対応、既定型はf64です。

• 1e6 = 1000000
• 7.6e-4 = 0.00076

リテラル型サフィックス（重要）

Rustではリテラルの型を明示する必要があり、よく使われるサフィックスは下記の通りです。

• u32：32ビット符号なし整数（非負数のみ）
• i32：32ビット符号付き整数（正負両方対応）

注意：符号付き整数と符号なし整数を混ぜて演算するとエラーが発生します。

サンプルコード：

fn main() {
    // 1. 通常整数リテラル
    println!("整数: {}", 13);
    // 2進数、8進数、16進数整数
    println!("2進数: {}", 0b1010);
    println!("8進数: {}", 0o77);
    println!("16進数: {}", 0x2A);
    // 区切り記号付き整数（可読性向上）
    println!("アンダースコア付き整数: {}", 1_000_000);
    // 型サフィックス付き整数
    println!("u32符号なし整数: {}", 100u32);
    println!("i32符号付き整数: {}", -50i32);

    // 2. 浮動小数点数リテラル
    println!("浮動小数点数: {}", 3.14);
    // アンダースコア付き浮動小数点数
    println!("アンダースコア付き浮動小数点数: {}", 0.000_001);
    // 指数表記浮動小数点数
    println!("指数表記: {}", 1e6);
    println!("負の指数表記: {}", 7.6e-4);

    // 3. 文字列リテラル（ダブルクォーテーション）
    println!("文字列: {}", "hello world");

    // 4. 文字リテラル（シングルクォーテーション、1文字のみ指定可）
    println!("文字: {}", 'a');
    println!("日本語文字: {}", '中');

    // 5. 真偽値リテラル
    println!("真偽値true: {}", true);
    println!("真偽値false: {}", false);

    // 6. ユニットリテラル ()（Rustのユニット型）
    println!("ユニット型: {:?}", ());
}Code language: JavaScript (javascript)

演算子

Rustの演算子ルール・優先順位はC系言語とほぼ同じです。

1. 算術演算子

足し算・引き算など基礎的な数値演算で、整数型サフィックスと併用します。

• 足し算：+
• 引き算：-

2. 論理演算子（ショートサーキット論理）

true/falseの真偽値にのみ適用可能です。

• 論理積 &&：両辺がtrueの場合のみ結果がtrue
• 論理和 ||：片方だけtrueでも結果がtrue
• 否定 !：真偽値を反転

演算式	演算結果
true && true	true
true && false	false
false && true	false
false && false	false
true || true	true
true || false	true
false || true	true
false || false	false
!true	false
!false	true

3. ビット演算子（2進ビット操作）

主に整数に使用、サンプルでは{:04b}により4桁2進数をフォーマット出力しています。

1. ビット積 &：同じ桁の両方が1の時のみ結果が1
2. ビット和 |：同じ桁のどちらかが1なら結果が1
3. 排他的論理和 ^：同じ桁の値が異なる場合1、同じ場合は0
4. 左シフト <<：2進数全体を左へシフト（×2ⁿと同等）
5. 右シフト >>：2進数全体を右へシフト（÷2ⁿと同等）

  0 0 1 1
& 0 1 0 1
-----------
  0 0 0 1  

  0 0 1 1
| 0 1 0 1
-----------
  0 1 1 1

  0 0 1 1
^ 0 1 0 1
-----------
  0 1 1 0

左シフト <<
2進数：00000001
5ビット左シフト → 00100000、結果 = 32

右シフト >>
0x80 2進数：10000000
2ビット右シフト → 00100000（16進数 0x20）、結果 = 32

fn main() {
    // ========== 算術演算子 ==========
    // 整数足し算：u32 32ビット符号なし整数
    // 実行結果：1 + 2 = 3
    println!("1 + 2 = {}", 1u32 + 2);

    // 整数引き算：i32 32ビット符号付き整数、負数に対応
    // 1u32に変更するとエラー、符号なし整数は負数を表現できない
    // 実行結果：1 - 2 = -1
    println!("1 - 2 = {}", 1i32 - 2);

    // ========== 浮動小数点数リテラル - 指数表記 ==========
    // 実行結果：1e4 は 10000、-2.5e-3 は -0.0025
    println!("1e4 は {}, -2.5e-3 は {}", 1e4, -2.5e-3);

    // ========== 論理演算子（ショートサーキット演算） ==========
    // 論理積 &&：両辺同時にtrueで結果がtrue
    // 実行結果：true 論理積 false = false
    println!("true 論理積 false = {}", true && false);

    // 論理和 ||：片方がtrueなら結果がtrue
    // 実行結果：true 論理和 false = true
    println!("true 論理和 false = {}", true || false);

    // 否定 !：真偽値を反転
    // 実行結果：否定 true = false
    println!("否定 true = {}", !true);

    // ========== ビット演算子（2進ビット操作） ==========
    // {:04b} 4桁2進数固定出力、桁不足時左を0埋め
    // ビット積 &：同桁両方1で結果1
    // 実行結果：0011 ビット積 0101 = 0001
    println!("0011 ビット積 0101 = {:04b}", 0b0011u32 & 0b0101);

    // ビット和 |：同桁いずれか1で結果1
    // 実行結果：0011 ビット和 0101 = 0111
    println!("0011 ビット和 0101 = {:04b}", 0b0011u32 | 0b0101);

    // 排他的論理和 ^：同桁値が異なれば1、同一なら0
    // 実行結果：0011 排他的論理和 0101 = 0110
    println!("0011 排他的論理和 0101 = {:04b}", 0b0011u32 ^ 0b0101);

    // 左シフト <<：2進数全体を5ビット左へ
    // 実行結果：1 を5ビット左シフト = 32
    println!("1 を5ビット左シフト = {}", 1u32 << 5);

    // 右シフト >>：2進数全体を2ビット右へ、{:x} 16進数出力
    // 実行結果：0x80 を2ビット右シフト = 0x20
    println!("0x80 を2ビット右シフト = 0x{:x}", 0x80u32 >> 2);

    // ========== 数値区切りアンダースコア _ ==========
    // アンダースコアは可読性向上のみ、数値に変化なし
    // 実行結果：100万の記述：1000000
    println!("100万の記述：{}", 1_000_000u32);
}Code language: JavaScript (javascript)

---

3. 코드 실행 추가 설명

1. 1i32를 1u32로 바꿔 감산 1u32 - 2을 실행하면 오류가 발생합니다. 부호 없는 정수는 음수를 표현할 수 없기 때문입니다.
2. {:04b}：포맷 출력 구문, b는 2진수를 의미하며 04는 자릿수가 4자리 미만일 경우 왼쪽을 0으로 채웁니다.
3. 큰 숫자는 밑줄로 구분하는 것을 권장（예：1_000_000u32）코드 가독성이 높아집니다.