四时宝库

编码的实现环境是go1.15.6、LiteIDE X37.3、win7。是《Go语言圣经》的练习及作业，个别代码有修改，仅供交流学习之用。

// Boiling prints the boiling point of water.

package main
import "fmt"
const boilingF = 212.0
func main() {
    var f = boilingF
    var c = (f - 32) * 5 / 9
    fmt.Printf("boiling point = %goF or %goC \n", f, c)
    // Output:
    // boiling point = 212°F or 100°C
}

// Ftoc prints two Fahrenheit-to-Celsius conversions.

package main
import "fmt"
const boilingF = 212.0
func main() {
    const freezingF, boilingF = 32.0, 212.0
    fmt.Printf("%goF = %goC \n", freezingF, fToC(freezingF))
    fmt.Printf("%goC = %goF \n", boilingF, fToC(boilingF))
}
func fToC(f float64) float64 {
    return (f - 32) * 5 / 9
}

// Echo4 prints its command-line arguments.

// 指针是实现标准库中flag包的关键技术，它使用命令行参数来设置对应变量的值。

package main
import (
    "fmt"
    "flag"
    "strings"
)
// 调用flag.Bool函数会创建一个新的对应布尔型标志参数的变量。它有三个属性：
// 第一个是命令行标志参数的名字“n”，然后是该标志参数的默认值（这里是false），最后是该标志参数对应的描述信息。
// 如果用户在命令行输入了一个无效的标志参数，或者输入-h或-help参数，那么将打印所有标志参数的名字、默认值和描述信息。
var n = flag.Bool("n", false, "省略行尾换行符(omit trailing newline)")
var sep = flag.String("s", " ", "分隔符(separator)")   //调用flag.String函数将创建一个对应字符串类型的标志参数变量。
func main() {
    // 当程序运行时，必须在使用标志参数对应的变量之前先调用flag.Parse函数，用于更新每个标志参数对应变量的值（之前是默认值）。
    // 如果在flag.Parse函数解析命令行参数时遇到错误，默认将打印相关的提示信息，然后调用os.Exit(2)终止程序。
    flag.Parse()
    // 对于非标志参数的普通命令行参数可以通过调用flag.Args()函数来访问，返回值对应一个字符串类型的slice。
    fmt.Print(strings.Join(flag.Args(), *sep))  // sep和n变量分别是指向对应命令行标志参数变量的指针
    if !*n {
        fmt.Println()
    }
    var ii int
    var ss string
    var bb bool
    var ff interface{}
    fmt.Printf("整型、字符串型、布尔型、空接口的默认值分别是：", ii, ss, bb, ff)
    // Output:
    // boiling point = 212°F or 100°C
}

// Cf converts its numeric argument to Celsius and Fahrenheit.

// 执行命令：go run cf.go 22

package main
import (
    "fmt"
    "os"
    "strconv"
    "gopl.io/tempconv"
)
func main() {
    for _, arg := range os.Args[1:] {
        t, err := strconv.ParseFloat(arg, 64)
        if err != nil {
            fmt.Fprintf(os.Stderr, "cf: %v\n", err)
            os.Exit(1)
        }
        fmt.Println(t)
        f := tempconv.Fahrenheit(t)
        c := tempconv.Celsius(t)
        fmt.Printf("%s = %s, %s = %s\n", f, tempconv.FToC(f), c, tempconv.CToF(c))
    }
}

// popcount 定义了一个PopCount函数，用于返回一个数字中含二进制1bit的个数。

package main
import (
    "fmt"
)
var pc [256]byte
func init() {
    for i := range pc {
        pc[i] = pc[i/2] + byte(i&1)
    }
    fmt.Println(pc, 6&1)
}
// pc[i] is the population count of i.可代替初始化函数
/*var pc [256]byte func() pc [256]byte {
    for i := range pc {
        pc[i] = pc[i/2] + byte(i&1)
    }
}*/
// PopCount returns the population count (number of set bits) of x.
func PopCount(x int64) int {
    return int(pc[byte(x>>(0*8))] +
        pc[byte(x>>(1*8))] +
        pc[byte(x>>(2*8))] +
        pc[byte(x>>(3*8))] +
        pc[byte(x>>(4*8))] +
        pc[byte(x>>(5*8))] +
        pc[byte(x>>(6*8))] +
        pc[byte(x>>(7*8))])
}
func main() {
    fmt.Println(PopCount(7))
}