Fonctions puissantes : utilisez le langage Go pour mettre en œuvre quatre opérations arithmétiques afin de répondre facilement aux exigences opérationnelles complexes

Titre : Puissant : Utilisez le langage Go pour implémenter quatre opérations arithmétiques afin de faire face facilement à des besoins informatiques complexes

Avec le développement du domaine informatique, les quatre opérations arithmétiques, en tant qu'une des opérations mathématiques les plus élémentaires, sont souvent largement utilisé dans diverses utilisations de développement de logiciels. Afin de mieux répondre à des besoins informatiques complexes, de nombreux développeurs utilisent des langages de programmation efficaces tels que le langage Go pour implémenter les fonctions associées. Cet article expliquera comment utiliser le langage Go pour implémenter quatre opérations arithmétiques, de la simple addition, soustraction, multiplication et division aux opérations complexes prenant en charge les parenthèses et la préséance, aidant ainsi les lecteurs à résoudre facilement les problèmes de calcul.

Tout d’abord, nous devons clarifier les principes de base des quatre opérations arithmétiques. Les quatre opérations arithmétiques comprennent l'addition, la soustraction, la multiplication et la division. L'ordre de calcul peut être déterminé par calcul séquentiel ou basé sur les parenthèses et la priorité. En langage Go, nous pouvons implémenter ces fonctions en définissant des structures et des méthodes. Ce qui suit est un simple programme en langage Go qui implémente les quatre opérations arithmétiques de base :

package main

import (
    "fmt"
)

type Operation struct {
    operand1 float64
    operand2 float64
}

func (op Operation) Add() float64 {
    return op.operand1 + op.operand2
}

func (op Operation) Subtract() float64 {
    return op.operand1 - op.operand2
}

func (op Operation) Multiply() float64 {
    return op.operand1 * op.operand2
}

func (op Operation) Divide() float64 {
    if op.operand2 != 0 {
        return op.operand1 / op.operand2
    } else {
        return 0
    }
}

func main() {
    op := Operation{operand1: 10, operand2: 5}
    
    fmt.Println("加法结果：", op.Add())
    fmt.Println("减法结果：", op.Subtract())
    fmt.Println("乘法结果：", op.Multiply())
    fmt.Println("除法结果：", op.Divide())
}

Dans l'exemple ci-dessus, une structure Operation est définie, contenant deux opérandes operand1 et operand2, et implémente quatre méthodes opérationnelles d'addition, de soustraction, de multiplication et de division respectivement. Dans la fonction main, un objet Operation est créé pour appeler ces méthodes et imprimer les résultats. Operation结构体，包含两个操作数operand1和operand2，并分别实现了加法、减法、乘法和除法四种运算的方法。在main函数中，创建了一个Operation对象，分别调用这些方法并打印结果。

除了基本的四则运算，有时候我们还需要处理包含括号和优先级的复杂运算表达式。这时候可以借助栈的数据结构来实现。下面是一个实现带括号和优先级的四则运算的Go语言程序示例：

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func calculate(expression string) float64 {
    expression = strings.ReplaceAll(expression, " ", "") // 去除空格
    stack := []string{}
    tokens := strings.Split(expression, "")

    for _, token := range tokens {
        if token == "(" {
            stack = append(stack, token)
        } else if token == ")" {
            var current string
            for {
                current, stack = stack[len(stack)-1], stack[:len(stack)-1]
                if current == "(" {
                    break
                }
                result, _ := strconv.ParseFloat(current, 64)
                stack = append(stack, strconv.FormatFloat(result, 'f', -1, 64))
            }
        } else {
            stack = append(stack, token)
        }
    }

    for len(stack) > 1 {
        op2, _ := strconv.ParseFloat(stack[len(stack)-1], 64)
        op1, _ := strconv.ParseFloat(stack[len(stack)-3], 64)
        operator := stack[len(stack)-2]
        var result float64

        switch operator {
        case "+":
            result = op1 + op2
        case "-":
            result = op1 - op2
        case "*":
            result = op1 * op2
        case "/":
            result = op1 / op2
        }

        stack = stack[:len(stack)-3]
        stack = append(stack, strconv.FormatFloat(result, 'f', -1, 64))
    }

    result, _ := strconv.ParseFloat(stack[0], 64)
    return result
}

func main() {
    expression := "(10 + 5) * 2"
    result := calculate(expression)
    fmt.Println("复杂运算结果：", result)
}

在上面的示例中，calculate函数可以对包含括号和优先级的复杂运算表达式进行计算。通过栈来处理表达式的括号结构，并根据四则运算的优先级依次计算得出最终结果。在main函数中，我们定义了一个包含括号的表达式(10 + 5) * 2，通过calculate

En plus des quatre opérations arithmétiques de base, nous devons parfois également traiter des expressions d'opérations complexes, notamment les parenthèses et la priorité. Ceci peut être réalisé à l'aide de la structure de données de la pile. Voici un exemple de programme en langage Go qui implémente quatre opérations arithmétiques avec parenthèses et priorité :

rrreee

Dans l'exemple ci-dessus, la fonction calculer peut calculer des expressions arithmétiques complexes contenant des parenthèses et une priorité. La structure entre parenthèses de l'expression est traitée via la pile et le résultat final est calculé séquentiellement en fonction de la priorité des quatre opérations arithmétiques. Dans la fonction main, on définit une expression (10 + 5) * 2 contenant des parenthèses, et le résultat est calculé via la fonction calculate et imprimer. 🎜🎜En résumé, la mise en œuvre des quatre opérations arithmétiques via le langage Go peut non seulement résoudre les besoins opérationnels de base, mais également gérer facilement les expressions d'opérations complexes contenant des parenthèses et des priorités. Les développeurs peuvent optimiser le code en fonction des besoins réels et obtenir des fonctions informatiques plus riches en fonctionnalités. J'espère que cet article pourra aider les lecteurs à mieux comprendre comment utiliser le langage Go pour implémenter quatre opérations arithmétiques et faire face à des exigences informatiques complexes. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!