コンテンツにスキップ

Go/int

リンクを追加
出典: フリー教科書『ウィキブックス（Wikibooks）』
< Go

Goにおけるintは、整数値を表現するための事前宣言された組み込み型です。これは言語仕様で定義された基本的な型であり、実行環境に依存してそのサイズが変わる特徴があります。

基本的な特徴

[編集]
  • プラットフォーム依存のサイズ: 32ビットシステムでは32ビット（4バイト）、64ビットシステムでは64ビット（8バイト）
  • 符号付き整数型: 正負両方の値を表現可能
  • デフォルト値（ゼロ値）: 0

他のキーワードとの組み合わせとユースケース

[編集]

1. 変数宣言との組み合わせ

[編集]
// 基本的な宣言
var count int
var counter int = 10
shortCounter := 20 // 型推論による短縮宣言

// 複数宣言
var x, y int = 10, 20
a, b := 30, 40 // 複数の短縮宣言

ユースケース:

  • カウンター変数
  • インデックス
  • 量や個数の表現
  • サイズやオフセットの管理

2. 定数との組み合わせ

[編集]
const MaxUsers int = 100
const (
    MinValue int = -100
    DefaultValue int = 0
    MaxValue int = 100
)

// 型を省略した定数（リテラル定数）
const Limit = 1000 // intリテラルとして扱われる

ユースケース:

  • 最大/最小値の定義
  • 設定値の固定
  • マジックナンバーの回避
  • 列挙型の定義

3. 関数パラメータと戻り値での使用

[編集]
func add(a, b int) int {
    return a + b
}

func divideAndRemainder(a, b int) (int, int, error) {
    if b == 0 {
        return 0, 0, errors.New("0による除算はできません")
    }
    return a / b, a % b, nil
}

// 関数型の定義
type MathFunc func(int, int) int

ユースケース:

  • 数値演算
  • カウント値の返却
  • 結果コードの表現
  • 関数型の定義

4. 配列とスライスでの使用

[編集]
// 配列
var arr [5]int
numbers := [3]int{1, 2, 3}

// スライス
var slice []int
numbers := []int{1, 2, 3, 4, 5}
moreNumbers := make([]int, 10)      // 長さ10、容量10のスライス
evenMoreNumbers := make([]int, 5, 10) // 長さ5、容量10のスライス

ユースケース:

  • データコレクションの格納
  • 数値シーケンスの表現
  • バッファサイズの定義
  • 数値リストの操作

5. マップでのキーと値としての使用

[編集]
// マップ（キーとしてのint）
userAges := map[int]string{
    1: "Alice",
    2: "Bob",
    3: "Charlie",
}

// マップ（値としてのint）
nameAges := map[string]int{
    "Alice": 25,
    "Bob": 30,
    "Charlie": 35,
}

ユースケース:

  • IDや識別子としてのキー
  • カウントや数値データの格納
  • ルックアップテーブル
  • 頻度計算

6. 構造体のフィールドとしての使用

[編集]
type Person struct {
    ID        int
    Age       int
    Height    int // cm単位
    Weight    int // kg単位
}

type Rectangle struct {
    Width  int
    Height int
}

func (r Rectangle) Area() int {
    return r.Width * r.Height
}

ユースケース:

  • 識別子やID
  • 物理的な量の表現
  • カウンターやインデックス
  • 寸法や測定値

7. 型変換との組み合わせ

[編集]
// 他の整数型からの変換
var small int8 = 127
var normal int = int(small)

// 浮動小数点数からの変換（小数点以下切り捨て）
var pi float64 = 3.14159
var rounded int = int(pi) // 3

// 文字列と整数の変換
str := "123"
num, err := strconv.Atoi(str) // 文字列からintへ
if err != nil {
    // エラー処理
}

numStr := strconv.Itoa(42) // intから文字列へ

ユースケース:

  • データ型の互換性確保
  • 数値精度の調整
  • 外部データの取り込み
  • 表示用データの生成

8. ビット操作との組み合わせ

[編集]
// ビット演算子
a := 5      // 二進数: 101
b := 3      // 二進数: 011
c := a & b  // AND: 001 -> 1
d := a | b  // OR:  111 -> 7
e := a ^ b  // XOR: 110 -> 6
f := a << 1 // 左シフト: 1010 -> 10
g := a >> 1 // 右シフト: 10 -> 2

ユースケース:

  • フラグ操作
  • パーミッション制御
  • データ圧縮
  • ハッシュ計算
  • 高速計算

9. チャネルでの使用

[編集]
// intを送受信するチャネル
ch := make(chan int)
bufferedCh := make(chan int, 10) // バッファ付きチャネル

// ゴルーチンでの使用
go func() {
    ch <- 42 // チャネルに値を送信
}()

value := <-ch // チャネルから値を受信

ユースケース:

  • ゴルーチン間の数値データ通信
  • 同期カウンターの実装
  • イベントシグナリング
  • 処理結果の受け渡し

10. インターフェースと型アサーション

[編集]
var x interface{} = 42

// 型アサーション
if val, ok := x.(int); ok {
    fmt.Println("xはint型で値は", val)
}

// 型スイッチ
switch v := x.(type) {
case int:
    fmt.Printf("intの値: %d\n", v)
case float64:
    fmt.Printf("float64の値: %f\n", v)
default:
    fmt.Printf("未知の型: %T\n", v)
}

ユースケース:

  • 多態的なデータ処理
  • 動的型付けの模倣
  • ジェネリックな関数実装
  • 外部データの型安全な処理

11. iota（列挙型）との組み合わせ

[編集]
const (
    Sunday int = iota    // 0
    Monday               // 1
    Tuesday              // 2
    Wednesday            // 3
    Thursday             // 4
    Friday               // 5
    Saturday             // 6
)

const (
    Readable int = 1 << iota  // 1 (1 << 0)
    Writable                  // 2 (1 << 1)
    Executable                // 4 (1 << 2)
)

ユースケース:

  • 列挙型の定義
  • 連続値の自動生成
  • ビットフラグの定義
  • 定数グループの作成

12. メソッドレシーバーとしての使用

[編集]
// intに対するメソッド定義（型エイリアス使用）
type MyInt int

func (m MyInt) Double() MyInt {
    return m * 2
}

func (m MyInt) IsEven() bool {
    return m%2 == 0
}

// 使用例
var num MyInt = 5
doubled := num.Double() // 10
isEven := num.IsEven()  // false

ユースケース:

  • 基本型の拡張
  • 数値型特有の操作のカプセル化
  • 型安全な数値操作
  • ドメイン固有の数値型の作成

13. ポインタとの組み合わせ

[編集]
var x int = 10
ptr := &x        // xのアドレスを取得
fmt.Println(*ptr) // 10 (ポインタが指す値を取得)
*ptr = 20        // ポインタを通して値を変更
fmt.Println(x)    // 20

// 関数でのポインタ使用
func increment(value *int) {
    *value++
}

count := 5
increment(&count)
fmt.Println(count) // 6

ユースケース:

  • 値の参照渡し
  • 大きな数値の効率的な受け渡し
  • インプレース操作
  • ミュータブルな関数パラメータ

14. 制御構造との組み合わせ

[編集]
// for文でのカウンター
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// rangeループでのインデックス
numbers := []int{10, 20, 30, 40, 50}
for index, value := range numbers {
    fmt.Printf("index: %d, value: %d\n", index, value)
}

// if文での条件
age := 18
if age >= 18 {
    fmt.Println("成人です")
}

// switch文
status := 200
switch status {
case 200:
    fmt.Println("OK")
case 404:
    fmt.Println("Not Found")
default:
    fmt.Println("Unknown Status")
}

ユースケース:

  • ループカウンター
  • 条件評価
  • ステータスコードの判定
  • インデックス操作

15. 組み込み関数との組み合わせ

[編集]
// len, cap関数
slice := []int{1, 2, 3, 4, 5}
length := len(slice) // 5
capacity := cap(slice) // 5以上

// copy関数
src := []int{1, 2, 3}
dst := make([]int, len(src))
count := copy(dst, src) // コピーされた要素数: 3

// append関数
numbers := []int{1, 2}
numbers = append(numbers, 3, 4, 5) // [1 2 3 4 5]

// make関数
channel := make(chan int, 5) // バッファサイズ5のチャネル

ユースケース:

  • コレクションサイズの操作
  • メモリ割り当て
  • バッファサイズの指定
  • キャパシティ管理

16. 数学関数との組み合わせ

[編集]
import "math"

// int と float64 の相互変換
x := 10
y := math.Pow(float64(x), 2) // 10の2乗 = 100.0
result := int(math.Sqrt(y))  // 100の平方根 = 10

// 絶対値
absValue := int(math.Abs(float64(-5))) // 5

// 最大値・最小値
maxVal := int(math.Max(float64(10), float64(20))) // 20

ユースケース:

  • 数学的計算
  • 範囲制限
  • スケーリング操作
  • 数値分析

17. 時間操作との組み合わせ

[編集]
import "time"

// 時間操作
now := time.Now()
future := now.Add(time.Duration(24) * time.Hour) // 24時間後

// タイムアウト設定
timeout := time.Duration(5) * time.Second
time.Sleep(timeout)

// タイマー
timer := time.NewTimer(time.Duration(3) * time.Second)
<-timer.C // 3秒待機

ユースケース:

  • タイムアウト設定
  • 待機時間指定
  • 間隔指定
  • 日付計算

18. システムプログラミングでの使用

[編集]
import "os"

// ファイル権限設定
file, err := os.OpenFile("data.txt", os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
    // エラー処理
}
defer file.Close()

// プロセス終了コード
os.Exit(0) // 正常終了
os.Exit(1) // エラー終了

ユースケース:

  • ファイル操作フラグ
  • プロセス制御
  • システムコール引数
  • エラーコード

19. 並行処理との組み合わせ

[編集]
// WaitGroup
var wg sync.WaitGroup
wg.Add(5) // 5つのゴルーチンを待つ

for i := 0; i < 5; i++ {
    go func(id int) {
        defer wg.Done()
        // 処理
    }(i)
}
wg.Wait() // すべてのゴルーチンの完了を待つ

// セマフォの実装
sem := make(chan int, 3) // 最大3つの並行処理
for i := 0; i < 10; i++ {
    sem <- 1 // スロットを獲得
    go func(id int) {
        defer func() { <-sem }() // スロットを解放
        // 処理
    }(i)
}

ユースケース:

  • 同期カウンター
  • リソース制限
  • ゴルーチンの数制御
  • バッチ処理

20. コンテキストでのタイムアウト設定

[編集]
import "context"

// タイムアウト付きコンテキスト
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(5)*time.Second)
defer cancel()

// デッドライン付きコンテキスト
deadline := time.Now().Add(time.Duration(10) * time.Second)
ctx, cancel = context.WithDeadline(context.Background(), deadline)
defer cancel()

ユースケース:

  • API呼び出しのタイムアウト設定
  • キャンセル可能な操作
  • プロセス制限時間設定
  • 長時間処理の制御

intとその他の整数型の関係

[編集]

Goは複数の整数型を提供しています： 

// int型と他の整数型の相互変換
var a int = 100
var b int64 = int64(a)  // intからint64へ
var c int = int(b)      // int64からintへ

使用上の注意点

[編集]
  1. オーバーフロー: intのサイズはアーキテクチャに依存するため、移植性を考慮するなら固定サイズ型を検討
  2. 型変換: 異なる整数型間で演算する場合は明示的な型変換が必要
  3. パフォーマンス: 大抵の場合、32ビットシステムでもintを使うのが最も効率的（CPUのネイティブワードサイズに最適化されるため）
  4. 符号なし整数との使い分け: 負の値が意味を持たない場合（サイズ、長さ、カウントなど）でも、Goでは慣例的にintを使う場合が多い
  5. 型の一貫性: コード内で整数型を一貫して使用することで、不要な型変換を減らせる

int型はGoにおける最も基本的な数値型の一つであり、多くの標準ライブラリや組み込み関数で使用されています。適切に活用することでコードの可読性と効率性を高めることができます。

"https://ja.wikibooks.org/w/index.php?title=Go/int&oldid=273785" より作成