五、数据类型

5.复杂数据类型

1.指针

指针就是内存地址

*赋值：var ptr int = &age

func main(){
        var age int = 18
        //&符号+变量 就可以获取这个变量内存的地址
        fmt.Println(&age) //0xc0000a2058
        //定义一个指针变量：
        //var代表要声明一个变量
        //ptr 指针变量的名字
        //ptr对应的类型是：*int 是一个指针类型 （可以理解为 指向int类型的指针）
        //&age就是一个地址，是ptr变量的具体的值
        var ptr *int = &age
        fmt.Println(ptr)
        fmt.Println("ptr本身这个存储空间的地址为：",&ptr)
        //想获取ptr这个指针或者这个地址指向的那个数据：
        fmt.Printf("ptr指向的数值为：%v",*ptr) //ptr指向的数值为：18
}

取值：*ptr = 21

总结：最重要的就是两个符号：

1.& 取内存地址

2.* 根据地址取值

指针细节

【1】可以通过指针改变指向值

func main(){
        var num int = 10
        fmt.Println(num)
        var ptr *int = &num
    	// 改变值为20
        *ptr = 20
        fmt.Println(num)
}

【2】指针变量接收的一定是地址值

【3】指针变量的地址不可以不匹配

PS:*float32意味着这个指针指向的是float32类型的数据，但是&num对应的是int类型的不可以。

【4】基本数据类型（又叫值类型），都有对应的指针类型,形式为数据类型，
比如int的对应的指针就是int, float32对应的指针类型就是*float32。依次类推。

6.标识符的使用

标识符定义规则：

四个注意：不可以以数字开头，严格区分大小写，不能包含空格，不可以使用Go中的保留关键字

起名规则：
（1）包名：尽量保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，和标准库不要冲突
1.为什么之前在定义源文件的时候，一般我们都用package main 包 ？
main包是一个程序的入口包，所以你main函数它所在的包建议定义为main包，如果不定义为main包，那么就不能得到可执行文件。

（2）变量名、函数名、常量名 : 采用驼峰法。

（3）如果变量名、函数名、常量名首字母大写，则可以被其他的包访问;

注意：
import导入语句通常放在文件开头包声明语句的下面。
导入的包名需要使用双引号包裹起来。
包名是从$GOPATH/src/后开始计算的，使用/进行路径分隔。

需要配置一个环境变量：GOPATH

并且需要：go env -w GO111MODULE=off

外部包使用

六、运算符

1.算数运算符

算术运算符：+ ，-，*，/，%，++，--

package main
import "fmt"
func main(){
        //+加号：
        //1.正数 2.相加操作  3.字符串拼接
        var n1 int = +10
        fmt.Println(n1)
        var n2 int = 4 + 7
        fmt.Println(n2)
        var s1 string = "abc" + "def"
        fmt.Println(s1)
        // /除号：
        fmt.Println(10/3) //两个int类型数据运算，结果一定为整数类型
        fmt.Println(10.0/3)//浮点类型参与运算，结果为浮点类型
        // % 取模  等价公式： a%b=a-a/b*b
        fmt.Println(10%3) // 10%3= 10-10/3*3 = 1
        fmt.Println(-10%3)
        fmt.Println(10%-3)
        fmt.Println(-10%-3)
        //++自增操作：
        var a int = 10
        a++
        fmt.Println(a)
        a--
        fmt.Println(a)
        //++ 自增 加1操作，--自减，减1操作
        //go语言里，++，--操作非常简单，只能单独使用，不能参与到运算中去
        //go语言里，++，--只能在变量的后面，不能写在变量的前面 --a  ++a  错误写法
}

2.赋值运算符

package main
import "fmt"
func main(){
        var num1 int = 10
        fmt.Println(num1)
        var num2 int = (10 + 20) % 3 + 3 - 7   //=右侧的值运算清楚后，再赋值给=的左侧
        fmt.Println(num2)
        var num3 int = 10
        num3 += 20 //等价num3 = num3 + 20;
        fmt.Println(num3)
}

3.关系运算符

关系运算符:==,!=,>,<,> =，<=

关系运算符的结果都是bool型，也就是要么是true，要么是false

package main
import "fmt"
func main(){
        fmt.Println(5==9)//判断左右两侧的值是否相等，相等返回true，不相等返回的是false， ==不是=
        fmt.Println(5!=9)//判断不等于
        fmt.Println(5>9)
        fmt.Println(5<9)
        fmt.Println(5>=9)
        fmt.Println(5<=9)
}

4.逻辑运算符

逻辑运算符:&&(逻辑与/短路与)，||（逻辑或/短路或），!（逻辑非）

package main
import "fmt"
func main(){
        //与逻辑：&& :两个数值/表达式只要有一侧是false，结果一定为false
        //也叫短路与：只要第一个数值/表达式的结果是false，那么后面的表达式等就不用运算了，直接结果就是false  -->提高运算效率
        fmt.Println(true&&true)
        fmt.Println(true&&false)
        fmt.Println(false&&true)
        fmt.Println(false&&false)
        //或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true
        //也叫短路或：只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了，直接结果就是true -->提高运算效率
        fmt.Println(true||true)
        fmt.Println(true||false)
        fmt.Println(false||true)
        fmt.Println(false||false)
        //非逻辑：取相反的结果：
        fmt.Println(!true)
        fmt.Println(!false)
}

5.优先级

为了提高优先级，可以加（）

6.获取用户终端输入

要传入地址变量，因为scan内部是值改变，只有传入地址变量，才能影响到地址变量的值

package main
import "fmt&q