Question

在其中一个排序示例中，他们使用以下代码：

package main

import (
    "fmt"
    "sort"
)

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%s: %d", p.Name, p.Age)
}

// ByAge implements sort.Interface for []Person based on
// the Age field.
type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }

func main() {
    people := []Person{
        {"Bob", 31},
        {"John", 42},
        {"Michael", 17},
        {"Jenny", 26},
    }

    fmt.Println(people)
    sort.Sort(ByAge(people))
    fmt.Println(people)

}

Sort的行对我来说有点混乱：

sort.Sort(ByAge(people))

ByAge（人）是否会生成某种复制传入数组的构造函数？我不确定我是否理解新类型ByAge如何能够访问这些元素。

Answer 1

语法foo(expr)其中foo是一种类型而expr是类型转换，，如spec中所述：

转化

转化是表单T(x)的表达式，其中T是一种类型，x   是一个可以转换为T类型的表达式。
Conversion = Type "(" Expression [ "," ] ")" .
如果类型以运算符*或<-，或者类型以关键字func开头没有结果列表，必须在必要时用括号括起来以避免歧义：
*Point(p)        // same as *(Point(p))
(*Point)(p)      // p is converted to *Point
<-chan int(c)    // same as <-(chan int(c))
(<-chan int)(c)  // c is converted to <-chan int
func()(x)        // function signature func() x
(func())(x)      // x is converted to func()
(func() int)(x)  // x is converted to func() int
func() int(x)    // x is converted to func() int (unambiguous)
常数值x可以   在任何这些情况下都要转换为T类型：


x可以使用T类型的值表示。

x是一个浮点常量，T是浮点类型，x在使用IEEE 754进行舍入后可由T类型的值表示圆形到均匀的规则。常量T(x)是舍入值。

x是一个整数常量，T是一个字符串类型。在这种情况下，适用与非常数x相同的规则。


转换常量会产生类型化的常量。
uint(iota)               // iota value of type uint
float32(2.718281828)     // 2.718281828 of type float32
complex128(1)            // 1.0 + 0.0i of type complex128
float32(0.49999999)      // 0.5 of type float32
string('x')              // "x" of type string
string(0x266c)           // "♬" of type string
MyString("foo" + "bar")  // "foobar" of type MyString
string([]byte{'a'})      // not a constant: []byte{'a'} is not a constant
(*int)(nil)              // not a constant: nil is not a constant, *int is not a boolean, numeric, or string type
int(1.2)                 // illegal: 1.2 cannot be represented as an int
string(65.0)             // illegal: 65.0 is not an integer constant
非常数值x可以转换为类型T.   在任何这些情况下：


x可分配给T。

x的类型和T具有相同的基础类型。

x的类型和T是未命名的指针类型及其指针基类型   具有相同的基础类型。

x的类型和T都是整数或浮点类型。 x的类型和T都是复杂类型。

x是一个整数或一个字节或符文切片，T是一个字符串类型。

x是一个字符串，T是一个字节或符文切片。


具体规则适用于   （非常量）数值类型之间的转换或来自a的转换   字符串类型。这些转化可能会改变x和x的表示形式   产生运行时间成本。所有其他转换只会更改类型   不是{{1}}的表示。

没有语言机制可以在指针之间进行转换   整数。包unsafe在其下实现此功能   受限制的情况。

有关详细信息，请参阅链接页面。

这里是否生成了某种构造函数？

1 个答案:

转化