Golang中指针的数学运算解析

Golang中指针的数学运算解析 我有两个浮点数值作为指针。

var a *float64
var b *float64

a = 3.5
b = 5.5

a + b = (操作符 + 未在指针上定义)

我该如何使用操作符和指针？

4 回复

什么数据库？什么更新器？它如何消费JSON？

更多关于Golang中指针的数学运算解析的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


这段代码无法编译，因为你不能将浮点数字面量赋值给指针，也不能获取浮点数字面量的地址。

为什么不直接使用浮点数呢？

当我将浮点数设置为0.0时，marshaler会认为这个键值是空的，并在json中将其省略。如果float64是指针，那么可以将值设置为0。是的，我知道可以使用模式“json:key, omitempty”，但那样我的数据库更新器就无法正常工作。

在Go语言中，指针本身不支持数学运算，但可以通过解引用指针来操作其指向的值。以下是几种处理指针数值运算的方法：

方法1：直接解引用指针

package main

import "fmt"

func main() {
    var a *float64
    var b *float64
    
    // 分配内存并赋值
    aVal := 3.5
    bVal := 5.5
    a = &aVal
    b = &bVal
    
    // 解引用进行运算
    sum := *a + *b
    product := *a * *b
    difference := *a - *b
    quotient := *a / *b
    
    fmt.Printf("Sum: %.2f\n", sum)           // 输出: Sum: 9.00
    fmt.Printf("Product: %.2f\n", product)   // 输出: Product: 19.25
    fmt.Printf("Difference: %.2f\n", difference) // 输出: Difference: -2.00
    fmt.Printf("Quotient: %.2f\n", quotient) // 输出: Quotient: 0.64
}

方法2：使用辅助函数

package main

import "fmt"

// 指针加法函数
func addPtr(a, b *float64) float64 {
    if a == nil || b == nil {
        return 0
    }
    return *a + *b
}

// 指针乘法函数
func multiplyPtr(a, b *float64) float64 {
    if a == nil || b == nil {
        return 0
    }
    return *a * *b
}

func main() {
    x := 3.5
    y := 5.5
    ptrX := &x
    ptrY := &y
    
    result := addPtr(ptrX, ptrY)
    fmt.Printf("Addition result: %.2f\n", result)  // 输出: Addition result: 9.00
    
    result = multiplyPtr(ptrX, ptrY)
    fmt.Printf("Multiplication result: %.2f\n", result)  // 输出: Multiplication result: 19.25
}

方法3：使用结构体封装

package main

import "fmt"

type FloatPtr struct {
    value *float64
}

func (f *FloatPtr) Add(other *FloatPtr) *float64 {
    if f.value == nil || other.value == nil {
        return nil
    }
    result := *f.value + *other.value
    return &result
}

func (f *FloatPtr) Multiply(other *FloatPtr) *float64 {
    if f.value == nil || other.value == nil {
        return nil
    }
    result := *f.value * *other.value
    return &result
}

func main() {
    a := 3.5
    b := 5.5
    
    ptrA := &FloatPtr{value: &a}
    ptrB := &FloatPtr{value: &b}
    
    sumPtr := ptrA.Add(ptrB)
    if sumPtr != nil {
        fmt.Printf("Sum: %.2f\n", *sumPtr)  // 输出: Sum: 9.00
    }
    
    productPtr := ptrA.Multiply(ptrB)
    if productPtr != nil {
        fmt.Printf("Product: %.2f\n", *productPtr)  // 输出: Product: 19.25
    }
}

方法4：使用指针接收器的方法

package main

import "fmt"

type Calculator struct {
    value float64
}

func (c *Calculator) Add(other *Calculator) float64 {
    return c.value + other.value
}

func (c *Calculator) Subtract(other *Calculator) float64 {
    return c.value - other.value
}

func (c *Calculator) Multiply(other *Calculator) float64 {
    return c.value * other.value
}

func (c *Calculator) Divide(other *Calculator) float64 {
    if other.value == 0 {
        return 0
    }
    return c.value / other.value
}

func main() {
    calc1 := &Calculator{value: 3.5}
    calc2 := &Calculator{value: 5.5}
    
    fmt.Printf("Addition: %.2f\n", calc1.Add(calc2))        // 输出: Addition: 9.00
    fmt.Printf("Subtraction: %.2f\n", calc1.Subtract(calc2)) // 输出: Subtraction: -2.00
    fmt.Printf("Multiplication: %.2f\n", calc1.Multiply(calc2)) // 输出: Multiplication: 19.25
    fmt.Printf("Division: %.2f\n", calc1.Divide(calc2))     // 输出: Division: 0.64
}

关键点总结：

  1. 指针解引用：使用 * 操作符获取指针指向的值
  2. 空指针检查：在操作指针前应检查是否为 nil
  3. 内存安全：确保指针指向有效的内存地址
  4. 操作符优先级：解引用操作符 * 的优先级高于数学运算符

最常用的方法是直接解引用指针：*a + *b。这种方法简单直接，适用于大多数场景。

回到顶部