Golang快速入门教程（一）

news2025/6/21 13:43:02

目录

一、环境搭建

1.windows安装

2.linux安装 

3.开发工具

二、变量定义与输入输出

1.变量定义

2.全局变量与局部变量

3.定义多个变量

4.常量定义

5.命名规范

6.输出

7.输入 

三、基本数据类型

1.整数型

2.浮点型

3.字符型

4.字符串类型

转义字符

多行字符串

5.布尔类型

四、数组、切片、map

1.数组

 2.切片

make函数

切片面试题 

3.Map

map面试题 

一、环境搭建

官网

https://go.dev/dl/

访问不了的就访问中文网就好了

go安装包下载

https://studygolang.com/dl

安装指定版本的安装包就好了

1.windows安装

选择 xxx.windows-amd64.msi

  • 将go的对应bin目录设置为环境变量，这一步是方便可以在命令行里面直接使用go命令
  • 将go的第三方bin目录设置为环境变量，一般是在用户目录下，这一步是为了以后使用go install安装的第三方可执行文件可以直接使用

2.linux安装 

选择 xxx.linux-amd64.tar.gz

该站点比较快：All releases - The Go Programming Language

# 下载

wget https://golang.google.cn/dl/go1.22.2.linux-amd64.tar.gz

# 解压

tar -xvf go1.22.2.linux-arm64.tar.gz -C /usr/local

# 配置环境变量

echo 'export GO111MODULE=on' >> /etc/profile
echo 'export GOROOT=/usr/local/go' >> /etc/profile
echo 'export GOPATH=/home/gopath' >> /etc/profile
echo 'export PATH=$PATH:$GOROOT/bin:$GOPATH/bin' >> /etc/profile

source /etc/profile

# 创建go包安装目录

mkdir -p /home/gopath

# 设置代理

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

# 检查成功

go version

3.开发工具

推荐goland

二、变量定义与输入输出

1.变量定义

package main

import "fmt"

func main() {
  // 先定义，再赋值
  var name string
  name = "os_lee1"
  fmt.Println(name)
  
  // 定义加赋值
  var userName string = "os_lee1"
  fmt.Println(userName)
}

如果一个变量定义了，但是没有赋值，那么这个变量的值就是这个类型的 "零值" 

// 变量类型省略
var name = "os_lee"

// 简单声明
name := "os_lee"

2.全局变量与局部变量

定义在函数体（包括main函数）内的变量都是局部变量，定义了就必须使用
定义在外部的变量就是全局变量，可以只定义不使用 

package main

import "fmt"

// 全局变量可以不使用
var userName = "oslee_全局" 

func main() {
  // 局部变量
  var name = "oslee_局部"
  // 在函数体内定义的变量，必须要使用
  fmt.Println(name)
}

3.定义多个变量

package main

import "fmt"

func main() {
	var name1, name2, name3 string // 定义多个变量

	var a1, a2 = "os", "lee" // 定义多个变量并赋值

	a3, a4 := "os", "lee" // 简短定义多个变量并赋值

	fmt.Printf("name1: %s, name2: %s, name3: %s\n", name1, name2, name3)
	fmt.Printf("a1: %s, a2: %s, a3: %s, a4: %s\n", a1, a2, a3, a4)
}

package main

import "fmt"

var (
	name     string = "os"
	userName        = "os_lee"
)

func main() {
	fmt.Println(name, userName)
}

4.常量定义

定义的时候就要赋值
赋值之后就不能再修改了

package main

import "fmt"

const name string = "os_lee" // 定义就要赋值

func main() {
	fmt.Println(name)
}

5.命名规范

核心思想：首字母大写的变量、函数。方法，属性可在包外进行访问

6.输出

package main

import "fmt"

func main() {
	fmt.Println("os_lee")
	fmt.Println(1)
	fmt.Println(true)
	fmt.Println("什么", "都", "可以", "输出")
}

格式化输出

package main

import "fmt"

func main() {
    fmt.Printf("%v\n", "你好")           // 可以作为任何值的占位符输出
    fmt.Printf("%v %T\n", "os", "lee") // 打印类型
    fmt.Printf("%d\n", 3)              // 整数
    fmt.Printf("%.2f\n", 1.25)         // 小数
    fmt.Printf("%s\n", "哈哈哈")          // 字符串
    fmt.Printf("%#v\n", "")            // 用go的语法格式输出，很适合打印空字符串

    // 还有一个用的比较多的就是将格式化之后的内容赋值给一个变量
    name := fmt.Sprintf("%v", "你好")
    fmt.Println(name)
}

7.输入 

package main

import "fmt"

func main() {
	fmt.Println("输入您的名字：")
	var name string
	fmt.Scan(&name) // 这里记住，要在变量的前面加个&, 后面讲指针会提到
	fmt.Println("你输入的名字是", name)
}

三、基本数据类型

go语言的基本数据类型有

  1. 整数形
  2. 浮点型
  3. 复数
  4. 布尔
  5. 字符串

1.整数型

go语言的整数类型，具体细分有很多

var n1 uint8 = 2 
var n2 uint16 = 2 
var n3 uint32 = 2 
var n4 uint64 = 2 
var n5 uint = 2 
var n6 int8 = 2 
var n7 int16 = 2 
var n8 int32 = 2 
var n9 int64 = 2 
var n10 int = 2 

大家只需要记住以下几点

  1. 默认的数字定义类型是int类型
  2. 带个u就是无符号，只能存正整数
  3. 后面的数字就是2进制的位数
  4. uint8还有一个别名 byte， 一个字节=8个bit位
  5. int类型的大小取决于所使用的平台

例如uint8，那就是8个二进制位，都用来存储数据，那最小就是0，最大就是2的八次方-1=255

那int8，因为要拿一位存符合，使用实际只有七位可用，所以最小的就是负2的七次方=-128，最大的就是2的七次方-1=127

至于为什么要减一，其实很好理解，因为实际到最后一个数字的时候，已经向前进位了，例如一个小时是60分钟，但是分钟最大只有59

第五点的测试

我是64位操作系统，那么我会试一下int是不是就是int64的最大上限

2的63次方-1=9223372036854775807

fmt.Printf("%.0f\n", math.Pow(2, 63))
var n1 int = 9223372036854775807
fmt.Println(n1)
var n2 int = 9223372036854775808 // 看它报不报错
fmt.Println(n2)

2.浮点型

Go语言支持两种浮点型数：float32 和 float64

  • float32 的浮点数的最大范围约为3.4e38，可以使用常量定义：math.MaxFloat32
  • float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64

如果没有显式声明，则默认是float64

3.字符型

注意哦，是字符，不是字符串

比较重要的两个类型是byte（单字节字符）和rune（多字节字符）

package main

import "fmt"

func main() {
	var c1 = 'a'
	var c2 = 97
	fmt.Println(c1) // 直接打印都是数字
	fmt.Println(c2)

	fmt.Printf("%c %c\n", c1, c2) // 以字符的格式打印

	var r1 rune = '中'
	fmt.Printf("%c\n", r1)
}

在 Go 中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8 编码的码值
可以直接给某个变量赋一个数字，然后按格式化输出时 %c ，会输出该数字对应的 unicode 字符
字符类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码。

4.字符串类型

和字符不一样的是，字符的赋值是单引号，字符串的赋值是双引号 

var s string = "lee李"
fmt.Println(s)

转义字符

一些常用的转义字符

fmt.Println("枫枫\t知道")              // 制表符
fmt.Println("枫枫\n知道")              // 回车
fmt.Println("\"枫枫\"知道")            // 双引号
fmt.Println("枫枫\r知道")              // 回到行首
fmt.Println("C:\\pprof\\main.exe") // 反斜杠

多行字符串

在``这个里面，再出现转义字符就会原样输出了

package main

import "fmt"

func main() {
	str := `今天
天气
真好
`
	fmt.Println(str)
}

5.布尔类型

  • 布尔型数据只有 true（真）和 false（假）两个值
  • 布尔类型变量的默认值为false
  • Go 语言中不允许将整型强制转换为布尔型
  • 布尔型无法参与数值运算，也无法与其他类型进行转换

  • 零值问题
    如果我们给一个基本数据类型只声明不赋值，那么这个变量的值就是对应类型的零值，例如int就是0，bool就是false，字符串就是""

package main

import "fmt"

func main() {
	var a1 int
	var a2 float32
	var a3 string
	var a4 bool

	fmt.Printf("%#v\n", a1)
	fmt.Printf("%#v\n", a2)
	fmt.Printf("%#v\n", a3)
	fmt.Printf("%#v\n", a4)
}

四、数组、切片、map

1.数组

数组（Array）是一种非常常见的数据类型，几乎所有的计算机编程语言中都会用到它

  1. 数组里的元素必须全部为同一类型，要嘛全部是字符串，要嘛全部是整数
  2. 声明数组时，必须指定其长度或者大小
package main

import "fmt"

func main() {
	var array [3]int = [3]int{1, 2, 3}
	fmt.Println(array)
	var array1 = [3]int{1, 2, 3}
	fmt.Println(array1)
	var array2 = [...]int{1, 2, 3}
	fmt.Println(array2)
}

 如果要修改某个值，只能根据索引去找然后替换

var array1 = [3]int{1, 2, 3}
array1[0] = 10 // 根据索引找到对应的元素位置，然后替换
fmt.Println(array1)

 2.切片

很明显啊，go里面的数组，长度被限制死了，所以不经常用

所以go出了一个数组plus，叫做slice（切片）

切片（Slice）相较于数组更灵活，因为在声明切片后其长度是可变的

package main

import "fmt"

func main() {
  // 定义一个字符串切片
  var list []string

  list = append(list, "枫枫")
  list = append(list, "知道")
  fmt.Println(list)
  fmt.Println(len(list)) // 切片长度
  // 修改第二个元素
  list[1] = "不知道"
  fmt.Println(list)
}

make函数

除了基本数据类型，其他数据类型如果只定义不赋值，那么实际的值就是nil

// 定义一个字符串切片
var list []string
fmt.Println(list == nil) // true

那么我们可以通过make函数创建指定长度，指定容量的切片了

make([]type, length, capacity)
package main

import "fmt"

func main() {
	// 定义一个字符串切片
	var list = make([]string, 0)
	fmt.Println(list, len(list), cap(list))
	fmt.Println(list == nil) // false

	list1 := make([]int, 2, 2)
	fmt.Println(list1, len(list1), cap(list1))
}

为什么叫切片？
因为切片是数组切出来的

package main

import "fmt"

func main() {
	var list = [...]string{"a", "b", "c"}
	slices := list[:] // 左一刀，右一刀 变成了切片
	fmt.Println(slices)
	fmt.Println(list[1:2]) // b
}

切片排序

package main

import (
	"fmt"
	"sort"
)

func main() {
	var list = []int{4, 5, 3, 2, 7}
	fmt.Println("排序前:", list)
	sort.Ints(list)
	fmt.Println("升序:", list)
	sort.Sort(sort.Reverse(sort.IntSlice(list)))
	fmt.Println("降序:", list)
}

切片面试题 

面试题1：什么是Go语言中的切片？

答案： Go语言中的切片（slices）是一种灵活的、动态大小的、基于数组的抽象数据类型。它并不存储任何数据，而是指向底层数组的一个片段，包含了三个信息：指向数组的指针、长度（len）和容量（cap）。长度表示切片当前拥有的元素个数，容量则是切片可以扩展到的最大元素个数，容量等于或大于长度。

面试题2：切片的扩容是如何工作的？

答案： 当向切片添加元素超出其当前容量时，Go语言会自动扩容切片。扩容的具体策略并不是固定的，但大致遵循以下规则：

  • 如果切片的容量不足以容纳新增元素，Go 会创建一个新的更大的底层数组，将原有数据复制到新数组，并更新切片的指针和容量。
  • 扩容因子通常为原来容量的2倍，但是也可能会根据实际情况调整，比如在Go 1.17版本之后，根据内存分配器的行为，扩容可能会跳跃式增长以更好地适应内存分配器的粒度。
  • 新容量至少会增加到原来的两倍+所需添加的元素数量，以尽量减少频繁的扩容操作。

面试题3：切片与数组有什么区别？

答案：

  1. 长度可变性：

    • 数组（array）的长度在声明时确定并且不能改变。
    • 切片（slice）虽然在声明时可以指定初始长度，但可以在运行时动态改变其长度（增删元素），不过容量有限制。

  2. 存储结构：

    • 数组是一个定长的、连续的内存区域。
    • 切片不是数据结构，它只是一个描述符，指向一个数组的一部分。

  3. 引用行为：

    • 数组变量直接存储数据，赋值操作会复制整个数组的内容。
    • 切片变量存储的是指向数组的指针和长度、容量信息，赋值操作只会复制切片描述符，不会复制底层数据。

面试题4：浅拷贝和深拷贝

浅拷贝（Shallow Copy）： 浅拷贝是创建一个新的切片，但它仍然指向同一个底层数组。这意味着对新切片所做的修改会影响到原始切片所指向的数据。

// 示例1：直接赋值
original := []int{1, 2, 3}
copied := original // 此时copied是对original的浅拷贝

// 示例2：使用内置的copy函数
original := []int{1, 2, 3}
copied := make([]int, len(original))
copy(copied, original) // 这也是浅拷贝，copied和original共享相同的底层数组

深拷贝（Deep Copy）： 深拷贝是创建一个与原始切片完全独立的新切片，包含一个全新的底层数组。对新切片所做的修改不会影响到原始切片。

// 手动循环遍历复制每一个元素
original := []int{1, 2, 3}
copied := make([]int, len(original))
for i, v := range original {
copied[i] = v
}

// 或者使用反射(reflect)包，但请注意这不是最优实践，仅作演示
import "reflect"
original := []int{1, 2, 3}
copied := reflect.ValueOf(original).Clone().Interface().([]int)

3.Map

  1. Go语言中的map(映射、字典)是一种内置的数据结构，它是一个无序的key-value对的集合
  2. map的key必须是基本数据类型，value可以是任意类型
  3. 注意，map使用之前一定要初始化
package main

import "fmt"

func main() {
	// 声明
	var m1 map[string]string
	// 初始化1
	m1 = make(map[string]string)
	// 初始化2
	m1 = map[string]string{}
	// 设置值
	m1["name"] = "枫枫"
	fmt.Println(m1)
	// 取值
	fmt.Println(m1["name"])
	// 删除值
	delete(m1, "name")
	fmt.Println(m1)

	// 声明并赋值
	var m2 = map[string]string{}
	fmt.Println(m2)
	var m3 = make(map[string]string)
	fmt.Println(m3)

}

map取值

  1. 如果只有一个参数接，那这个参数就是值，如果没有，这个值就是类型的零值
  2. 如果两个参数接，那第二个参数就是布尔值，表示是否有这个元素
package main

import "fmt"

func main() {
	// 声明并赋值
	var m1 = map[string]int{
		"age": 21,
	}
	age1 := m1["age1"] // 取一个不存在的
	fmt.Println(age1)
	age2, ok := m1["age1"]
	fmt.Println(age2, ok)
}

map面试题 

面试题1：什么是Go语言中的map？

答案： Go语言中的map是一种关联数组或字典类型的数据结构，它存储键值对（key-value pairs），通过键（key）快速查找对应的值（value）。键和值可以是任何类型，但键的类型必须支持相等比较，通常为整型、浮点型、字符串或复合类型（如结构体，但结构体内的字段必须支持相等比较）。

面试题2：Go语言中的map何时会引发panic？

答案：

  • 在使用尚未初始化的map时（即nil map）执行读写操作，会导致panic。
  • 在迭代map的过程中，如果同时修改该map，也会导致panic，除非使用for range循环迭代并在循环体内使用delete函数删除元素。

面试题3：Go语言中map的扩容是如何进行的？

Go语言中的map在底层实现上使用了哈希表。当map中的元素数量越来越多，达到一定的负载因子时，Go语言会自动触发map的扩容操作。扩容是为了保持map操作的高效性，防止哈希冲突过于密集，导致性能下降。

扩容的具体流程如下：

  1. 负载因子判断： 当map的元素数量（entry count）与其桶（bucket）数量的比例超过一定阈值时（通常大约是6.5），map会触发扩容。这个阈值可以通过runtime包的内部常量mapExpandHeapSize和mapExpandLoadFactor间接推算出来。

  2. 新桶分配： 扩容时，Go会创建一个新的、大小翻倍的哈希表。例如，如果原map的桶数量是2^N，则新表的桶数量将是2^(N+1)。

  3. 元素迁移： Go采用了渐进式（incremental）的迁移策略，不会一次性将所有元素从旧表迁移到新表。在每次map的读写操作时，如果发现正在进行扩容操作，就会顺带将旧表中的部分元素迁移到新表中。每次操作最多迁移两个桶（bucket）的数据。

  4. 保持引用关系： 在扩容过程中，map的旧表和新表会同时存在，直到所有元素都迁移到新表为止。旧表的最后一个桶会存储一个指向新表的指针，以确保在扩容过程中依然能正确找到已迁移的元素。

  5. 空间回收： 所有元素都迁移到新表后，旧表的空间最终会被垃圾回收机制释放。

值得注意的是，上述细节基于Go语言的早期版本，Go语言的map扩容机制在不同版本间可能会有所调整。最新的Go版本可能会根据具体情况采用不同的扩容策略和负载因子阈值。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

RN使用蓝牙扫描

RN使用蓝牙扫描

我项目需要用到蓝牙模块,蓝牙扫描到设备并且获取到电量显示到页面上,因此我做了如下demo,使用了react-native-ble-plx这个插件 点击进入官方文档官方文档 1.安卓环境配置(ios暂定,还没做ios,不过下面的方法是兼容的,自行配置ios权限) android/app/src/main/AndroidManifest.xml…
阅读更多...
API管理平台：你用的到底是哪个？

API管理平台：你用的到底是哪个？

Apifox是不开源的，在github的项目只是readme文件，私有化需要付费。当然saas版目前是免费使用的。 一、Swagger 为了让Swagger界面更加美观，有一些项目可以帮助你实现这一目标。以下是一些流行的项目，它们提供了增强的UI和额外的功…
阅读更多...
代码签名证书：确保软件安全与可信性的关键工具

代码签名证书：确保软件安全与可信性的关键工具

在数字化时代，软件已成为各行各业的核心驱动力。然而，随着网络威胁日益复杂，用户对于软件来源的可靠性、内容的完整性和发布者的可信度提出了更高要求。为满足这一需求，代码签名证书应运而生，它通过先进的加密技术&…
阅读更多...
【SpringBoot】-- mapstruct进行类型转换时Converter实现类不能自动生成代码问题解决

【SpringBoot】-- mapstruct进行类型转换时Converter实现类不能自动生成代码问题解决

问题描述 我的问题如下&#xff1a; 应该在红色区域生成对应的转换细节&#xff0c;但是这里只返回了一个空对象 问题解决 加入lombok-mapstruct-binding依赖,也要注意依赖引用顺序问题 <dependency><groupId>org.projectlombok</groupId><artifactId&…
阅读更多...
【智能优化算法详解】粒子群算法PSO量子粒子群算法QPSO

【智能优化算法详解】粒子群算法PSO量子粒子群算法QPSO

1.粒子群算法PSO 博主言简意赅总结-算法思想&#xff1a;大方向下个体自学习探索群体交流共享 对比适应度找到最优点 背景 粒子群算法&#xff0c;也称粒子群优化算法或鸟群觅食算法&#xff08;Particle Swarm Optimization&#xff09;&#xff0c; 缩写为 PSO。粒子群…
阅读更多...
小白部署springboot+vue网站到服务器踩坑总结【维护更新篇】

小白部署springboot+vue网站到服务器踩坑总结【维护更新篇】

目录 前言如何更新前端nginx安装和启动言归正传&#xff0c;更新前端 如何更新后端杀死进程 前言 在上一篇文章里详细介绍了怎样部署一个前后端分离的网站&#xff0c;链接: 链接在此 但是部署完之后&#xff0c;在本地的开发更新后&#xff0c;重新上传到服务器上又遇到了一些…
阅读更多...
mybatis(5)参数处理＋语句查询

mybatis(5)参数处理＋语句查询

参数处理&#xff0b;语句查询 1、简单单个参数2、Map参数3、实体类参数4、多参数5、Param注解6、语句查询6.1 返回一个实体类对象6.2 返回多个实体类对象 List<>6.3 返回一个Map对象6.4 返回多个Map对象 List<Map>6.5 返回一个大Map6.6 结果映射6.6.1 使用resultM…
阅读更多...
[图解]DDD领域驱动设计伪创新-聚合根01

[图解]DDD领域驱动设计伪创新-聚合根01

0 00:00:00,070 --> 00:00:06,010 今天我们来说一下领域驱动设计的另外一个伪创新&#xff0c;聚合根 1 00:00:06,870 --> 00:00:09,440 这个我们分为几个部分来讲 2 00:00:12,610 --> 00:00:15,580 前面说过很多遍&#xff0c;伪创新 3 00:00:16,760 --> 00:00…
阅读更多...
登陆qq，经常收到qq游戏中心的推送信息，关闭推送信息

登陆qq，经常收到qq游戏中心的推送信息，关闭推送信息

手动关闭推送信息的步骤&#xff1a; 1.点开左侧游戏中心 2、在打开界面&#xff0c;点击左下角自己的头像 3、打开设置中心&#xff0c;关闭所有的推送 4、完成关闭&#xff0c;不会推送了
阅读更多...
基于springboot实现教学资源库系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现教学资源库系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现教学资源库系统演示 摘要 社会的进步&#xff0c;教育行业发展迅速&#xff0c;人们对教育越来越重视&#xff0c;在当今网络普及的情况下&#xff0c;教学模式也开始逐渐网络化&#xff0c;各大高校开始网络教学模式。 本文研究的教学资源库系统基于Sprin…
阅读更多...
锂电池升降压转换利器：PW2224转换器，实现3.3V高效持续输出

锂电池升降压转换利器：PW2224转换器，实现3.3V高效持续输出

描述&#xff1a; PW2224是一款专为锂电池供电设备设计的高效单电感降压-升压转换器。这款转换器能够在3V至4.2V的锂电池输入电压范围内工作&#xff0c;实现升降压模式自动切换&#xff0c;稳定输出3.3V电压&#xff0c;并持续提供高达1A的负载电流。此外&#xff0c;PW2224的…
阅读更多...
Linux C++ 029-STL之queue容器

Linux C++ 029-STL之queue容器

Linux C 029-STL之queue容器 本节关键字&#xff1a;Linux、C、queue 相关库函数&#xff1a;push、pop、back、front queue基本概念 概念&#xff1a;queue是一种先进先出&#xff08;First In Fisrst Out&#xff0c;FIFO&#xff09;的数据结构&#xff0c;它有两个端口 关…
阅读更多...
数据可视化-ECharts Html项目实战（11）

数据可视化-ECharts Html项目实战（11）

在之前的文章中&#xff0c;我们学习了如何在ECharts中特殊图表的双y图以及自定义形状词云图。想了解的朋友可以查看这篇文章。同时&#xff0c;希望我的文章能帮助到你&#xff0c;如果觉得我的文章写的不错&#xff0c;请留下你宝贵的点赞&#xff0c;谢谢。 数据可视化-ECh…
阅读更多...
栈与队列2s总结（不含单调栈)

栈与队列2s总结（不含单调栈)

6.栈与队列 栈与队列理论基础 队列是先进先出&#xff0c;栈是先进后出。 C中stack 是容器么&#xff1f; 我们使用的stack是属于哪个版本的STL&#xff1f; 我们使用的STL中stack是如何实现的&#xff1f; stack 提供迭代器来遍历stack空间么&#xff1f; 栈和队列是STL…
阅读更多...
甘特图在生产进度管理中的应用

甘特图在生产进度管理中的应用

生产进度管理在生产制造过程中起着至关重要的作用。 它主要关注对生产进程的掌控和安排&#xff0c;确保生产活动能够按照预定的计划和时间顺利进行&#xff0c;以达到按时交付产品的目标。 在生产进度管理中&#xff0c;首先需要制定一个详细且合理的生产计划&#xff0c;明…
阅读更多...
Ubuntu20.04安装ROS过程记录以及常见报错处理

Ubuntu20.04安装ROS过程记录以及常见报错处理

官网安装步骤如下&#xff1a; http://wiki.ros.org/cn/noetic/Installation/Ubuntu#A.2BXwBZy1uJiMU- 第一个&#xff1a;添加ROS软件源 sudo sh -c echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-la…
阅读更多...
第十二届蓝桥杯省赛真题（C/C++大学B组）

第十二届蓝桥杯省赛真题（C/C++大学B组）

目录 #A 空间 #B 卡片 #C 直线 #D 货物摆放 #E 路径 #F 时间显示 #G 砝码称重 #H 杨辉三角形 #I 双向排序 #J 括号序列 #A 空间 #include <bits/stdc.h> using namespace std;int main() {cout<<256 * 1024 * 1024 / 4<<endl;return 0; } #B 卡片…
阅读更多...
【正点原子Linux连载】第二十九章 Linux RTC驱动实验摘自【正点原子】ATK-DLRK3568嵌入式Linux驱动开发指南

【正点原子Linux连载】第二十九章 Linux RTC驱动实验摘自【正点原子】ATK-DLRK3568嵌入式Linux驱动开发指南

1&#xff09;实验平台&#xff1a;正点原子ATK-DLRK3568开发板 2&#xff09;平台购买地址&#xff1a;https://detail.tmall.com/item.htm?id731866264428 3&#xff09;全套实验源码手册视频下载地址&#xff1a; http://www.openedv.com/docs/boards/xiaoxitongban 第二十…
阅读更多...
自动驾驶定位算法-递归贝叶斯滤波(Bayes Filter)

自动驾驶定位算法-递归贝叶斯滤波(Bayes Filter)

自动驾驶定位算法-递归贝叶斯滤波(Bayes Filter) 附赠自动驾驶学习资料和量产经验&#xff1a;链接 贝叶斯滤波器(Bayes Filter)是无人驾驶汽车中高精定位相关的基础技术&#xff0c;同时也是机器人技术中的基础算法。 如上图&#xff0c;开始机器人不知道自己在哪里&#xff…
阅读更多...
图解二叉树遍历方法-前序遍历、中序遍历、后序遍历

图解二叉树遍历方法-前序遍历、中序遍历、后序遍历

一、几个概念 二叉树&#xff08;binary tree&#xff09;&#xff1a;是 n&#xff08;n > 0&#xff09;个结点&#xff08;每个结点最多只有2棵子树&#xff09;的有限集合&#xff0c;该集合可为空集&#xff08;称为空二叉树&#xff09;&#xff0c;或由一个根节点和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023