学习笔记 | Golang基础，Go语言快速入门！

最新推荐文章于 2024-09-28 20:34:52 发布
最新推荐文章于 2024-09-28 20:34:52 发布
阅读量694 收藏 4
点赞数 5
分类专栏： 学习笔记 文章标签： 学习 笔记 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53469830/article/details/142617452
版权

本文将介绍 Go 语言的基础语法，包括环境配置、数据类型、流程控制、函数、结构体、接口、异常、文本处理、并发编程、网络编程等。本文是对多个 Go 入门视频的总结，并结合个人理解对内容进行了简化。由于水平有限，文中可能存在些许错误，烦请评判指正。

前言

Go 的作者：Rob Pike（罗伯·派克）、Ken Thompson（肯·汤姆森）、Robert Griesemer（罗伯特·格里茨默）。

Go 的开源时间：2009 年 11 月 10 日。

Rob Pike 曾说：“你是否认同 Go，取决于你是否认同少就是多，还是少就是少（Less is more or less is less）”。Go 的设计哲学是：将简单、使用体现得淋漓尽致。

使用 Go 的项目：Docker、Kubernetes、etcd、beego、codis。

使用 Go 的公司：Google、Faebook、腾讯、百度、七牛云、京东、小米、字节跳动。

环境配置

下载地址：All releases - The Go Programming Language (google.cn)，推荐下载 zip 格式。

配置环境变量：添加以下变量，并将 %GOROOT%\bin 添加到 Path 变量中。

变量值说明
GOROOTD:\Development\Environment\Go\Go-1.23.1Go 安装目录
GOPATHD:\LocalRepository\GoGo 依赖安装目录
GOPROXYhttps://mirrors.aliyun.com/goproxy/Go 依赖镜像

CMD 执行 go version 查看 Go 版本。

集成开发环境：GoLand by JetBrains: More than just a Go IDE

基础语法

注释
// 单行注释（推荐）

/*
多行注释
*/
包
package main


// 普通
import "fmt"

// 忽略
import _ "fmt"

// “解构”
import . "fmt"

// 别名
import ifmp "fmt"

// “分组”
import (
	"fmt"
    "os"
)

// 主函数
func main(){
    
}

一个可执行程序必须包含一个 main 包，一个 main 包必须包含一个 main 函数。

所在目录（父级）相同 go 文件的包名必须相同。

变量

变量被声明后必须被使用。

// 定义
var a int
var a, b string
var (
	a string
    b string
)
// 定义并初始化
var a string = "a"
var a, b string = "a", "b"
var a, b = "a", "b"
a, b := "a", "b"			// 自动类型推导

零值（默认值）：整型为0，浮点型为0.0，字符串为空字符串，布尔型为false，切片、函数、指针默认为 nil。

变量遵循驼峰命名。对于全局变量，若首字母大写，则认定为 “public”。

交换变量的值。

a, b, c = b, c, a

匿名变量。匿名变量不占用空间，不会分配内存。

a, _ := getTwo()
_ = getOne()

变量作用域：局部变量、全局变量。全局变量与局部变量可同名。

// 全局变量
age := 14

func main(){
    // 局部变量
    age := 15
    fmt.Println(age)	// 15
}

常量。常量的定义和初始化与变量类似。

// 单个常量
const a = 1

// 多个常量
const a, b = 1, 2
const (
	b = 2
    c = 3
)

// iota
const (
    a = iota	// 0
    b 			// 1
    c = "c"		// c
    d			// c
    e = 100		// 100
    f			// 100
    g = iota	// 6
    h			// 7
)
const (
	i = iota	//0
    j			// 1
)
数据类型

布尔型：默认 false。

 var flag = true

整型。字符用 int32 存储。

类型描述
uint8 / byte0 到 2^8
uint160 到 2^16
uint32 / uint（32位系统）0 到 2^32
uint64 / uint（64位系统）0 到 2^64
int8-2^7 到 2^7-1
int16-2^15 到 2^15-1
int32 / rune / int（32位系统）-2^31 到 2^31-1
int64 / int（64位系统）-2^63 到 2^64-1

浮点型。

类型描述
float32IEEE-754 32 位浮点数
float64IEEE-754 64 位浮点数

字符串。

var s string = "tom"
fmt.Println(s[0])

类型转换。

// 数值转数值
b := float64(a)

// 转字符串
s := strconv.FormatInt(int64(v), 10)
s := strconv.Itoa(v)	// 特殊

// 字符串转数值
v, _ := strconv.ParseInt(s, 10)
v, _ := strconv.Atoi(s)	// 特殊

指针：无需手动回收，内存回收由 GC 自动完成。

var p *int		// 默认nil
var p = &a
var p = new(int)

var b = *p

数组：数组大小必须为常量。

var arr [5]int
var arr [5]int = [5]int{1, 2}	// 未初始化的值默认为0
var arr = [5]int{1, 2, 3, 4}
arr := [5]int{1, 2, 3, 4}

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

切片：自动扩容。

var a []int
var a []int = []int{1, 2, 3}
var a = []int{1, 2, 3}
a := []int{1, 2, 3}
a := make([]int, 10, 15)	// 类型 长度 容量

// 长度
len(a)
// 容量
cap(a)

// 追加
a = append(a, 1)
a = append(a, b...)

// 截取
b := a[1:2:1]	// [low:high:max] 左边右开 长度=high-low 容量=max-high
b := a[1:2]
b := a[:2]
b := a[1:]

// 数组切片-浅拷贝
a := []int{1, 2, 3}
b := a[1:2]
b = append(b, 4)
b[0] = 5
fmt.Println(a)	// 1 5 4
fmt.Println(b)	// 5 4

map。

var mp map[string]int
var mp = map[string]int{"a": 1, "b": 2}
mp := make(map[string]int, 10)
运算符

算术运算符

+	-	*	/	%	++	--

关系运算符

==	!=	>	>=	<	<=

逻辑运算符

&&	||	!

位运算符：a &^ b，将 a 中与 b 中 1 的对应位置 0，称为位清空。

&	|	^	&^	<<	>>

赋值运算符

=    +=    -=    *=    /=    %=    <<=    >>=    &=    ^=    |=
输入输出
fmt.Println(1)
fmt.Printf("%d", 2)
fmt.Print(3)

fmt.Scan(&age)
fmt.Scanln(&age)
fmt.Scanf("%s", &age)
流程控制

if-else

if age < 18 {

} else if age < 35 {

} else {

}

// 含初始化语句
if a := 10; a >= 10 {

} else if b := 20; b >= 20 {

}else {}

switch：fallthrough、break。

// 执行匹配项
switch age {
    case 18:{}
    case 35, 45:{}
    default:{}
}

// 执行最后一个匹配项
switch {
    case age < 18:{}
    case age < 35:{}
    default:{}
}

// 执行true
switch {
	case true:{}
	case false:{}
	default:{}
}

// fallthrough执行下一个case
// break跳出switch
switch idx {
	case 1:
		fallthrough
	case 2:
    	break
    	fallthrough
	default:
}

// 判断类型
switch x.(type) {
	case string:
	case int:
	default:
}

for：break、continue。

for i := 0; i < 10; i++ {}

i := 0
for ; i < 10; i++ {}

i := 0
for i < 10 { i++ }

for { }

for i := range s {}

for i, ch := range s { }

goto

func f() {
	goto L1
	fmt.Println(1)
L1:
	fmt.Println(2)
}
函数
func say(a, b string) (c, d string) {
	return b, a
}
func main() {
    e, f := say("a", "b")
}

// 可变参数
func say(cnt int, args ...string) {
	fmt.Println(cnt)
	for _, v := range args {
		fmt.Println(v)
	}
}

// 匿名函数（立即执行）
func main() {
	func() {
		fmt.Println("s")
	}()
}

参数传递

  • 值传递：int、float64、string、bool、array等。
  • 引用传递：slice、map、chan等。
// 执行顺序：d、e、c、b、a，defer逆序执行
func main() {
	defer a()
	defer b()
	defer c()
    d()
    e()
}

// 函数类型
var f  func(int,int)
var f = func(int, int) { }

// 回调函数
func f1(a, b int) int {
	return a + b
}
func f2(a, b int, f func(int, int) int) int {
	return f(a, b)
}

// 闭包
func main() {
	fc := f()
	fmt.Println(fc()) // 1
	fmt.Println(fc()) // 2

}
func f() func() int {
	i := 0
	return func() int {
		i++
		return i
	}
}

main 函数：一个可执行程序必须包含一个 main 包，一个 main 包必须包含一个 main 函数，仅 main 包下的 main 可作为入口函数。

package main

func main() {
	
}

init 函数：在导入一个包的同时，会直接执行这个包的 init()，main 包的 init() 会先于 main() 执行。

内置函数。

len()
cap()

a = append(a, 1)
a = append(a, b...)

a := []int{1, 2, 3}
b := []int{4, 5}
copy(a, b)
fmt.Println(a)	// 4 5 3
fmt.Println(b)	// 4 5

delete(a, 1)
编码规范

导包。

import (
	"fmt"
    "json"
)

命名：一个目录一个 go 文件，go 文件包名与目录名保持一致，包名与目录名采用小写，多个单词用下划线分隔。

结构体

type Student struct {
	id   int
	name string
}
func main() {
    // 按顺序赋值
	var s1 = Student{1, "tom"}
    // 指定字段赋值
	var s2 = Student{
		id:   1,
		name: "tom",
	}
    // 指针
	s3 := &s1
	s4 := new(Student)
    
	fmt.Println(s1.id, s2.name)
}


type Student struct {
	id   int
    // 首字母大写才可跨包可见（public）
	Name string
}
继承
// 结构体匿名变量
type Person struct {
	id int
}
type Student struct {
	Person
	name string
}

func main() {
	s := Student{Person{1}, "tom"}
	s.Person= Person{2}
	s.Person.id = 1
	s.id = 2
	s.name = "jack"
}

// 结构体指针匿名变量
type Person struct {
	id int
}
type Student struct {
	*Person
	name string
}

func main() {
	s := Student{&Person{1}, "tom"}
}

// 同名变量
type Person struct {
	id int
}
type Student struct {
	*Person
	id int
}

func main() {
	s := Student{&Person{1}, 2}
	fmt.Println(s.id)				// 2
}

// 非结构体类型匿名变量
type Student struct {
	int
}

func main() {
	s := Student{1}
	fmt.Println(s.int)
}
方法
type Student struct {
	id int
}
// 方法挂载到自定义类型
func (s Student) say() {
    // s是实参的拷贝
	fmt.Println(s.id)
}
func main() {
	 Student{1}.say()
}

type str string
// 方法挂载到自定义类型
func (s str) say() {
	fmt.Println(s)
}
func main() {
	s := str("hi")
	s.say()
}

方法集：指针变量和非指针变量可看作共用方法集（语法糖）

type Student struct {
	age int
}
func (s *Student) add(v int) {
	s.age += v
}
func main() {
	s := Student{1}
	s.add(1)
	fmt.Println(s.age)	// 2
}

方法的继承。

type Person struct {
	id int
}
type Student struct {
	Person
}

func (p *Person) say() {
	fmt.Println(p.id)
}
func main() {
	s := Student{Person{1}}
	s.say()
}

方法的重写。

type Person struct {
	id int
}
type Student struct {
	Person
}

func (p *Person) say() {
	fmt.Println("p")
}

func (s *Student) say() {
	fmt.Println("s")
}
func main() {
	s := Student{Person{1}}
	s.say()			// s
    s.Person.say()	// p
}

方法值。

p := Person{1}
pf := p.say
pf()

方法表达式。

p := Person{1}
pf := (*Person).say
pf(&p)

接口

若一个类型实现了一个接口的所有方法，便认为该类型体实现了该接口。

type Person interface {
	say()
}
type Student struct {
}

func (s *Student) say() {
	fmt.Println("Student")
}

func main() {
	var p Person = new(Student)
    // 多态
	p.say()
}
接口的继承
type Person interface {
	say()
}
type GoodPerson interface {
	Person
}

type Person interface {
	say()
}
type GoodPerson interface {
	Person
	sayGood()
}
type Student struct {}

func (s *Student) say() {}
func (s *Student) sayGood() {}

func main() {
	var p Person = &Student{}
	var gp GoodPerson = &Student{}
	// 下转上
	p = gp
	// 上转下 不允许
	// gp = p
空接口

可以将任何类型的值赋给空类型的变量。

var v interface{}
v = &Student{}

类型断言。

// 断言v是Person类型
// ok=true表示断言成功，否则断言失败
// 若断言成功，则会将v转为Person类型并赋给sv，否则sv为零值
if sv, ok := v.(Person); ok {
    sv.say()
}

func main() {
	var v interface{}
	v = &Student{}	// Student实现了Person
	switch v.(type) {
        case int:
            fmt.Println("int")
        case Student:
            fmt.Println("Student")
        case Person:
            fmt.Println("Person")
        default:
            fmt.Println("default")
	}
}
// 输出Person

异常

内置 error 接口。

// builtin.go
type error interface {
	Error() string
}

error 接口的实现。

// errors.go
type errorString struct {
	s string
}
func (e *errorString) Error() string {
	return e.s
}

使用。

func main() {
	err := fmt.Errorf("%s", "error msg")
	fmt.Println(err)
}
func main() {
	err:=errors.New("error msg")
	fmt.Println(err)
}

func div(a, b int) (res int, err error) {
	if b == 0 {
		err = errors.New("divide by zero")
	} else {
		res = a / b
	}
	return
}
func main() {
	res, err := div(10, 0)
	fmt.Println(res, err)
}

当发生致命错误时，可调用 panic 函数中断程序。

func div(a, b int) (res int, err error) {
	if b == 0 {
		panic("divide by zero")
	}
	res = a / b
	return
}

recover 函数可拦截异常。

func div(a, b int) (res int, err error) {
	defer func() {
		if e := recover(); e != nil {
			fmt.Println(e)
		}
	}()
	if b == 0 {
		panic(errors.New("divide by zero"))
	}
	res = a / b
	return
}

文本处理

字符串操作。

strings.Contains()
strings.Join()
strings.Index()
strings.Repeat()
strings.Replace()
strings.Split()
strings.Trim()
strings.Fields()

字符串转换。

// 其他类型转string
strconv.FormatXXX()
// string转其他类型
strconv.ParseXXX()

正则表达式。

func main() {
	r, s := ".*", "abc"
	reg := regexp.MustCompile(r)
	reg.Match([]byte(s))
	reg.FindStringIndex(s)
}

JSON。

type Student struct {
	Id   int    `json:"id"`
	Name string `json:"-"`
	Flag bool   `json:"flag,string"`
}

func main() {
	s := Student{1, "tom", true}
	js, _ := json.Marshal(s)
	_ = json.Unmarshal(js, &s)
}

文件操作

创建/打开文件

func Create(name string) (*File, error)
func Open(name string) (*File, error) 
func OpenFile(name string, flag int, perm FileMode) (*File, error)

写文件

func WriteFile(name string, data []byte, perm FileMode) error

读文件

func ReadFile(name string) ([]byte, error)

删除文件

func Remove(name string) error
func RemoveAll(path string) error

命令行参数

os.Args

并发编程

协程
func main() {
	go func() {
		
	}()
}

// 设置CPU核数
runtime.GOMAXPROCS(1)
// 当前协程让出时间片
runtime.Gosched()
// 退出当前协程
runtime.Goexit()
channel

goroutine奉行通过通信来共享内存，而不是通过共享内存来通信。

// 通道-无缓冲
var ch = make(chan int)

func main() {
	go func() {
		// 存放数据，阻塞等待
		ch <- 1
	}()
	// 阻塞等待，获取数据
	d := <-ch
	fmt.Println(d)
}

// 通道-有缓冲
var ch = make(chan int, 2)

func main() {
	cnt := 3
	go func() {
		for i := 0; i < cnt; i++ {
			// 存放数据，缓存区满时阻塞等待
			ch <- 1
		}
	}()
	for i := 0; i < cnt; i++ {
		// 阻塞等待数据
		d := <-ch
		fmt.Println(d)
	}
}

// 关闭通道
func main() {
	ch := make(chan int, 2)
	go func() {
		for i := 0; i < 3; i++ {
			ch <- 1
		}
		close(ch)
	}()
	for {
		if v, ok := <-ch; ok {
			fmt.Println(v)
		} else {
			break
		}
	}
}
func main() {
	ch := make(chan int, 2)
	go func() {
		for i := 0; i < 3; i++ {
			ch <- 1
		}
		close(ch)
	}()
	for d := range ch {
		fmt.Println(d)
	}
}

// 双向 单向
func main() {
	// 双向
	ch := make(chan int, 2)
	// 单向只读
	var rch <-chan int = ch
	// 单向只写
	var wch chan<- int = ch
}

// 通道参数
func main() {
	ch := make(chan int, 2)
	go read(ch)
	go write(ch)
}

func read(rch <-chan int) {}
func write(wch chan<- int) {}
定时器
// 等待5s
timer := time.NewTimer(5 * time.Second)
<-timer.C	

// 等待1s
time.Sleep(1 * time.Second)

// 等待5s
time.After(5 * time.Second)

timer :=time.NewTimer(time.Second)
// 重设定时器
timer.Reset(time.Minute)
// 停止定时器
timer.Stop()

// 定时执行
ticker := time.NewTicker(2 * time.Second)
for i := 0; ; i++ {
    <-ticker.C
    fmt.Println(time.Now().Unix())
    if i >= 10 {
        ticker.Stop()
        break
    }
}

// select
func main() {
	c1, c2 := make(chan int), make(chan int)
	go func() {
		x, y := 1, 2
		for i := 0; i < 10; i++ {
			select {
			// 写数据
			case c1 <- x:
				fmt.Println("c1", i, x)
				x, y = y, x
				// 读数据
			case k := <-c2:
				fmt.Println("c2", i, k)
			}
		}
		// 对于每轮循环，select会随机选择一个未阻塞的case来执行
		// 如果所有case都阻塞，select会阻塞 
	}()
	for i := 0; i < 3; i++ {
		// 读数据
		<-c1
		// 写数据
		c2 <- i
	}
}

// 超时取消
go func() {
label:
    for {
        select {
        case v := <-ch:
            fmt.Println(v)
        case <-time.After(time.Second * 5):
            fmt.Println("timeout")
            break label
        }
    }
}()

网络编程

Scoket编程

服务端。

func main() {
	// 监听
	listener, _ := net.Listen("tcp", ":8080")
	defer listener.Close()
	// 处理请求
	for {
		conn, _ := listener.Accept()
		go handleConn(conn)
	}
}

func handleConn(conn net.Conn) {
	buf := make([]byte, 1024)
	n, _ := conn.Read(buf)
	fmt.Println(string(buf[:n]))
	_ = conn.Close()
}

客户端。

func main() {
	conn, _ := net.Dial("tcp", ":8080")
	// 连接服务器
	defer conn.Close()
	// 发送数据
	_, _ = conn.Write([]byte("Hi"))
}
Http编程

服务端。

func main() {
	// 处理请求
	http.HandleFunc("/", handleConn)
	// 监听
	_ = http.ListenAndServe(":8080", nil)
}

func handleConn(w http.ResponseWriter, req *http.Request) {
	_, _ = w.Write([]byte("Hi"))
}

客户端。

func main() {
	resp, _ := http.Get("https://www.baidu.com")
	defer resp.Body.Close()
	buf := make([]byte, 10240)
	n, _ := resp.Body.Read(buf)
	fmt.Println(string(buf[:n]))
}

END

以上就是本文的全部内容，文档会根据自己的实际使用和各位提出的问题而不断更新。

如果觉得本文对您有一点点帮助，欢迎点赞、转发加关注，这会对我有非常大的帮助，如果有任何问题，欢迎在评论区留言，咱们下期见！

字节幺零二四
关注
专栏目录
Go语言学习笔记—golang基础语法
qq_39280718的博客
06-17 2551
golang基础语法
Go语言学习笔记—golang基础简介
qq_39280718的博客
06-14 608
Go语言简称golang，是一种静态强类型、编译型语言。
Go/golang语言学习笔记（一）：基础入门
qq_63536895的博客
10-13 524
go语言学习笔记
Go语言学习笔记—golang方法
qq_39280718的博客
06-25 329
Go中的方法，是一种**特殊的函数**，定义于结构体struct之上（与struct关联、绑定），被称为struct的接受者（receiver）。通俗的讲，方法就是有接收者的函数。
go语言入门学习笔记（三）
weixin_51530404的博客
01-14 635
接上一篇。
Go语言学习笔记—golang包管理
qq_39280718的博客
06-27 2086
包的本质实际上就是创建不同的文件夹，来存放程序文件。
Go语言自学系列 | golang标准库bytes
COCO_gsta的博客
06-13 1583
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》一边学习一边整理老师的课程内容及试验笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：Go语言自学系列 | 汇总_COCOgsta的博客-CSDN博客_自学go语言bytes包提供了对字节切片进行读写操作的一系列函数，字节切片处理的函数比较多分为基本处理函数、比较函数、后缀检查函数、索引函数、分割函数、大小写处理函数和子切片处理函数等。 运行结果 Buffer类型 缓冲区是具有读取和写入
Go语言自学系列 | golang标准库log
COCO_gsta的博客
06-03 1136
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》一边学习一边整理老师的课程内容及试验笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：Go语言自学系列 | 汇总_COCOgsta的博客-CSDN博客_go语言自学golang内置了log包，实现简单的日志服务。通过调用log包的函数，可以实现简单的日志打印功能。log包中有3个系列的日志打印函数，分别print系列、panic系列、fatal系列。函数系列作用print单纯打印日志panic打印
golang学习笔记——基础01
e891377的专栏
11-18 374
golang学习笔记——基础01
Go语言学习笔记 pdf
09-27
作为时下流行的一种系统编程语言，Go 简单易学，性能很好，且支持各类主流平台。已有大量项目采用 Go 编写，这其中就包括 Docker 等明星作品，其开发和执行效率早已被证明。本书经四年多逐步完善，内容覆盖了语言、...
Spring Boot 学习和使用
cesske的博客
09-24 1067
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
Go基础学习08-并发安全型类型-通道（chan）深入研究
最新发布
FLJS_T的博客
09-28 553
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。元素值的发送和接收都需要用到操作符
大模型输入参数学习
AI智能，无处不在
09-25 336
top_p和top_k：用于控制生成文本的多样性和连贯性。较小的值会使生成的文本更连贯但缺乏多样性，较大的值会使生成的文本更随机和多样。：用于控制生成文本的随机性。较高的值增加随机性，较低的值增加确定性。：用于控制生成文本的长度。
Linux入门学习：进程概念
Lvision2的博客
09-24 1067
在课本的概念中，进程程序的一个执行实例，正在执行的程序。其内核观点：担当分配系统资源（CPU时间，内存）的实体。但这些概念太笼统，并不能让我们更加清晰的知道进程是什么，实际上，进程是内核数据结构(pcb) + 程序的代码与数据。pcb(process control block)进程控制块，进程信息被放在一个叫pcb的数据结构中，可以理解为进程属性的集合。在Linux入门学习：深刻理解计算机硬件与OS体系中，我们已经了解到。
Nexus学习
howwickhappy的博客
09-24 979
Nexus 是一个开源的仓库管理器，用于管理和分发软件构建的组件。
2024-2025华为ICT大赛报名｜赛前辅导｜学习资料
qq2859066538的博客
09-25 262
华为ICT大赛是华为公司打造的面向全球高校的年度ICT赛事，大赛以“联接、荣耀、未来”为主题，协同政府、高等教育机构、培训机构和行业企业，促进高校ICT人才培养、成长和就业，助力ICT人才生态繁荣。华为ICT大赛2023-2024实践赛涵盖网络、云、计算（第九届华为ICT大赛更名为基础软件）和昇腾AI四个赛道。为有效帮助参赛者把握命题思路、突破重点内容、检验学习效果、提高实战经验，更充分地备战大赛，华为首次推出华为ICT大赛2023-2024实践赛真题实战系列课程，为您铺就通往大赛的成功之路。
js基础巩固学习，包含数据类型、继承、闭包、数组、异步、垃圾回收机制等
m0_73761441的博客
09-23 1602
js基础巩固学习，包含数据类型、继承、闭包、数组、异步、垃圾回收机制等
智能指针学习笔记
weixin_42130300的博客
09-24 292
1. 共享指针总体的使用来说是不线程安全的（构造和析构时才会改变引用计数，但是在访问资源时是不安全的）。可以对引用计数改变时加锁，或者将+或-操作改变为原子操作。3. 不可以将shared_ptr转换为unique_ptr。unique_ptr可以转换为shared_ptr，通过std::move。1. 关于int，成员变量的引用计数必须是int*。不可以直接是int，不然没有引用计数的作用。2. 关于是否可以声明为静态成员。不可以，否则每一个相同类型的对象都共享该计数。需要通过weak_ptr进行解决。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值