GO数组切片

1. 数组

数组是一个由固定长度的特定类型元素组成的序列,一个数组可以由零个或多个元素组成。

因为数组的长度是固定的,所以在Go语言中很少直接使用数组。

Go语言数组的声明:

var 数组变量名 [元素数量]Type

1

  • 数组变量名:数组声明及使用时的变量名。
  • 元素数量:数组的元素数量,可以是一个表达式,但最终通过编译期计算的结果必须是整型数值,元素数量不能含有到运行时才能确认大小的数值。
  • Type:可以是任意基本类型,包括数组本身,类型为数组本身时,可以实现多维数组。

例子:

//默认数组中的值是类型的默认值
var arr [3]int

从数组中取值:

  1. 通过索引下标取值,索引从0开始
fmt.Println(arr[0])fmt.Println(arr[1])fmt.Println(arr[2])

  1. for range获取
for index,value := range arr{fmt.Printf("索引:%d,值:%d \n",index,value)
}

给数组赋值:

  1. 初始化的时候赋值
		var arr [3]int = [3]int{1, 2, 4}//如果第三个不使用,默认为0var arr1 [3]int = [3]int{1, 2}//可以使用简短声明arr2 := [3]int{1, 2, 3}//如果不写数据数量,而使用...,表示数组的长度是根据初始化值的个数来计算arr3 := [...]int{1, 2, 4, 1, 2}

通过索引下标赋值

	var arr [3]intarr[0]=1arr[1]=2arr[2]=4

一定要注意,数组是定长的,不可更改,在编译阶段就决定了

小技巧: 如果觉的每次写 [3]int 有点麻烦,你可以为 [3]int 定义一个新的类型。

	type arr3 [3]intvar arr arr3arr[2] = 9for _, v := range arr {fmt.Println(v)}

如果想要只初始化第三个值怎么写?

数组比较

如果两个数组类型相同(包括数组的长度,数组中元素的类型)的情况下,我们可以直接通过较运算符(==和!=)来判断两个数组是否相等,只有当两个数组的所有元素都是相等的时候数组才是相等的,不能比较两个类型不同的数组,否则程序将无法完成编译。

	a := [2]int{2, 1}b := [2]int{2, 1}fmt.Println(a == b) //true


2. 多维数组

Go语言中允许使用多维数组,因为数组属于值类型,所以多维数组的所有维度都会在创建时自动初始化零值,多维数组尤其适合管理具有父子关系或者与坐标系相关联的数据。

声明多维数组的语法如下所示:

//array_name 为数组的名字,array_type 为数组的类型,size1、size2 等等为数组每一维度的长度。
var array_name [size1][size2]...[sizen] array_type

二维数组是最简单的多维数组,二维数组本质上是由多个一维数组组成的。

	var arr, arr2 [2][2]int//直接初始化arr = [2][2]int{{1, 2}, {2, 1}}//初始化索引为1的的元素arr2 = [2][2]int{1: {2, 3}}

循环取值

	var arr [2][2]int//直接初始化arr = [2][2]int{{1, 2}, {2, 1}}for _, v := range arr {fmt.Println(v) //[1 2] [2 1]}

只要类型一致,就可以将多维数组互相赋值,如下所示,多维数组的类型包括每一维度的长度以及存储在元素中数据的类型:

// 声明两个二维整型数组 [2]int [2]int
var array1 [2][2]int  
var array2 [2][2]int
// 为array2的每个元素赋值
array2[0][0] = 10
array2[0][1] = 20
array2[1][0] = 30
array2[1][1] = 40
// 将 array2 的值复制给 array1
array1 = array2

因为数组中每个元素都是一个值,所以可以独立复制某个维度,如下所示:

	var arr [2][2]intarr = [2][2]int{{1, 2}, {3, 4}}var arr2 [2]intarr2 = arr[1]fmt.Println(arr2) //[3 4]

3. 切片

切片(Slice)与数组一样,也是可以容纳若干类型相同的元素的容器。

与数组不同的是,无法通过切片类型来确定其值的长度。

每个切片值都会将数组作为其底层数据结构。

我们也把这样的数组称为切片的底层数组。

切片(slice)是对数组的一个连续片段的引用,所以切片是一个引用类型。

这个片段可以是整个数组,也可以是由起始和终止索引标识的一些项的子集,需要注意的是,终止索引标识的项不包括在切片内(左闭右开的区间)。

Go语言中切片的内部结构包含地址、大小和容量,切片一般用于快速地操作一块数据集合。

从连续内存区域生成切片是常见的操作,格式如下:

slice [开始位置 : 结束位置]

1

语法说明如下:

  • slice:表示目标切片对象;
  • 开始位置:对应目标切片对象的索引;
  • 结束位置:对应目标切片的结束索引。

从数组生成切片,代码如下:

var a  = [3]int{1, 2, 3}
//a[1:2] 生成了一个新的切片
fmt.Println(a, a[1:2])

从数组或切片生成新的切片拥有如下特性:

  • 取出的元素数量为:结束位置 - 开始位置;
  • 取出元素不包含结束位置对应的索引,切片最后一个元素使用 slice[len(slice)] 获取;
  • 当缺省开始位置时,表示从连续区域开头到结束位置(a[:2]);
  • 当缺省结束位置时,表示从开始位置到整个连续区域末尾(a[0:]);
  • 两者同时缺省时,与切片本身等效(a[:]);
  • 两者同时为 0 时,等效于空切片,一般用于切片复位(a[0:0])。

注意:超界会报运行时错误,比如数组长度为3,则结束位置最大只能为3

切片在指针的基础上增加了大小,约束了切片对应的内存区域,切片使用中无法对切片内部的地址和大小进行手动调整,因此切片比指针更安全、强大。

3.1 直接声明新的切片

除了可以从原有的数组或者切片中生成切片外,也可以声明一个新的切片,每一种类型都可以拥有其切片类型,表示多个相同类型元素的连续集合。

切片类型声明格式如下:

//name 表示切片的变量名,Type 表示切片对应的元素类型。
var name []Type

	// 声明字符串切片var strList []string// 声明整型切片var numList []int// 声明一个空切片var numListEmpty = []int{}// 输出3个切片fmt.Println(strList, numList, numListEmpty) //[] [] []// 输出3个切片大小fmt.Println(len(strList), len(numList), len(numListEmpty))// 切片判定空的结果fmt.Println(strList == nil)      //truefmt.Println(numList == nil)      //truefmt.Println(numListEmpty == nil) //false

切片是动态结构,只能与 nil 判定相等,不能互相判定相等。声明新的切片后,可以使用 append() 函数向切片中添加元素。

func append(slice []Type, elems ...Type) []Type

3.2 使用 make() 函数构造切片

如果需要动态地创建一个切片,可以使用 make() 内建函数,格式如下:

make( []Type, size, cap )

Type 是指切片的元素类型,size 指的是为这个类型分配多少个元素,cap 为预分配的元素数量,这个值设定后不影响 size,只是能提前分配空间,降低多次分配空间造成的性能问题。

使用 make() 函数生成的切片一定发生了内存分配操作,但给定开始与结束位置(包括切片复位)的切片只是将新的切片结构指向已经分配好的内存区域,设定开始与结束位置,不会发生内存分配操作

思考题:

var numbers4 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
myslice := numbers4[4:6]
//这打印出来长度为2
fmt.Printf("myslice为 %d, 其长度为: %d\n", myslice, len(myslice))
myslice = myslice[:cap(myslice)]
//为什么 myslice 的长度为2,却能访问到第四个元素
fmt.Printf("myslice的第四个元素为: %d", myslice[3])

这里,cap(myslice) 返回 myslice 的容量(capacity)。由于 myslice 是从 numbers4 中提取的,它的容量实际上是从原始数组 numbers4 的起始位置到 numbers4 的结束位置的元素数量,即10。因此,myslice[:cap(myslice)] 实际上等同于 myslice[:10],它将 myslice 扩展到了其最大容量,即包含了从原始数组 numbers4 的开始到原始切片结束的所有元素。

4. 切片复制

Go语言的内置函数 copy() 可以将一个数组切片复制到另一个数组切片中,如果加入的两个数组切片不一样大,就会按照其中较小的那个数组切片的元素个数进行复制。

copy() 函数的使用格式如下:

copy( destSlice, srcSlice []T) int

其中 srcSlice 为数据来源切片,destSlice 为复制的目标(也就是将 srcSlice 复制到 destSlice),目标切片必须分配过空间且足够承载复制的元素个数,并且来源和目标的类型必须一致,copy() 函数的返回值表示实际发生复制的元素个数。

下面的代码展示了使用 copy() 函数将一个切片复制到另一个切片的过程:

	slice1 := []int{1, 2, 3, 4, 5}slice2 := []int{6, 7, 8}copy(slice1, slice2) //复制slice2 的前三个元素到slice1中fmt.Println(slice1)  //[6 7 8 4 5]copy(slice2, slice1) //复制slice1的前三个元素到slice2中fmt.Println(slice2)  //[6 7 8]

切片的引用和复制操作对切片元素的影响:

	srcArr := make([]int, 10)for i := 0; i < 10; i++ {srcArr[i] = i}refArr := srcArrcopyArr := make([]int, 10)copy(copyArr, refArr)fmt.Println(srcArr) //[0 1 2 3 4 5 6 7 8 9]srcArr[0] = 999// 打印引用切片的第一个元素 引用数据的第一个元素将会发生变化fmt.Println(refArr) //[999 1 2 3 4 5 6 7 8 9]//由于数据是复制的,因此不会发生变化。fmt.Println(copyArr) //[0 1 2 3 4 5 6 7 8 9]

5. map

map 是一种无序的键值对的集合。

map 最重要的一点是通过 key 来快速检索数据,key 类似于索引,指向数据的值。

map 是一种集合,所以我们可以像迭代数组和切片那样迭代它。不过,map 是无序的,我们无法决定它的返回顺序,这是因为 map 是使用 hash 表来实现的。

map 是引用类型,可以使用如下方式声明:

//[keytype] 和 valuetype 之间允许有空格。
var mapname map[keytype]valuetype

其中:

  • mapname 为 map 的变量名。
  • keytype 为键类型。
  • valuetype 是键对应的值类型。

在声明的时候不需要知道 map 的长度,因为 map 是可以动态增长的,未初始化的 map 的值是 nil,使用函数 len() 可以获取 map 中 键值对的数目。

	var mapLit map[string]intvar mapAssigned map[string]intmapLit = map[string]int{"one": 1, "two": 2}mapAssigned = mapLit//mapAssigned 是 mapList 的引用,对 mapAssigned 的修改也会影响到 mapList 的值。mapAssigned["two"] = 3fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])fmt.Printf("Map assigned at \"two\" is: %d\n", mapLit["two"])  //Map assigned at "two" is: 3fmt.Printf("Map literal at \"ten\" is: %d\n", mapLit["ten"]) //Map literal at "ten" is: 0

map的另外一种创建方式:

make(map[keytype]valuetype)

1

切记不要使用new创建map,否则会得到一个空引用的指针

map 可以根据新增的 key-value 动态的伸缩,因此它不存在固定长度或者最大限制,但是也可以选择标明 map 的初始容量 capacity,格式如下:

make(map[keytype]valuetype, cap)

当 map 增长到容量上限的时候,如果再增加新的 key-value,map 的大小会自动加 1,所以出于性能的考虑,对于大的 map 或者会快速扩张的 map,即使只是大概知道容量,也最好先标明。

既然一个 key 只能对应一个 value,而 value 又是一个原始类型,那么如果一个 key 要对应多个值怎么办?

答案是:使用切片

例如,当我们要处理 unix 机器上的所有进程,以父进程(pid 为整形)作为 key,所有的子进程(以所有子进程的 pid 组成的切片)作为 value。

通过将 value 定义为 []int 类型或者其他类型的切片,就可以优雅的解决这个问题,示例代码如下所示:

mp1 := make(map[int][]int)
mp2 := make(map[int]*[]int)

5.1 遍历map

map 的遍历过程使用 for range 循环完成,代码如下:

	scene := make(map[string]int)scene["cat"] = 66scene["dog"] = 4scene["pig"] = 960for k, v := range scene {fmt.Printf("key :%s,val:%d\n", k, v)}

注意:map是无序的,不要期望 map 在遍历时返回某种期望顺序的结果

5.2 删除

使用 delete() 内建函数从 map 中删除一组键值对,delete() 函数的格式如下:

delete(map, 键)

map 为要删除的 map 实例,键为要删除的 map 中键值对的键。

	scene := make(map[string]int)// 准备map数据scene["cat"] = 66scene["dog"] = 4scene["pig"] = 960delete(scene, "dog")for k, v := range scene {fmt.Printf("key :%s,val:%d\n", k, v)}

Go语言中并没有为 map 提供任何清空所有元素的函数、方法,清空 map 的唯一办法就是重新 make 一个新的 map,不用担心垃圾回收的效率,Go语言中的并行垃圾回收效率比写一个清空函数要高效的多。

注意map 在并发情况下,只读是线程安全的,同时读写是线程不安全的。

func main() {myMap := make(map[int]int)//写go func() {//不停的写for {myMap[0] = 10}}()//读go func() {//不停的读for {_ = myMap[0]}}()// 无限循环, 让并发程序在后台执行for {}
}

程序报错:fatal error: concurrent map read and map write

需要并发读写时,一般的做法是加锁,但这样性能并不高,Go语言在 1.9 版本中提供了一种效率较高的并发安全的 sync.Map,sync.Map 和 map 不同,不是以语言原生形态提供,而是在 sync 包下的特殊结构。

sync.Map 有以下特性:

  • 无须初始化,直接声明即可。
  • sync.Map 不能使用 map 的方式进行取值和设置等操作,而是使用 sync.Map 的方法进行调用,Store 表示存储,Load 表示获取,Delete 表示删除。
  • 使用 Range 配合一个回调函数进行遍历操作,通过回调函数返回内部遍历出来的值,Range 参数中回调函数的返回值在需要继续迭代遍历时,返回 true,终止迭代遍历时,返回 false。

	var color sync.Mapcolor.Store(1, "red")color.Store(2, "blue")color.Store(3, "yellow")fmt.Println(color) //{{0 0} {[] {} 0xc00008a040} map[1:0xc0000a8018 2:0xc0000a8020 3:0xc0000a8028] 0}fmt.Println(color.Load(1)) //red truecolor.Delete(2)color.Range(func(k, v interface{}) bool {fmt.Println("iter:", k, v)return true})//iter: 1 red//iter: 3 yellow

sync.Map 为了保证并发安全有一些性能损失,因此在非并发情况下,使用 map 相比使用 sync.Map 会有更好的性能

6. nil

在Go语言中,布尔类型的零值(初始值)为 false,数值类型的零值为 0,字符串类型的零值为空字符串"",而指针、切片、映射、通道、函数和接口的零值则是 nil。

nil和其他语言的null是不同的。

nil 标识符是不能比较的

func main() {//invalid operation: nil == nil (operator == not defined on nil)fmt.Println(nil==nil)
}

nil 不是关键字或保留字

nil 并不是Go语言的关键字或者保留字,也就是说我们可以定义一个名称为 nil 的变量,比如下面这样:

//但不提倡这样做
var nil = errors.New("my god")

nil 没有默认类型

package main
import ("fmt"
)
func main() {//error :use of untyped nilfmt.Printf("%T", nil)print(nil)
}

不同类型 nil 的指针是一样的

	var arr []intvar point *intfmt.Printf("%p\n", arr) //0x0fmt.Printf("%p", point) //0x0

nil 是 map、slice、pointer、channel、func、interface 的零值

	var m map[int]intvar p *intvar f func()var ch chan intvar s []intvar i interface{}fmt.Printf("%##v\n", m)  //map[int]int(nil)fmt.Printf("%##v\n", p)  //(*int)(nil)fmt.Printf("%##v\n", f)  //(func())(nil)fmt.Printf("%##v\n", ch) //(chan int)(nil)fmt.Printf("%##v\n", s)  //[]int(nil)fmt.Printf("%##v\n", i)  //<nil>

零值是Go语言中变量在声明之后但是未初始化被赋予的该类型的一个默认值。

不同类型的 nil 值占用的内存大小可能是不一样的

func main() {var p *struct{}fmt.Println( unsafe.Sizeof( p ) ) // 8var s []intfmt.Println( unsafe.Sizeof( s ) ) // 24var m map[int]boolfmt.Println( unsafe.Sizeof( m ) ) // 8var c chan stringfmt.Println( unsafe.Sizeof( c ) ) // 8var f func()fmt.Println( unsafe.Sizeof( f ) ) // 8var i interface{}fmt.Println( unsafe.Sizeof( i ) ) // 16
}

7. new和make

make 关键字的主要作用是创建 slice、map 和 Channel 等内置的数据结构,而 new 的主要作用是为类型申请一片内存空间,并返回指向这片内存的指针。

  1. make 分配空间后,会进行初始化,new分配的空间被清零
  2. new 分配返回的是指针,即类型 *Type。make 返回引用,即 Type;
  3. new 可以分配任意类型的数据;

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/713717.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

本地快速部署谷歌开放模型Gemma教程(基于WasmEdge)

本地快速部署谷歌开放模型Gemma教程&#xff08;基于WasmEdge&#xff09; 一、介绍 Gemma二、部署 Gemma2.1 部署工具2.1 部署步骤 三、构建超轻量级 AI 代理四、总结 一、介绍 Gemma Gemma是一系列轻量级、最先进的开放式模型&#xff0c;采用与创建Gemini模型相同的研究和技…

持续集成(CICD)- Jenkins插件安装失败解决办法

解决办法&#xff1a;将插件安装更新源需要改成国内镜像源 具体步骤如下&#xff1a; 步骤一&#xff1a;修改Jenkins工作目录下的 hudson.model.UpdateCenter.xml 文件&#xff0c;将url 改为http://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json 步骤二…

RuoYi-Vue-Plus功能分析-jackson配置

文章目录 前言一、配置文件二、配置类三、注解四、json工具类1. 工具内容2. 使用工具 前言 前端在给我发送请求的时候一般包含三个部分url&#xff0c;header&#xff0c;body。那么就会涉及我们后端如何接收这些请求参数并且我们处理完毕参数后前端又如何接收参数 通过url传…

代码随想录刷题笔记 DAY 37 | 动态规划理论基础 | 斐波那契数 No.509 | 爬楼梯 No.70 | 使用最小花费爬楼梯 No.746

文章目录 Day 3700. 动态规划理论基础01. 斐波那契数&#xff08;No. 509&#xff09;<1> 题目<2> 笔记<3> 代码 02. 爬楼梯&#xff08;No. 70&#xff09;<1> 题目<2> 笔记<3> 代码 03. 使用最小花费爬楼梯&#xff08;No. 746&#xff…

ECMAScript-262 @2023版本中的关键字和保留字

1、什么是标识符&#xff1f; 所谓标识符&#xff0c;就是javascript里的变量、函数、属性或函数参数的名称&#xff0c;可由一个或多个字符组成&#xff0c;当然标识符有命名规范 标识符第一个字符必须是 一个字母、下划线&#xff08;_&#xff09;或美元符号&#xff08;$…

ONLYOFFICE文档8.0全新发布:私有部署、卓越安全的协同办公解决方案

ONLYOFFICE文档8.0全新发布&#xff1a;私有部署、卓越安全的协同办公解决方案 文章目录 ONLYOFFICE文档8.0全新发布&#xff1a;私有部署、卓越安全的协同办公解决方案摘要&#x1f4d1;引言 &#x1f31f;正文&#x1f4da;一、ONLYOFFICE文档概述 &#x1f4ca;二、ONLYOFFI…

【新书推荐】10.2 分支程序设计

稍微复杂一些的程序通常需要做某种条件判断&#xff0c;然后再决定程序的执行流程。当然也可以无条件跳转到程序的另一处地址开始执行。本节我们将详细介绍分支结构的程序设计方法。 针对功能较为复杂的程序&#xff0c;程序开发有一套标准的流程&#xff0c;我们将10.1节中的五…

计算机网络【网络安全】

计算机网络——网络安全 一、网络安全问题概述 网络安全威胁 网络安全面临两大类威胁&#xff0c;被动攻击和主动攻击 被动攻击 指攻击者从网络上窃听他人的通信内容&#xff0c;通常把这类攻击称为截获。 主动攻击 篡改 攻击者故意篡改网络上传送的报文 恶意程序 拒绝服…

InnoDB索引与优化篇(5)-InnoDB中的查询优化策略

InnoDB是MySQL数据库中一种常用的存储引擎&#xff0c;它具有高性能和可靠性。查询优化是数据库开发中非常重要的一环&#xff0c;它能够帮助我们提高数据库查询的效率和性能。在本篇博客中&#xff0c;我们将介绍一些在使用InnoDB存储引擎时进行查询优化的常用策略&#xff0c…

贪心 Leetcode 455 分发饼干

分发饼干 Leetcode 455 学习记录自代码随想录 假设你是一位很棒的家长&#xff0c;想要给你的孩子们一些小饼干。但是&#xff0c;每个孩子最多只能给一块饼干。 对每个孩子 i&#xff0c;都有一个胃口值 g[i]&#xff0c;这是能让孩子们满足胃口的饼干的最小尺寸&#xff1…

神经网络算法:卷积神经网络

神经网络算法&#xff0c;也称为人工神经网络算法&#xff0c;是一种模仿人脑神经网络结构和功能的计算模型。它由多个神经元相互连接而成的网络组成&#xff0c;每个神经元都有输入和输出&#xff0c;并通过学习算法来调整连接权重&#xff0c;从而实现对输入数据的模式识别和…

JavaScript Web Socket 详解

Web Socket ​ Web Socket&#xff08;套接字&#xff09;的目标是通过一个长时连接实现与服务器全双工、双向的通信。在 JavaScript 中创建 Web Socket 时&#xff0c;一个 HTTP 请求会发送到服务器以初始化连接。服务器响应后&#xff0c;连接使用 HTTP 的 Upgrade 头部从 H…

12、窗口看门狗

目录 1、窗口看门狗概述 2、常用寄存器和库函数配置 3、窗口看门狗实验 1、窗口看门狗概述 之所以称为窗口就是因为其喂狗时间是一个有上下限的范围内&#xff08;窗口&#xff09;&#xff0c;你可以通过设定相关寄存器&#xff0c;设定其上限时间&#xff08;下限固定&…

数据结构 栈和队列 力扣例题AC——代码以及思路记录

20. 有效的括号 给定一个只包括 (&#xff0c;)&#xff0c;{&#xff0c;}&#xff0c;[&#xff0c;] 的字符串 s &#xff0c;判断字符串是否有效。 有效字符串需满足&#xff1a; 左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。每个右括号都有一个对应…

mysql使用连接池

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、mysql连接池&#xff1f;二、使用步骤1.引入库 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 例如&#xff1a; 提示&#xff1a…

深入理解Flutter中的StreamSubscription和StreamController

在Flutter中&#xff0c;StreamSubscription和StreamController是处理异步数据流的重要工具。它们提供了一种方便的方式来处理来自异步事件源的数据。本文将深入探讨它们的区别以及在实际应用中的使用场景。 StreamSubscription StreamSubscription代表了对数据流的订阅&…

代码随想录算法训练营番外 刷题日记0301 || 29、两数相除,31、下一个排列

29、两数相除 思路&#xff1a;不断相减就是求解的最直接方法&#xff0c;我这样计算时间复杂度有点高 // 时间复杂度O(count*divisor) // 空间复杂度O(1)class Solution {int res 0;public int divide(int dividend, int divisor) {// dividend 是被除数if(dividend 0) …

技术栈选型的时候,ruby、go、java、vue、react应该怎么选择?

选择适合项目需求、团队技术背景和偏好、开发速度、性能要求以及可扩展性的技术栈和框架是一个综合考虑的过程&#xff0c;没有一种通用的最佳选择&#xff0c;取决于具体情况。 选择Vue.js或React应该综合考虑项目的需求、团队的技术背景和偏好、生态系统的支持和发展趋势等因…

随记-点选验证码

文字验证码&#xff08;点击文字&#xff09; 模板匹配&#xff08;从一张图片中寻找 icon&#xff09;&#xff0c;放弃&#xff0c;目前准确率不高&#xff0c;且处理过程复杂 灰度处理将 complete_image_path 截取并另存为 target_image_path&#xff0c; verify_image_path…

WPF真入门教程30--顺风物流单据管理系统

1、教程回顾 到现在为止&#xff0c;真入门系列教程已完成了29刺由浅入深地讲解&#xff0c;当然不可能讲到了WPF的所有技能点&#xff0c;但读者看到了wpf的内部各种功能及之间的联系&#xff0c;在此基础上&#xff0c;提供一个完整有效的综合项目&#xff0c;本项目采用的是…