Bagaimana untuk Mengesan Limpahan Integer dengan Cekap dalam Go?

Pengesanan Limpahan Cekap dalam Go untuk Pengiraan Integer

Apabila bekerja dengan integer, terutamanya dalam konteks bahasa Lisp, kebimbangan timbul tentang limpahan integer berpotensi yang boleh membawa kepada keputusan yang salah. Mengesan limpahan sedemikian adalah penting untuk mengekalkan ketepatan pengiraan anda.

Satu pendekatan biasa untuk mengesan limpahan ialah menukar operan kepada jenis integer yang lebih besar sebelum menjalankan operasi. Walaupun ini menjamin pengesanan limpahan, ia boleh menjadi proses yang tidak cekap dan intensif memori untuk operasi aritmetik asas.

Teknik yang lebih cekap dan tepat untuk pengesanan limpahan ialah menggunakan sifat matematik penambahan integer. Sebagai contoh, apabila menambah dua integer 32-bit, limpahan berlaku apabila hasilnya melebihi nilai maksimum integer 32-bit (2^31-1) atau jatuh di bawah nilai minimum (-2^31).

Pertimbangkan coretan kod berikut untuk mengesan limpahan integer dalam Go:

package main

import (
    "errors"
    "fmt"
    "math"
)

var ErrOverflow = errors.New("integer overflow")

func Add32(left, right int32) (int32, error) {
    if right > 0 {
        if left > math.MaxInt32-right { // Check for positive overflow
            return 0, ErrOverflow
        }
    } else {
        if left < math.MinInt32-right { // Check for negative overflow
            return 0, ErrOverflow
        }
    }
    return left + right, nil
}

func main() {
    var a, b int32 = 2147483327, 2147483327
    c, err := Add32(a, b)
    if err != nil {
        // Handle integer overflow
        fmt.Println(err, a, b, c)
    }
}

Dalam coretan kod ini, kami mentakrifkan fungsi tersuai Add32 yang mengambil dua integer 32-bit sebagai input dan menyemak limpahan sebelum melaksanakan operasi tambah. Menggunakan prinsip matematik, kami menentukan keadaan yang menunjukkan limpahan (apabila keputusan melebihi maksimum atau jatuh di bawah nilai minimum yang dibenarkan).

Jika limpahan dikesan, fungsi mengembalikan ralat yang menunjukkan limpahan. Jika tidak, ia mengembalikan hasil operasi penambahan.

Menjalankan coretan kod ini akan mengeluarkan yang berikut:

integer overflow 2147483327 2147483327 0

Ini menunjukkan limpahan berlaku apabila menambah dua integer 32-bit, dan fungsi Add32 mengesan dan melaporkan ralat dengan betul. Pendekatan ini menyediakan cara yang cekap dan boleh dipercayai untuk mengesan limpahan integer dalam Go, memastikan ketepatan pengiraan anda.

Atas ialah kandungan terperinci Bagaimana untuk Mengesan Limpahan Integer dengan Cekap dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!