package main 
import ( 
   "fmt" 
   "unsafe" 
) 

var ( 
   a uint8   = 72 
   b int32   = 240 
   c uint64  = 1234564321 
   d float32 = 12432345.232 
   e int64   = -1233453443434 
   f float64 = -1.43555622362467 
   g int16   = 32000 
   h [5]rune = [5]rune{'O', 'n', 'T', 'o', 'p'} 
) 

func main() { 
   fmt.Printf("a = %v [%T, %d bits]\n", a, a, unsafe.Sizeof(a)*8) 
   fmt.Printf("b = %v [%T, %d bits]\n", b, b, unsafe.Sizeof(b)*8) 
   fmt.Printf("c = %v [%T, %d bits]\n", c, c, unsafe.Sizeof(c)*8) 
   fmt.Printf("d = %v [%T, %d bits]\n", d, d, unsafe.Sizeof(d)*8) 
   fmt.Printf("e = %v [%T, %d bits]\n", e, e, unsafe.Sizeof(e)*8) 
   fmt.Printf("f = %v [%T, %d bits]\n", f, f, unsafe.Sizeof(f)*8) 
   fmt.Printf("g = %v [%T, %d bits]\n", g, g, unsafe.Sizeof(g)*8) 
   fmt.Printf("h = %v [%T, %d bits]\n", h, h, unsafe.Sizeof(h)*8) 
} 

$>go run alloc.go
a = 72 [uint8, 8 bits]
b = 240 [int32, 32 bits]
c = 1234564321 [uint64, 64 bits]
d = 1.2432345e+07 [float32, 32 bits]
e = -1233453443434 [int64, 64 bits]
f = -1.43555622362467 [float64, 64 bits]
g = 32000 [int16, 16 bits]
h = [79 110 84 111 112] [[5]int32, 160 bits]

package main 
import ( 
   "math" 
   "unsafe" 
) 

var _ int8 = 12 
var _ int16 = -400 
var _ int32 = 12022 
var _ int64 = 1 << 33 
var _ int = 3 + 1415 

var _ uint8 = 18 
var _ uint16 = 44 
var _ uint32 = 133121 
var i uint64 = 23113233 
var _ uint = 7542 
var _ byte = 255 
var _ uintptr = unsafe.Sizeof(i) 

var _ float32 = 0.5772156649 
var _ float64 = math.Pi 

var _ complex64 = 3.5 + 2i 
var _ complex128 = -5.0i 

func main() { 
   fmt.Println("all types declared!") 
} 

package main 
import "fmt" 

func main() { 
   vals := []int{ 
       1024, 
       0x0FF1CE, 
       0x8BADF00D, 
       0xBEEF, 
       0777, 
   } 
   for _, i := range vals { 
         if i == 0xBEEF { 
               fmt.Printf("Got %d\n", i) 
               break 
         } 
   } 
} 

package main 

import "fmt" 

func main() { 
   p := 3.1415926535 
   e := .5772156649 
   x := 7.2E-5 
   y := 1.616199e-35 
   z := .416833e32 

   fmt.Println(p, e, x, y, z) 
} 

package main 
import "fmt" 

func main() { 
   a := -3.5 + 2i 
   fmt.Printf("%v\n", a) 
   fmt.Printf("%+g, %+g\n", real(a), imag(a)) 
} 

package main 
import "fmt" 

func main() { 
   var readyToGo bool = false 
   if !readyToGo { 
       fmt.Println("Come on") 
   } else { 
       fmt.Println("Let's go!") 
   } 
} 

$>go run runes.go
8
9
10
632
2438
35486
873
250
37 

var ( 
   txt2 = "\u6C34\x20brings\x20\x6c\x69\x66\x65." 
   txt3 = ` 
   \u6C34\x20 
   brings\x20 
   \x6c\x69\x66\x65\. 
   ` 
) 

golang.fyi/ch04/pointers.go

给定一个类型为`T`的变量，Go 使用表达式`*T`作为其指针类型。类型系统认为`T`和`*T`是不同的，不可替代。指针不指向任何东西时的零值是地址 0，由文字*常量*nil 表示。

## 地址运算符

指针值只能分配给其声明类型的地址。在 Go 中执行此操作的一种方法是使用地址运算符`&`（与符号）获取变量的地址值，如下例所示：

golang.fyi/ch04/pointers.go

指针类型为`*int`的变量`aptr`被初始化，并使用表达式`&a`为变量`a`分配地址值，如下所示：

当变量`a`存储实际值时，我们说`aptr`指向`a`。以下显示了变量`a`值及其分配给`aptr`的存储位置的程序输出：

分配的地址值将始终相同（始终指向`a`），无论在代码中的何处可以访问`aptr`。还值得注意的是，Go 不允许对数字、字符串和布尔类型使用带文字常量的地址运算符。因此，以下内容将不会编译：

但是，当使用文字常量初始化复合类型（如 struct 和 array）时，该规则有一个语法上的例外。以下程序说明了此类场景：

golang.fyi/ch04/address2.go

在前面的代码段中，address 运算符直接与复合文字`&struct{ x, y int }{44, 55}`和`&[2]string{"A", "B"}` 一起使用，分别返回指针类型`*struct { x int; y int }`和`*[2]string`。这是一种语法上的甜点，它消除了将值分配给变量，然后检索其分配的地址的中间步骤。

## 新的（）函数

内置函数*新增（<类型>*也可用于初始化指针值。它首先为指定类型的零值分配适当的内存。然后，函数返回新创建的值的地址。以下程序使用`new()`函数初始化变量`intptr`和`p`：

golang.fyi/ch04/newptr.go

变量`intptr`初始化为`*int`，变量`p`初始化为`*struct{first, last string}`。一旦初始化，这两个值将在代码的后面相应地更新。当初始化时实际值不可用时，您可以使用`new()`函数以零值初始化指针变量。

## 指针间接寻址-访问引用值

如果您只有一个地址，您可以通过对指针值本身应用`*`运算符（或取消引用）来访问它所指向的值。下面的程序在函数`double()`和`cap()`中说明了这一思想：

golang.fyi/ch04/derefptr.go

在前面的代码中，函数`double()`中的表达式`*x = *x * 2`可以分解如下，以了解其工作原理：

<colgroup><col> <col></colgroup> 
| **表达式** | **步骤** |
| 

 | 原始表达式，其中 `x`为`*int`类型。 |
| 

 | 通过将`*` 应用于地址值来解引用指针。 |
| 

 | `*(*x) = 3`的解引用值。 |
| 

 | 此表达式的右侧取消引用`x`的值。它将使用结果 6 进行更新。 |

在函数`cap()`中，使用类似的方法访问和更新`struct{first, last string}`类型的复合变量`p`中的字段。然而，在处理复合材料时，这个成语更宽容。无需写入`*p.first`即可访问指针的字段值。我们可以放下`*`直接使用`p.first = strings.ToUpper(p.first).`

# 类型声明

在 Go 中，可以将一个类型绑定到一个标识符，以创建一个新的命名类型，该类型可以在需要该类型的地方被引用和使用。声明类型采用以下常规格式：

*类型<名称标识符><基础类型名称>*

类型声明以关键字`type`开头，后跟*名称标识符*和现有*基础类型*的名称。基础类型可以是内置的命名类型，如以下类型声明片段中所示的数值类型、布尔类型或字符串类型之一：

### 注

类型声明还可以使用复合*类型文字*作为其基础类型。复合类型包括数组、切片、映射和结构。本节重点介绍非复合类型。有关复合类型的详细信息，请参阅[第 7 章](07.html "Chapter 7. Composite Types")、*复合类型*。

以下示例说明了命名类型如何以其最基本的形式工作。示例中的代码转换温度值。每个温度单位由一个声明的类型表示，包括`fahrenheit`、`celsius`和`kelvin`。

golang.fyi/ch04/typedef。

在前面的代码段中，新声明的类型都基于底层内置的数字类型`float64`。声明新类型后，可以将其分配给变量并参与表达式，就像其基础类型一样。新声明的类型将具有相同的零值，并且可以在其基础类型之间进行转换。

# 类型转换

一般来说，Go 认为每种类型都是不同的。这意味着在正常情况下，不同类型的值在赋值、函数参数和表达式上下文中是不可替换的。这对于内置类型和声明类型都是如此。例如，由于类型不匹配，以下情况将导致生成错误：

golang.fyi/ch04/type_conv.go

表达式`actual + count`导致生成时错误，因为两个变量的类型不同。即使变量`actual`和`count`是数值类型，并且`int32`和`int`具有相同的内存表示，编译器仍然拒绝该表达式。

声明的命名类型及其基础类型也是如此。编译器将拒绝分配`var event int = sig`，因为类型`signal`被认为与类型`int`不同。即使`signal`使用`int`作为其基础类型，这也是事实。

要跨越类型边界，Go 支持将值从一种类型转换为另一种类型的类型转换表达式。类型转换使用以下格式完成：

*<目标\类型>（<值或表达式>）*

以下代码段通过将变量转换为正确的类型修复了前面的示例：

golang.fyi/ch04/type_conv2.go

请注意，在前面的代码段赋值表达式中，`var test int32 = int32(actual) + count`将变量`actual`转换为适当的类型，以匹配表达式的其余部分。类似地，表达式`var event int = int(sig)`转换变量`sig`以匹配赋值中的目标类型`int`。

转换表达式通过显式更改封闭值的类型来满足赋值。显然，并非所有类型都可以从一种转换为另一种。下表总结了适当且允许进行类型转换的常见情况：

<colgroup><col> <col></colgroup> 
| **说明** | **代码** |
| 目标类型和转换值都是简单的数字类型。 | 

 |
| 目标类型和转换后的值都是复杂的数字类型。 | 

 |
| 目标类型和转换后的值具有相同的基础类型。 | 

 |
| 目标类型是字符串，转换后的值是有效的整数类型。 | 

 |
| 目标类型是字符串，转换后的值是字节片、int32 或符文。 | 

 |
| 目标类型是字节、int32 或符文值的切片，转换后的值是字符串。 |