Gelei Blog

golang圣经第二章：程序结构

2023-10-13T00:00:00+00:00

本章介绍Go语言程序的命名，声明，基本元素结构、变量、新类型定义、包和文件、以及作用域

2.1 命名

变量名称有大小写区分

关键字

break      default       func     interface   select
case       defer         go       map         struct
chan       else          goto     package     switch
const      fallthrough   if       range       type
continue   for           import   return      var

预定义的名字

内建常量: true false iota nil

内建类型: int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

内建函数: make len cap new append copy close delete
          complex real imag
          panic recover

定义域

如果一个名字是在函数内部定义，那么它就只在函数内部有效。

如果是在函数外部定义，那么将在当前包的所有文件中都可以访问。

名字的开头字母的大小写决定了名字在包外的可见性

如果一个名字是大写字母开头的（必须是在函数外部定义的包级名字；包级函数名本身也是包级名字），那么它将是导出的，也就是说可以被外部的包访问，例如fmt包的Printf函数就是导出的，可以在fmt包外部访问。

包本身的名字一般总是用小写字母。

命名

命名一般采用大小写分隔而不是下划线分隔

QuoteRuneToASCII和parseRequestLine

缩略词一般大小写一致，如htmlEscape、HTMLEscape或escapeHTML，但不会是escapeHtml。

2.2 声明

Go语言主要有四种类型的声明语句：var、const、type和func，分别对应变量、常量、类型和函数实体对象的声明

函数声明

一个函数的声明由一个函数名字、参数列表（由函数的调用者提供参数变量的具体值）、一个可选的返回值列表和包含函数定义的函数体组成。

如果函数没有返回值，那么返回值列表是省略的。

2.3 变量

基本声明

变量声明

var 变量名字 类型 = 表达式

其中“类型”或“= 表达式”两个部分可以省略其中的一个。如果省略的是类型信息，那么将根据初始化表达式来推导变量的类型信息。如果初始化表达式被省略，那么将用零值初始化该变量。数值类型变量对应的零值是0，布尔类型变量对应的零值是false，字符串类型对应的零值是空字符串，接口或引用类型（包括slice、指针、map、chan和函数）变量对应的零值是nil。数组或结构体等聚合类型对应的零值是每个元素或字段都是对应该类型的零值。

声明多个

函数返回值也可以初始化

var i, j, k int                 // int, int, int
var b, f, s = true, 2.3, "four" // bool, float64, string
var f, err = os.Open(name) // os.Open returns a file and an error

不要混淆多个变量的声明和元组的多重赋值（§2.4.1），后者是将右边各个表达式的值赋值给左边对应位置的各个变量：

i, j = j, i // 交换 i 和 j 的值

2.3.1 简短变量声明

i := 100                  // an int
var boiling float64 = 100 // a float64
var names []string
var err error
var p Point

简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1

“:=”是一个变量声明语句，而“=”是一个变量赋值操作

简短变量声明左边的变量可能并不是全部都是刚刚声明的。如果有一些已经在相同的词法域声明过了，那么简短变量声明语句对这些已经声明过的变量就只有赋值行为了。

在下面的代码中，第一个语句声明了in和err两个变量。在第二个语句只声明了out一个变量，然后对已经声明的err进行了赋值操作。

in, err := os.Open(infile)
// ...
out, err := os.Create(outfile)

简短变量声明语句中必须至少要声明一个新的变量，下面的代码将不能编译通过：

f, err := os.Open(infile)
// ...
f, err := os.Create(outfile) // compile error: no new variables

简短变量声明语句只有对已经在同级词法域声明过的变量才和赋值操作语句等价，如果变量是在外部词法域声明的，那么简短变量声明语句将会在当前词法域重新声明一个新的变量。

在Go语言中，:= 和 = 是两种不同的变量声明和赋值操作符，它们的用法和含义有一些不同。

result := add(3, 5)

这是一个使用短变量声明操作符 := 的语句。它的主要特点是：

它用于声明并初始化一个新的变量 result。
变量的类型是由右侧的表达式的返回值类型来推断的，因此 result 的类型将由 add(3, 5) 的返回值类型决定。
这个操作符通常在函数内部使用，用于创建一个新的变量并为其赋初值。

var result = add(3, 5)

这是使用 var 关键字进行变量声明和初始化的语句。它的特点是：

它显式指定了变量的类型，类型由 var result 的部分决定，因此需要明确指定变量的类型。
右侧的表达式 add(3, 5) 用于初始化变量 result 的值。

因此，主要的区别在于类型的推断和声明方式：

result := add(3, 5) 会自动推断 result 的类型，不需要显式指定。
var result = add(3, 5) 显式指定了变量的类型，适用于需要明确指定类型的情况。

在实际使用中，通常会根据情况选择适当的方式。如果你希望变量的类型由赋值表达式自动推断，可以使用 :=，而如果你需要明确指定类型，可以使用 var。

2.3.2 指针

函数可以传指针，不能传引用

任何类型的指针的零值都是nil。

变量有时候被称为可寻址的值。即使变量由表达式临时生成，那么表达式也必须能接受&取地址操作。

指针之间也是可以进行相等测试的，只有当它们指向同一个变量或全部是nil时才相等。

在Go语言中，返回函数中局部变量的地址也是安全的，如下，因为指针p依然引用这个变量。

var p = f()

func f() *int {
    v := 1
    return &v
}

package main

import (
	"flag"
	"fmt"
	"strings"
)

var n = flag.Bool("n", false, "omit newline")
var sep = flag.String("s", " ", "separator")

func main() {
	flag.Parse()
	fmt.Print(strings.Join(flag.Args(), *sep))
	if !*n {
		fmt.Println()
	}
}

2.3.3 new函数

语法糖，不是新的基础概念

调用内建的new函数。表达式new(T)将创建一个T类型的匿名变量，初始化为T类型的零值，然后返回变量地址，返回的指针类型为*T。

每次调用new函数都是返回一个新的变量的地址

p := new(int)   // p, *int 类型, 指向匿名的 int 变量
fmt.Println(*p) // "0"
*p = 2          // 设置 int 匿名变量的值为 2
fmt.Println(*p) // "2"

用new创建变量和普通变量声明语句方式创建变量没有什么区别，除了不需要声明一个临时变量的名字外，我们还可以在表达式中使用new(T)

func newInt() *int {
    return new(int)
}

func newInt() *int {
    var dummy int
    return &dummy
}

重定义

由于new只是一个预定义的函数，它并不是一个关键字，因此我们可以将new名字重新定义为别的类型。例如下面的例子：

func delta(old, new int) int { return new - old }

由于new被定义为int类型的变量名，因此在delta函数内部是无法使用内置的new函数的。

2.3.4 变量的生命周期

对于在包一级声明的变量来说，它们的生命周期和整个程序的运行周期是一致的。

局部变量的生命周期则是动态的：每次从创建一个新变量的声明语句开始，直到该变量不再被引用为止，然后变量的存储空间可能被回收。

函数的参数变量和返回值变量都是局部变量。它们在函数每次被调用的时候创建。

末尾的参数变量后面显式插入逗号时，最后插入的逗号不会导致编译错误，这是Go编译器的一个特性

垃圾回收机制

基本的实现思路是，从每个包级的变量和每个当前运行函数的每一个局部变量开始，通过指针或引用的访问路径遍历，是否可以找到该变量。如果不存在这样的访问路径，那么说明该变量是不可达的，也就是说它是否存在并不会影响程序后续的计算结果。

因为一个变量的有效周期只取决于是否可达，因此一个循环迭代内部的局部变量的生命周期可能超出其局部作用域。同时，局部变量可能在函数返回之后依然存在。

2.3.5 栈和堆的分配

编译器会自动选择在栈上还是在堆上分配局部变量的存储空间，但可能令人惊讶的是，这个选择并不是由用var还是new声明变量的方式决定的。

var global *int

func f() {
    var x int
    x = 1
    global = &x
}

func g() {
    y := new(int)
    *y = 1
}

f函数里的x变量必须在堆上分配，因为它在函数退出后依然可以通过包一级的global变量找到，虽然它是在函数内部定义的；用Go语言的术语说，这个x局部变量从函数f中逃逸了。

相反，当g函数返回时，变量*y将是不可达的，也就是说可以马上被回收的。因此，*y并没有从函数g中逃逸，编译器可以选择在栈上分配*y的存储空间（译注：也可以选择在堆上分配，然后由Go语言的GC回收这个变量的内存空间），虽然这里用的是new方式。

其实在任何时候，你并不需为了编写正确的代码而要考虑变量的逃逸行为，要记住的是，逃逸的变量需要额外分配内存，同时对性能的优化可能会产生细微的影响。

2.4 赋值

2.4.1 递增，递减

数值变量也可以支持++递增和--递减语句，但是自增和自减是语句，而不是表达式，因此x = i++之类的表达式是错误的

2.4.2 元组赋值

元组赋值是另一种形式的赋值语句，它允许同时更新多个变量的值。在赋值之前，赋值语句右边的所有表达式将会先进行求值，然后再统一更新左边对应变量的值。

// 计算两个整数值的的最大公约数
func gcd(x, y int) int {
    for y != 0 {
        x, y = y, x%y
    }
    return x
}
// 计算斐波纳契数列（Fibonacci）的第N个数
func fib(n int) int {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        x, y = y, x+y
    }
    return x
}

有些表达式会产生多个值，比如调用一个有多个返回值的函数。当这样一个函数调用出现在元组赋值右边的表达式中时（译注：右边不能再有其它表达式），左边变量的数目必须和右边一致。

f, err = os.Open("foo.txt") // function call returns two values

如果map查找（§4.3）、类型断言（§7.10）或通道接收（§8.4.2）出现在赋值语句的右边，它们都可能会产生两个结果，有一个额外的布尔结果表示操作是否成功：

v, ok = m[key]             // map lookup
v, ok = x.(T)              // type assertion
v, ok = <-ch               // channel receive

也可能只产生一个结果。对于只产生一个结果的情形，map查找失败时会返回零值，类型断言失败时会发生运行时panic异常，通道接收失败时会返回零值（阻塞不算是失败）

v = m[key]                // map查找，失败时返回零值
v = x.(T)                 // type断言，失败时panic异常
v = <-ch                  // 管道接收，失败时返回零值（阻塞不算是失败）

_, ok = m[key]            // map返回2个值
_, ok = mm[""], false     // map返回1个值
_ = mm[""]                // map返回1个值

和变量声明一样，我们可以用下划线空白标识符_来丢弃不需要的值。

_, err = io.Copy(dst, src) // 丢弃字节数
_, ok = x.(T)              // 只检测类型，忽略具体值

2.4.3 可赋值性

不管是隐式还是显式地赋值，在赋值语句左边的变量和右边最终的求到的值必须有相同的数据类型。更直白地说，只有右边的值对于左边的变量是可赋值的，赋值语句才是允许的。

目前规则：类型必须完全匹配，nil可以赋值给任何指针或引用类型的变量，常量则有更灵活的赋值规则，因为这样可以避免不必要的显式的类型转换。

对于两个值是否可以用==或!=进行相等比较的能力也和可赋值能力有关系：对于任何类型的值的相等比较，第二个值必须是对第一个值类型对应的变量是可赋值的，反之亦然。

2.5 类型

type 类型名字 底层类型

类型声明语句一般出现在包一级，因此如果新创建的类型名字的首字符大写，则在包外部也可以使用。

2.5.1 类型转换

在任何情况下，运行时不会发生转换失败的错误，错误只会发生在编译阶段

比较运算符==和<也可以用来比较一个命名类型的变量和另一个有相同类型的变量，或有着相同底层类型的未命名类型的值之间做比较。但是如果两个值有着不同的类型，则不能直接进行比较：

var c Celsius
var f Fahrenheit
fmt.Println(c == 0)          // "true"
fmt.Println(f >= 0)          // "true"
fmt.Println(c == f)          // compile error: type mismatch
fmt.Println(c == Celsius(f)) // "true"!

2.6 包和文件

每个包都对应一个独立的名字空间。例如，在image包中的Decode函数和在unicode/utf16包中的 Decode函数是不同的。要在外部引用该函数，必须显式使用image.Decode或utf16.Decode形式访问。

包还可以让我们通过控制哪些名字是外部可见的来隐藏内部实现信息。在Go语言中，一个简单的规则是：如果一个名字是大写字母开头的，那么该名字是导出的（因为汉字不区分大小写，因此汉字开头的名字是没有导出的）。

2.6.1 包注释

在每个源文件的包声明前紧跟着的注释是包注释（§10.7.4）。通常，包注释的第一句应该先是包的功能概要说明。一个包通常只有一个源文件有包注释（如果有多个包注释，目前的文档工具会根据源文件名的先后顺序将它们链接为一个包注释）。如果包注释很大，通常会放到一个独立的doc.go文件中。

2.6.2 导入包

除了包的导入路径，每个包还有一个包名，包名一般是短小的名字（并不要求包名是唯一的），包名在包的声明处指定。按照惯例，一个包的名字和包的导入路径的最后一个字段相同

如果导入了一个包，但是又没有使用该包将被当作一个编译错误处理。

这种强制规则可以有效减少不必要的依赖，虽然在调试期间可能会让人讨厌，因为删除一个类似log.Print(“got here!”)的打印语句可能导致需要同时删除log包导入声明，否则，编译器将会发出一个错误。在这种情况下，我们需要将不必要的导入删除或注释掉

2.6.3 包的初始化

包的初始化是通过 init() 函数来实现的。每个包可以包含一个或多个 init() 函数，这些函数会在程序启动时自动执行，无需显式调用。

初始化函数的格式如下：

func init() {
    // 初始化代码
}

包中的 init() 函数会在包被导入时执行，每个包的 init() 函数按照导入的顺序执行，但每个 init() 函数仅执行一次。这使得包可以进行一些初始化工作，如设置全局变量、连接数据库、或执行其他必要的操作。

初始化函数对于包的用户是透明的，它们不需要显式调用，而是在包被导入时自动执行。

2.7 作用域

一个声明语句将程序中的实体和一个名字关联，比如一个函数或一个变量。

声明语句的作用域是指源代码中可以有效使用这个名字的范围。

不要将作用域和生命周期混为一谈。声明语句的作用域对应的是一个源代码的文本区域；它是一个编译时的属性。一个变量的生命周期是指程序运行时变量存在的有效时间段，在此时间区域内它可以被程序的其他部分引用；是一个运行时的概念。

2.7.1 作用域导致的隐晦的错误

var cwd string

func init() {
    cwd, err := os.Getwd() // NOTE: wrong!
    if err != nil {
        log.Fatalf("os.Getwd failed: %v", err)
    }
    log.Printf("Working directory = %s", cwd)
}

上述代码中，虽然cwd在外部已经声明过，但是:=语句还是将cwd和err重新声明为新的局部变量。因为内部声明的cwd将屏蔽外部的声明，因此上面的代码并不会正确更新包级声明的cwd变量。

最直接的解决方法是通过单独声明err变量，来避免使用:=的简短声明方式：

var cwd string

func init() {
    var err error
    cwd, err = os.Getwd()
    if err != nil {
        log.Fatalf("os.Getwd failed: %v", err)
    }
}

golang圣经第一章：入门

2023-10-12T00:00:00+00:00

Go语言（或 Golang）起源于 2007 年，并在 2009 年正式对外发布。Go 是非常年轻的一门语言，它的主要目标是“兼具 Python 等动态语言的开发速度和 C/C++ 等编译型语言的性能与安全性”。

1.1 hello world

go是静态编译

go run test.go
go build test.go

go build会生成可执行的二进制文件

必须恰当导入需要的包，缺少了必要的包或者导入了不需要的包，程序都无法编译通过。这项严格要求避免了程序开发过程中引入未使用的包（Go 语言编译过程没有警告信息，争议特性之一）。

换行符

Go 语言不需要在语句或者声明的末尾添加分号，除非一行上有多条语句。实际上，编译器会主动把特定符号后的换行符转换为分号，因此换行符添加的位置会影响 Go 代码的正确解析

函数的左括号 { 必须和 func 函数声明在同一行上，且位于末尾，不能独占一行，而在表达式 x+y 中，可在 + 后换行，不能在 + 前换行（译注：以+结尾的话不会被插入分号分隔符，但是以 x 结尾的话则会被分号分隔符，从而导致编译错误）。

代码编辑器会自动调用gofmt工具把代码格式化为标准格式，这个格式化工具没有任何可以调整代码格式的参数，固定死的

Go原生支持unicode

1.2 命令行参数

数组

go语言采用左闭右开形式

s[m:n] 这个切片，0≤m≤n≤len(s)，包含 n-m 个元素。

如果省略切片表达式的 m 或 n，会默认传入 0 或 len(s)，因此前面的切片可以简写成 os.Args[1:]

os包

命令行参数可以从os包的Args变量获取

os.Args是一个字符串的切片

os.Args[0]//命令本身的名字

++–

自增语句 i++ 给 i 加 1

这和 i+=1 以及 i=i+1 都是等价的。对应的还有 i-- 给 i 减 1。它们是语句，而不像 C 系的其它语言那样是表达式。

所以 j=i++ 非法，而且 ++ 和 -- 都只能放在变量名后面，因此 --i 也非法。

循环

go只有for循环

显示索引

for initialization; condition; post {
    // zero or more statements
}

for 循环三个部分不需括号包围。大括号强制要求，左大括号必须和 post 语句在同一行。

initialization 语句是可选的，在循环开始前执行。initalization 如果存在，必须是一条 简单语句（simple statement），即，短变量声明、自增语句、赋值语句或函数调用。condition 是一个布尔表达式（boolean expression），其值在每次循环迭代开始时计算。如果为 true 则执行循环体语句。post 语句在循环体执行结束后执行，之后再次对 condition 求值。condition 值为 false 时，循环结束。

for 循环的这三个部分每个都可以省略，如果省略 initialization 和 post，分号也可以省略：

// a traditional "while" loop
for condition {
    // ...
}

如果连 condition 也省略了，像下面这样：

// a traditional infinite loop
for {
    // ...
}

这就变成一个无限循环，尽管如此，还可以用其他方式终止循环，如一条 break 或 return 语句。

隐式索引

for 循环的另一种形式，在某种数据类型的区间（range）上遍历，如字符串或切片。echo 的第二版本展示了这种形式：

// Echo2 prints its command-line arguments.
package main

import (
    "fmt"
    "os"
)

func main() {
    s, sep := "", ""
    for _, arg := range os.Args[1:] {
        s += sep + arg
        sep = " "
    }
    fmt.Println(s)
}

每次循环迭代，range 产生一对值；索引以及在该索引处的元素值。这个例子不需要索引，但 range 的语法要求，要处理元素，必须处理索引。一种思路是把索引赋值给一个临时变量（如 temp）然后忽略它的值，但 Go 语言不允许使用无用的局部变量（local variables），因为这会导致编译错误。

Go 语言中这种情况的解决方法是用 空标识符（blank identifier），即 _（也就是下划线）。空标识符可用于在任何语法需要变量名但程序逻辑不需要的时候（如：在循环里）丢弃不需要的循环索引，并保留元素值。大多数的 Go 程序员都会像上面这样使用 range 和 _ 写 echo 程序，因为隐式地而非显式地索引 os.Args，容易写对。

变量声明

声明一个变量有好几种方式，下面这些都等价：

s := ""
var s string
var s = ""
var s string = ""

第一种形式，是一条短变量声明，最简洁，但只能用在函数内部，而不能用于包变量。

第二种形式依赖于字符串的默认初始化零值机制，被初始化为 ""。

第三种形式用得很少，除非同时声明多个变量。

第四种形式显式地标明变量的类型，当变量类型与初值类型相同时，类型冗余，但如果两者类型不同，变量类型就必须了。

实践中一般使用前两种形式中的某个，初始值重要的话就显式地指定变量的类型，否则使用隐式初始化。

1.3 查找重复的行

动词

%d          十进制整数
%x, %o, %b  十六进制，八进制，二进制整数。
%f, %g, %e  浮点数： 3.141593 3.141592653589793 3.141593e+00
%t          布尔：true或false
%c          字符（rune） (Unicode码点)
%s          字符串
%q          带双引号的字符串"abc"或带单引号的字符'c'
%v          变量的自然形式（natural format）
%T          变量的类型
%%          字面上的百分号标志（无操作数）

格式化函数

默认情况下，Printf 不会换行。按照惯例，以字母 f 结尾的格式化函数，如 log.Printf 和 fmt.Errorf，都采用 fmt.Printf 的格式化准则。而以 ln 结尾的格式化函数，则遵循 Println 的方式，以跟 %v 差不多的方式格式化参数，并在最后添加一个换行符。（译注：后缀 f 指 format，ln 指 line。）

nil

nil属于内置值，相当于其他语言中的NULL

golang环境配置

2023-10-11T00:00:00+00:00

windows系统，使用vs code作为IDE，配置golang环境

下载

Download and install - The Go Programming Language

go1.21.3.windows-amd64

C:\Users\admin>go version
go version go1.21.3 windows/amd64

安装go插件

VS code搜索go，第一个

设置代理

cmd输入以下命令

go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct

go modules功能的开关是GO111MODULE

https://goproxy.cn是国内代理

在使用go modules时，GOPATH是无意义的

The “gopls” command is not available. Run “go install -v golang.org/x/tools/gopls@latest” to install.

下载依赖

VS中ctrl shift p搜索go install/update tools

ctrl K T 选择VSC主题

下载所有依赖

go modules依赖管理

go mod tidy

将当前源码文件所依赖的包安装，多的删掉，少了补上

go mod init 应用名称(项目名称)

执行该命令，会在应用过的根目录下(家目录)，生成go.mod文件。

我们在进行go语言项目开发的时候，会依赖3种类型的库包：

内置的标准库包，在goroot/src目录下，也就是我们安装目录的src目录下(类似于python的bin目录)
第三方库包（git上开源的）
项目中的库包，也就是项目中的其他目录。自己调用自己写的函数方法

调试

文件目录

打断点

简单工厂模式

2023-09-22T00:00:00+00:00

定义一个工厂类，其成员函数可以根据不同的参数创建并返回不同的类对象，调用者无需关注创建细节

简介

模式：简单工厂

英文：simple factory

定义：定义一个工厂类，其成员函数可以根据不同的参数创建并返回不同的类对象，调用者无需关注创建细节

意图：实例化的活动不应该总是公开地进行，为了避免初始化总是造成耦合问题，将两者解耦

设计准则

对修改关闭，对扩展开放：增加新功能不应该修改已经存在的代码，而应该通过增加新类或新成员函数
针对接口编程，不针对实现编程
依赖倒置原则：要依赖抽象，不要依赖具体类：不能让高层组件依赖低层组件，而且两者都应该依赖于抽象
封装变化：将容易变化的代码段限制在一个小范围内

代码

#include <iostream>

class Role {
public:
	Role(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
	virtual ~Role(){}
protected:
	int m_life;
	int m_magic;
	int m_attack;
};

class R_A :public Role {
public:
	R_A(int life, int magic, int attack) :Role(life, magic, attack)
	{
		std::cout << "创建A角色" << std::endl;
	}
};
class R_B :public Role {
public:
	R_B(int life, int magic, int attack) :Role(life, magic, attack)
	{
		std::cout << "创建B角色" << std::endl;
	}
};
class R_C :public Role {
public:
	R_C(int life, int magic, int attack) :Role(life, magic, attack)
	{
		std::cout << "创建C角色" << std::endl;
	}
};
class RoleFactory
{
public:
	Role* createRole(std::string roletype)
	{
		Role* p_Role = nullptr;
		if(roletype=="A")
			p_Role=new R_A(300, 400, 1000);
		else if (roletype=="C")
			p_Role = new R_C(1000, 400, 500);
		else if (roletype == "B")
			p_Role = new R_B(400, 400, 800);
		return p_Role;
	}
};

int main() {
	RoleFactory rolefactory;
	Role* p_role1 = rolefactory.createRole("A");
	Role* p_role2 = rolefactory.createRole("C");
	Role* p_role3 = rolefactory.createRole("B");
	delete p_role1;
	delete p_role2;
	delete p_role3;

	return 0;
}

由于创建角色与角色工厂本身无关，所以可以使用static方法，也就是是静态工厂方法模式

#include <iostream>
class Role {
public:
	Role(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
	virtual ~Role() {}
protected:
	int m_life;
	int m_magic;
	int m_attack;
};

class R_A :public Role {
public:
	R_A(int life, int magic, int attack) :Role(life, magic, attack)
	{
		std::cout << "创建A角色" << std::endl;
	}
};
class R_B :public Role {
public:
	R_B(int life, int magic, int attack) :Role(life, magic, attack)
	{
		std::cout << "创建B角色" << std::endl;
	}
};
class R_C :public Role {
public:
	R_C(int life, int magic, int attack) :Role(life, magic, attack)
	{
		std::cout << "创建C角色" << std::endl;
	}
};
class RoleFactory
{
public:
	static Role* createRole(std::string roletype)
	{
		Role* p_Role = nullptr;
		if (roletype == "A")
			p_Role = new R_A(300, 400, 1000);
		else if (roletype == "C")
			p_Role = new R_C(1000, 400, 500);
		else if (roletype == "B")
			p_Role = new R_B(400, 400, 800);
		return p_Role;
	}
};

int main() {
	Role* p_role1 = RoleFactory::createRole("A");
	Role* p_role2 = RoleFactory::createRole("C");
	Role* p_role3 = RoleFactory::createRole("B");
	delete p_role1;
	delete p_role2;
	delete p_role3;
	return 0;
}

缺点

当引入新的子类时，需要修改createRole函数的源码，违背了开闭准则

使用场景

享元模式

2023-09-15T00:00:00+00:00

本文介绍享元模式

简介

模式：享元模式

英文：flyweight

定义：使用共享技术有效地支持大量细粒度的对象的复用，从而到达使用大量相似对象的同样的效果。

命名由来：flyweight是特轻量级，蝇量级的意思

意图：在同类对象十分多的情况下，改变模式，当需要某个对象时，尽量共用已经创建出来的同类对象，从而避免频繁new，节约内存，提高效率。

概念

享元：被共享的单元或者对象

内部状态：存储在享元对象内部的，一直不会发生改变的状态，这种状态可以被共享，一般可以作为享元类的成员变量

外部状态：随着外部环境改变而改变的状态，不可以被共享

总之，将内部状态相同的对象存储在享元池中，传递不同的外部状态。确定内部状态的时候，需要将在多个地方共享的成员变量作为享元对象的内部状态

享元池

享元模式中使用了简单工厂，这个工厂一般用于创建享元对象，并保存在一个容器中，这个容器专门用于保存一个或者多个享元对象，称为享元池

享元池的引入造成了程序的复杂性，需要衡量性价比

享元池和对象池，连接池，线程池都可以看成是对象的复用，但是后三者强调储备量，比如线程池可以规定线程池中线程数最多为多少，但是享元池强调的是创建对象这个过程可以使用享元池中的已有一种对象进行代替

代码结构

一般由以下几个部分组成

抽象享元类：Piece
具体享元类：BlackPiece，可以考虑使用单件模式实现
享元工厂类：pieceFactory，可以考虑使用单件模式实现

代码

使用享元模式前：

#include<iostream>
#include<list>

enum EnumColor {
	Black,White
};
struct Position {
	int m_x;
	int m_y;
	Position(int tmpx, int tmpy) :m_x(tmpx), m_y(tmpy){}
};
class Piece
{
public:
	Piece(EnumColor tmpcolor, Position tmppos) :m_color(tmpcolor), m_pos(tmppos) {

	}
	void draw();
private:
	EnumColor m_color;
	Position m_pos;
};
void Piece::draw()
{
	if (m_color == Black){
		std::cout << "绘制黑棋于" << m_pos.m_x << "," << m_pos.m_y << std::endl;
	}
	else {
		std::cout << "绘制白棋于" << m_pos.m_x << "," << m_pos.m_y << std::endl;
	}
}

int main()
{

	Piece* p_piece1 = new Piece(Black, Position(3, 3));
	p_piece1->draw();

	Piece* p_piece2 = new Piece(White, Position(5, 5));
	p_piece2->draw();

	Piece* p_piece3 = new Piece(Black, Position(4, 6));
	p_piece3->draw();

	std::list <Piece*>piece_list;
	piece_list.push_back(p_piece1);
	piece_list.push_back(p_piece2);
	piece_list.push_back(p_piece3);

	delete p_piece1;
	delete p_piece2;
	delete p_piece3;
	return 0;
}

使用享元模式后：

#include<iostream>
#include<list>
#include<map>
enum EnumColor {
	Black, White
};
struct Position {
	int m_x;
	int m_y;
	Position(int tmpx, int tmpy) :m_x(tmpx), m_y(tmpy) {}
};
class Piece
{
public:
	virtual ~Piece() {};
	virtual void draw(Position tmppos)=0;
};
class BlackPiece:public Piece {
public:
	virtual void draw(Position tmppos) {
		std::cout << "绘制黑棋于" << tmppos.m_x << "," << tmppos.m_y << std::endl;
	}
};
class WhitePiece :public Piece {
public:
	virtual void draw(Position tmppos) {
		std::cout << "绘制白棋于" << tmppos.m_x << "," << tmppos.m_y << std::endl;
	}
};
class pieceFactory {
public:
	~pieceFactory()
	{
		for (auto iter = m_FlyWeightMap.begin(); iter != m_FlyWeightMap.end(); iter++)
		{
			Piece* tmpfw = iter->second;
			delete tmpfw;
		}
		m_FlyWeightMap.clear();
	}
	Piece* getFlyWeight(EnumColor tmpcolor)
	{
		auto iter = m_FlyWeightMap.find(tmpcolor);
		if(iter==m_FlyWeightMap.end())
		{
			Piece* tmpfw = nullptr;
			if (tmpcolor == Black) tmpfw = new BlackPiece();
			else tmpfw = new WhitePiece();
			m_FlyWeightMap.insert(std::make_pair(tmpcolor, tmpfw));
			return tmpfw;
		}
		else 
			return iter->second;
	}
private:
	std::map<EnumColor, Piece*>m_FlyWeightMap;
};
int main()
{
	pieceFactory* pfactory = new pieceFactory();
	Piece* p_piece1 = pfactory->getFlyWeight(Black);
	p_piece1->draw(Position(3, 3));

	Piece* p_piece2 = pfactory->getFlyWeight(Black);
	p_piece2->draw(Position(5, 5));

	Piece* p_piece3 = pfactory->getFlyWeight(Black);
	p_piece3->draw(Position(4, 6));

	Piece* p_piece4 = pfactory->getFlyWeight(Black);
	p_piece4->draw(Position(5, 7));

	delete pfactory;
	return 0;
}

关闭命令行输出时两种代码创建相同数量的类的运行速度：

对象数/ms	普通模式	享元模式
1000（波动大）	400	170-356
一万	2572	1800-2200
十万	19643-33911	15749-16401
百万	249130-216128	159932
千万	2417764-2123181	1616665-1656742
一亿	19677707-20324193	15560363

可以看出来性能提升还不小，优化了25%左右

使用场景

程序中有大量相同或者相似的对象造成内存的大量消耗
对象的大部分状态可以定义为外部状态作为参数传入

模版方法模式

2023-09-01T00:00:00+00:00

本文介绍模版方法模式

简介

模式名：模版方法模式

英文：template method

定义：由固定步骤组成的事情，在步骤确定的情况下，通过多态在子类中对每步进行差异性实现。

命名由来：某个成员方法，称为A，固定调用某几个成员方法，故称A为模版方法，这种方法叫做模版方法模式

意图：定义一个操作的算法骨架，将一些步骤延迟到子类实现，通过父类定义虚函数，子类重写/实现来做到

概念

早绑定与晚绑定

早绑定：编译阶段就知道代码调用的哪个类的方法

晚绑定：父类指针指向子类对象，运行期间才能知道调用哪种方法

钩子方法hook

子类可以控制父类的行为的方法

使用场景

MFC

MFC创建对话框的应用程序

车间

零件装配工序固定，则针对零件创建一个父类，零件装配工序采用模版方法模式来实现，处理某道工序的细节可以放在子类的虚函数中

Gelei Blog

golang圣经第二章：程序结构

2.1 命名

关键字

预定义的名字

定义域

命名

2.2 声明

函数声明

2.3 变量

基本声明

变量声明

声明多个

2.3.1 简短变量声明

2.3.2 指针

2.3.3 new函数

重定义

2.3.4 变量的生命周期

垃圾回收机制

2.3.5 栈和堆的分配

2.4 赋值

2.4.1 递增，递减

2.4.2 元组赋值

2.4.3 可赋值性

2.5 类型

2.5.1 类型转换

2.6 包和文件

2.6.1 包注释

2.6.2 导入包

2.6.3 包的初始化

2.7 作用域

2.7.1 作用域导致的隐晦的错误

golang圣经第一章：入门

1.1 hello world

换行符

1.2 命令行参数

数组

os包

++–

循环

显示索引

隐式索引

变量声明

1.3 查找重复的行

动词

格式化函数

nil

golang环境配置

下载

安装go插件

设置代理

下载依赖

go modules依赖管理

调试

简单工厂模式

简介

设计准则

代码

缺点

使用场景

相关模式

享元模式

简介

概念

享元池

代码结构

代码

使用场景

相关模式

模版方法模式

简介

概念

早绑定与晚绑定

钩子方法hook

使用场景

MFC

车间

相关模式