Go实现支持任意终端输入类型的栈遇问题咨询

我正在实现一个支持从终端输入任意类型元素的Stack，暂未实现栈顶元素等其他功能，过程中遇到了以下问题：

案例1：不使用终端输入（正常工作） #

type Stack struct {
    elements []interface{}
}

func (s *Stack) Init() {
    s.elements = make([]interface{}, 0)
}
func (s *Stack) Push(i interface{}) {
    s.elements = append(s.elements, i)
}

func main() {
    s := Stack{}
    s.Init()
    s.Push("gi")
    s.Push(2)
    fmt.Println(s.elements) // Output: [gi 2]
}

此代码运行符合预期，能存储不同类型元素。

案例2：终端输入，变量声明为int类型 #

func main() {
    s := Stack{}
    s.Init()
    var a int
    fmt.Printf("enter element to be pushed: ")
    fmt.Scanf("%v", &a)
    s.Push(a)
    fmt.Println(s.elements) // 输入整数时Output: [2]
}

注：若输入字符串，输出为[0]

案例3：终端输入，变量声明为string类型 #

func main() {
    s := Stack{}
    s.Init()
    var a string
    fmt.Printf("enter element to be pushed: ")
    fmt.Scanf("%v", &a)
    s.Push(a)
    fmt.Println(s.elements) // 输入字符串时Output: ["gi"]
}

注：若输入整数，输出为[2]，且该元素类型为string

问题解答 #

问题1：为何int类型变量无法接收字符串输入，输出为[0]？ #

Go的fmt.Scanf在处理类型不匹配的输入时，不会修改目标变量的值，而是保留其零值。当声明var a int时，a的初始值是0，输入字符串无法解析为int类型，Scanf执行失败，a仍然是0，所以Push后栈里是[0]。

问题2：为何string类型变量可以接收整数输入并以string类型存储？ #

fmt.Scanf的%v格式符对于string类型的目标变量，会读取输入的原始字符序列（直到空白符）。输入整数时，这些数字字符会被直接读取为string类型，这符合Go强类型特性——变量类型是string，存储的就是string值，并非自动转换类型，而是直接读取输入内容作为字符串。

案例4：尝试用interface{}接收终端输入（失败） #

func main() {
    s := Stack{}
    s.Init()
    var a interface{}
    fmt.Printf("enter element to be pushed: ")
    fmt.Scanf("%v", &a)
    s.Push(a)
    fmt.Println(s.elements) // Output: [<nil>]
}

无法接收整数或字符串输入，输出为[<nil>]

案例5：尝试用类型断言处理输入（失败） #

func (s *Stack) Push(i interface{}) {
    switch v := i.(type) {
    case int:
        s.elements = append(s.elements, v)

    case string:
        s.elements = append(s.elements, v)
    }
}

func main() {
    s := Stack{}
    s.Init()
    var a interface{}
    fmt.Printf("enter element to be pushed: ")
    fmt.Scanf("%v", &a)
    s.Push(a)
    fmt.Println(s.elements) // Output: []
}

无论输入何种类型，输出均为[]

问题3：如何实现从终端输入不同类型元素并存入Stack？ #

fmt.Scanf无法自动推断输入的类型并填充到interface{}变量中，因为%v对于interface{}目标，默认不会解析为具体类型，需要手动处理输入。

解决思路是先读取输入的原始字符串，然后尝试将其解析为不同类型（如int、string等），根据解析结果存入栈：

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

type Stack struct {
    elements []interface{}
}

func (s *Stack) Init() {
    s.elements = make([]interface{}, 0)
}

func (s *Stack) Push(i interface{}) {
    s.elements = append(s.elements, i)
}

func main() {
    s := Stack{}
    s.Init()
    scanner := bufio.NewScanner(os.Stdin)
    fmt.Printf("enter element to be pushed: ")
    scanner.Scan()
    input := strings.TrimSpace(scanner.Text())

    // 先尝试解析为int，失败则作为string存储
    if num, err := strconv.Atoi(input); err == nil {
        s.Push(num)
    } else {
        s.Push(input)
    }

    fmt.Println(s.elements)
}

测试结果：

• 输入2，输出[2]（类型为int）
• 输入gi，输出[gi]（类型为string）

如果需要支持更多类型（如float64），可以继续添加解析逻辑：

// 扩展支持float64
if num, err := strconv.ParseFloat(input, 64); err == nil {
    s.Push(num)
} else if num, err := strconv.Atoi(input); err == nil {
    s.Push(num)
} else {
    s.Push(input)
}

内容的提问来源于stack exchange，提问作者rajesh