15

我有一行包含 3 个数字，我想用 fmt.Scanln() 从标准输入读取，但这段代码不起作用： 

X := make([]int, 3)
fmt.Scanln(X...)
fmt.Printf("%v\n", X)

我收到此错误消息： 

cannot use X (type []int) as type []interface {} in function argument

我不明白。

4

5 回答 5

13

惯用的 Go 将是：

func read(n int) ([]int, error) {
  in := make([]int, n)
  for i := range in {
    _, err := fmt.Scan(&in[i])
    if err != nil {
       return in[:i], err
    }
  }
  return in, nil
}

interface{}没有任何意义。如果没有必要，请不要使用它。

于 2015-11-19T18:33:38.507 回答
9

例如，

package main

import "fmt"

func intScanln(n int) ([]int, error) {
    x := make([]int, n)
    y := make([]interface{}, len(x))
    for i := range x {
        y[i] = &x[i]
    }
    n, err := fmt.Scanln(y...)
    x = x[:n]
    return x, err
}

func main() {
    x, err := intScanln(3)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("%v\n", x)
}

输入：

1 2 3

输出：

[1 2 3]
于 2013-03-14T18:01:00.580 回答
1

我认为正确的版本应该是

X := make([]int, 3)
fmt.Scanln(&X[0], &X[1], &X[2])
fmt.Printf("%v\n", X)
于 2013-03-14T16:01:27.357 回答
1

此错误消息发生在 b/c 没有合理的方式转换[]int为[]interface{}. 请注意，这是指切片。所以你使用的语法是正确的，但fmt.Scanln期望[]interface{}. 这在 pkg 之外有影响fmt。

我看到的原因是因为 Go 让您可以控制内存布局，因此它目前没有合理的方法来进行切片转换。这意味着您需要在将其传递给期望给定类型切片的函数之前手动进行转换。例如：

package main

import (
    "fmt"
)

func main() {
    x := make([]int, 3)
    y := make([]interface{}, 3)
    y[0] = x[0]
    y[1] = x[1]
    y[2] = x[2]

    fmt.Println(y...)
}

或者更一般的东西：

    x := make([]int, 3)
    y := make([]interface{}, len(x))
    for i, v := range x {
        y[i] = v
    }

    fmt.Println(y...)

关于您的具体问题，请参见以下内容：

    x := make([]*int, 3)
    for i := range x {
        x[i] = new(int)
    }

    y := make([]interface{}, 3)

    for i, v := range x {
        y[i] = v
    }

    if _, err := fmt.Scanln(y...); err != nil {
        fmt.Println("Scanln err: ", err)
    }

    for _, v := range y {
        val := v.(*int)
        fmt.Println(*val)
    }
于 2013-03-14T16:19:44.340 回答
0

我在评论中看到你说线条可以有不同的长度。在这种情况下，您可以实现自己的fmt.Scanner：

package main

import (
   "bytes"
   "fmt"
)

type slice struct {
   tok []int
}

func (s *slice) Scan(state fmt.ScanState, verb rune) error {
   tok, err := state.Token(false, func(r rune) bool { return r != '\n' })
   if err != nil { return err }
   if _, _, err := state.ReadRune(); err != nil {
      if len(tok) == 0 {
         panic(err)
      }
   }
   b := bytes.NewReader(tok)
   for {
      var d int
      _, err := fmt.Fscan(b, &d)
      if err != nil { break }
      s.tok = append(s.tok, d)
   }
   return nil
}

func main() {
   var s slice
   fmt.Scan(&s)
   fmt.Println(s.tok)
}

https://golang.org/pkg/fmt#Scanner

于 2021-05-27T18:20:17.940 回答