go入门笔记二(数据类型及转换、指针)_go fmt.sprint 指针值-CSDN博客

本文链接：https://blog.csdn.net/hkduan/article/details/123846119

Go 的数据类型分四大类：基础类型，聚合类型，引用类型和接口类型。
Go 同时具备有符号整数和无符号整数。有符号整数分四种大小：8位、16位、32位、64位，用 int8、int16、int32、int64 表示，对应的无符号整数是 uint8、uint16、uint32、uint64。
1.Go语言按类别有以下几种数据类型：
byte = uint8 = 0-255

在这里插入图片描述
支持八进制、六进制，以及科学记数法。标准库 math 定义了各数字类型取值范围。

     a, b, c, d := 071, 0x1F, 1e9, math.MinInt16

引用类型空指针值 nil，而非C/C++ NULL。

2.float浮点数
float64精度高，开发中推荐使用。因为float32会精度丢失
在这里插入图片描述
unsafe，大数安全判断

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var num1 float32 = 3.14159265
	fmt.Println(num1)
	fmt.Println("num1占用的大小:", unsafe.Sizeof(num1))

	var num2 float32 = 113.14159265
	fmt.Println("num2=", num2)

	var num3 float32 = -8.14159265
	fmt.Println("num3:", num3)
}

3.char

package main

import (
	"fmt"
)

func main() {
	var c1 = 'a'
	var c2 = 'b'

	fmt.Println(c1, c2)
	fmt.Printf("%c %c\n", c1, c2) // a b
	// fmt.Printf("%v", c1)

	// var c3 byte = '学' // byte只能存1字节8位，汉字是2字节16位
	var c4 int = '学'
	fmt.Printf("%T", c4)
	fmt.Printf("%x %d", c4, c4) //十六进制5b66  十进制23398
}

4. string

```go
package main

import "fmt"

func main() {
	// go中字符串中，不能修改单个字符；可以添加或者修改多个字符
	str1 := "abcd"
	str1 = "cdf" + "123"
	fmt.Printf(str1) //打印字符串

	str2 := 'a'        //单引号只能赋值1个字符
	str3 := "334\n443" // 双引号，识别转意符
	str4 := `334\n443` // 不识别转意符
	fmt.Println(str2, str3)
	fmt.Println(str4)
}

默认值

![在这里插入图片描述](https://img-blog.csdnimg.cn/8d475d4f55c047abb6a70fa14586aece.png)

6.数据类型转换
6.1 基本类型转string
```go
package main

import "fmt"

func main() {
	var i int32 = 100
	var n1 float32 = float32(i)
	var n2 int8 = int8(i)
	var n3 int64 = int64(i)

	// 小类型强制转换大类型，数据可能溢出
	var n4 int64 = 9999
	var n5 int8 = int8(n4) //打印出来15

	// float64->float32也会出现溢出
	var n6 float64 = 3.1415926535
	var n7 float32 = float32(n6) //3.1415927
	var n8 bool = true
	var n9 byte = 'a'
	var str string = string(i)
	fmt.Printf("i=%T %T %T %v %v\n", n1, n2, n3, n5, n7)
	// fmt.Printf("%q", "喜欢你")
	str = fmt.Sprintf("%d", i)  // 数字转string
	str = fmt.Sprintf("%f", n1) // 浮点转string
	str = fmt.Sprintf("%T", n8) // bool转string
	str = fmt.Sprintf("%c", n9) // bool转string
	fmt.Printf("%T %v", str, str)
}

6.2 string转基本类型
strconv&

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 当前的s是十进制, 最终的结果为十进制下int64类型的结果
	a, _ := strconv.ParseInt("-42", 10, 64)
	fmt.Println(a)
	// 当前的s是二进制
	var b int64
	b, _ = strconv.ParseInt("1110", 2, 64)
	// fmt.Println(b)
	fmt.Printf("%T %v\n", b, b)
	// 当前的s是十六进制
	var c int // 如果是自适应int类型，需要用Atoi转
	// c, _ = strconv.ParseInt("AB", 2, 8) //这样写会报错
	c, _ = strconv.Atoi("30")
	fmt.Printf("%T %v\n", c, c)

	d, _ := strconv.ParseFloat("3.141592653589793", 64)
	fmt.Printf("%T %v\n", d, d)

	e, _ := strconv.ParseBool("true")
	fmt.Printf("%T %v\n", e, e)

	f, _ := strconv.ParseInt("a", 10, 64) // 如果字符转int，就变成0
	fmt.Printf("%T %v\n", f, f)
}

//string到int (这个默认是int32类型的)
int,err := strconv.Atoi(string)  

#string到int64  
int64, err := strconv.ParseInt(string, 10, 64)  
//第二个参数为基数（2~36），
//第三个参数位大小表示期望转换的结果类型，其值可以为0, 8, 16, 32和64，
//分别对应 int, int8, int16, int32和int64

#int到string  
string := strconv.Itoa(int) 
//等价于
string := strconv.FormatInt(int64(int),10)
 
#int64到string  
string := strconv.FormatInt(int64,10)  
//第二个参数为基数，可选2~36
//对于无符号整形，可以使用FormatUint(i uint64, base int)

7.自定义数据类型&类型别名
type myInt int // 自定义数据类型
type myInt2 = int //类型别名=

//自定义数据类型
type myInt int

var I100 myInt = 1000

// 类型别名
type myInt2 = int

var aa2 myInt2 = 1000

func init() {
	fmt.Println("aaa:", aa == int(I100))
	fmt.Println("bbb:", aa == aa2)
}

struct结构体

package main

import "fmt"

type person struct {
	name string
	age  int
}

type person2 struct { //继承person
	*person
	sex string
}
type point struct {
	x int
	y int
}

type rect struct {
	p1, p2 *point
}

var aa int = 1000

//自定义数据类型
type myInt int

var I100 myInt = 1000

// 类型别名
type myInt2 = int

var aa2 myInt2 = 1000

func init() {
	fmt.Println("aaa:", aa == int(I100))
	fmt.Println("bbb:", aa == aa2)
}

//给int也追加方法
func (i myInt) printMe() {
	fmt.Printf("i is %d", i)
}

func main() {
	var p person
	p.name = "yangjie"
	p.age = 23

	var p2 *person2 = &person2{ // *和&，如果后面有&，前面必须有*
		person: &person{
			name: "duan",
			age:  40,
		},
		sex: "男",
	}
	fmt.Println("p:", p)
	fmt.Println("p2:", p2.name)

	var p1 *person = &person{name: "chengfei", age: 12} //指针形式
	(*p1).name = "hello"
	p1.age = 40 //隐式写法
	fmt.Printf("p1指向的对象的地址:%v,p1指针的地址:%v,p1指向的对象%v", p1, &p1, *p1)

	var p3 person = person{
		name: "大号",
		age:  40,
	}
	fmt.Println(p3)
}

8.指针
type name struct {name:“”, age:40}

package main

import "fmt"

type person struct {
	name string
	age  int
}

type point struct {
	x int
	y int
}

type rect struct {
	p1, p2 *point
}

var aa int = 1000

//自定义数据类型
type myInt int

var I100 myInt = 1000

// 类型别名
type myInt2 = int

var aa2 myInt2 = 1000

func init() {
	fmt.Println("aaa:", aa == int(I100))
	fmt.Println("bbb:", aa == aa2)
}

//给int也追加方法
func (i myInt) printMe() {
	fmt.Printf("i is %d", i)
}

func main() {
	var p person
	p.name = "yangjie"
	p.age = 23
	fmt.Println(p)

	var p1 *person = &person{name: "chengfei", age: 12} //指针形式
	(*p1).name = "hello"
	p1.age = 40 //隐式写法
	fmt.Printf("p1指向的对象的地址:%v,p1指针的地址:%v,p1指向的对象%v", p1, &p1, *p1)

	var p3 person = person{
		name: "大号",
		age:  40,
	}
	fmt.Println(p3)
}

package main

import "fmt"

func main() {
	var a = 1
	fmt.Println(&a)

	var b *int = &a // var name *type

	fmt.Println(b, *b) // b指向地址0xc000014098，*b指向值1

	*b = 20
	fmt.Println(a, *b) // 20 20
}