Implémenter un opérateur arithmétique de base en utilisant le langage Go

Le langage Go est un langage compilé open source à typage statique qui a reçu une attention et une utilisation généralisées pour sa simplicité, son efficacité et sa facilité d'expansion. Cet article explique comment utiliser le langage Go pour écrire une simple calculatrice arithmétique à quatre et fournit des exemples de code spécifiques.

Tout d'abord, nous devons définir plusieurs structures de données de base pour représenter les expressions opérationnelles et les opérateurs. Nous pouvons utiliser des structures pour représenter les opérateurs et les opérandes, et utiliser des types d'énumération pour limiter la plage de valeurs des opérateurs.

type Operator int

const (
    Add Operator = iota
    Subtract
    Multiply
    Divide
)

type Operand struct {
    value float64
}

type Expression struct {
    operator Operator
    leftOperand  Operand
    rightOperand Operand
}

Ensuite, nous pouvons implémenter une fonction pour analyser l'expression d'opération saisie par l'utilisateur et renvoyer un objet Expression.

func parseExpression(input string) (Expression, error) {
    // 解析输入字符串并生成Expression对象
    // 如果输入不合法则返回错误信息
}

Ensuite, nous pouvons implémenter une fonction de calcul pour calculer le résultat en fonction de l'objet Expression donné.

func calculate(expression Expression) float64 {
    switch expression.operator {
    case Add:
        return expression.leftOperand.value + expression.rightOperand.value
    case Subtract:
        return expression.leftOperand.value - expression.rightOperand.value
    case Multiply:
        return expression.leftOperand.value * expression.rightOperand.value
    case Divide:
        return expression.leftOperand.value / expression.rightOperand.value
    default:
        return 0
    }
}

Enfin, nous pouvons écrire une fonction principale pour gérer les entrées de l'utilisateur et appeler des fonctions d'analyse et de calcul pour afficher les résultats.

func main() {
    fmt.Println("欢迎使用四则运算计算器！")
    fmt.Println("请输入一个四则运算表达式：")
    
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        input := scanner.Text()
        
        expression, err := parseExpression(input)
        if err != nil {
            fmt.Println("输入无效，请重新输入")
            continue
        }
        
        result := calculate(expression)
        fmt.Println("结果是：", result)
    }
    
    if err := scanner.Err(); err != nil {
        fmt.Println("读取输入失败：", err)
    }
}

Ce qui précède est un exemple simple de code d'une calculatrice à quatre arithmétiques écrite en langage Go. En définissant des structures de données et en implémentant des fonctions d'analyse et de calcul, nous pouvons facilement traiter les résultats d'entrée et de sortie des utilisateurs. Bien sûr, cet exemple peut être étendu et optimisé, par exemple en ajoutant plus d'opérateurs et en prenant en charge des expressions d'opérations complexes, mais le cadre et les idées de base sont les mêmes.

Pour résumer, le langage Go est un langage de programmation puissant avec lequel vous pouvez facilement écrire diverses applications, dont quatre calculatrices arithmétiques. J'espère que l'exemple de code et les explications contenus dans cet article pourront vous être utiles.

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!