go学习-指针 标识符

指针，以及标识符

1.指针

（1）.基本介绍

1）基本数据类型，变量存的值，也叫值类型

2）获取变量的地址用&，比如 var num int ,获取num的地址：&num

3)指针类型，变量存的是一个地址，这个地址指向的空间存的才是真正值，比如： var ptr *int =&num

4)获取指针类型所指的值，使用*,比如：var *ptr int,使用 *ptr获取p指向的值

5）举例说明

package main

import(
	"fmt"
)
//演示golang中的指针类型
func main(){


	//基本数据在内存的布局
	var i int = 10 
	// i的地址是多少 &i
	fmt.Println("i的地址=",&i)  //结果为：i的地址= 0xc04205e058
	//1.a是一个指针变量
	//2. a的类型是 *int
	//3.a 本身就是 &i
	var a *int =&i
	fmt.Println("i的值是",i) //10
	fmt.Println("a存放的值是",a)//0xc04205e058
	fmt.Println("a指向的值是",*a)//10
    fmt.Println("指针本身的地址是",&a)//0xc04207c020
    或者可以使用printf()进行格式化输出

}

内存布局图：

关于指针的内存布局操作

练习，通过指针修改所存变量地址中存放的值

package main

import(
	"fmt"
)

func main(){
var a int =999
fmt.Println("a的地址是",&a)
fmt.Println("指针修改之前a的值是",a)
var prt *int = &a
fmt.Println("prt的值是",*prt)
*prt = 23  //通过指针去修改a变量的值
fmt.Println("prt的值是",*prt)
fmt.Println("通过指针修改后这个a的值是",a)

}

判断对错

func main(){
var a int = 300
var ptr *int =a //错误应该是 &a
}

func main(){
var a int = 300
var prt *float32 = &a //错误，类型不一致，不应该是float
}


func main(){
var a int =300
var b int =400

var ptr *int =&a
*ptr = 100 //a=100
ptr = &b  //存放b的地址
*ptr = 200  //b=200
fmt.Printf("a=%d, b=%d,*ptr=%d",a,b,*ptr)


}

（2）指针的细节说明

1)值类型，都有对应的指针类型，形式为：“数据类型”，比如int 的对应的指针就是 * int,而float32对应的指针类型就是 *float32 ,以此类推

2)值类型：基本数据类型int系列，float系列，bool string \数组和结构体struct

2.值类型和引用类型

（1）说明：

1)值类型:基本数据类型int系列，float系列，bootl,string、数组和结构体struct

2)引用类型：指针，slice切片、map、管道chan,interface等都是引用类型

（2）值类型和引用类型的区别

1）值类型：变量直接存储，内存通常在栈中分配

2）引用类型：变量存储的是一个地址，这个地址对应的空间才真正存储数据（值），内存通常在堆中分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾由GC来回收

3.标识符的命名规范

（1）.标识符概念

1）golang对各种变量、方法等命名时使用的字符序列称为标识符

2）凡是自己可以起名字的地方都叫标识符

（2）.标识符的命名规则(6点)

1）由26个英文字母大小写，0~9，下划线—组成

2）数字不可以开头

3）Golang中严格区分大小写

4）标识符不能包含空格

5）下划线"—"本身在go中是一个特殊字符，称为空标识符，可以代表任何其他的标识符，但是它对应的值会忽略（比如，忽略某个返回值），所以仅能被作为占位符使用不能作为标识符使用

6）不能以系统保留关键字作为标识符，比如break、if等等…

package main

import "fmt"

//演示golang中标识符的使用
func main() {
	//严格区分大小写
   var num int = 10
   var Num int = 20
   fmt.Printf("num=%v,Num=%v",num,Num) //10 20
   //标识符中不能含有空格
//    var ab c int = 30  //会报错

//_是空标识符，用于占用
// var _ int =40  // erro

} 

（3）go中的保留字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cm24KPYQ-1693040914579)(D:\myfile\后端\go语言学习\pic\关键字.jpg)]

标识符的案例

hello  //OK
hello12 //OK
1hello //erro 不能以数字开头
h-b  //erro 不能使用-
x h   //erro 不能有空格
h_4   //ok
_ab   //ok
int    //ok 不推荐，甚至不要去用,语法通过不推荐使用
var int int =10
fmt.Println("int的值",int)//10success
float32  //ok
_  //erro
Abc  //ok

（4）标识符命名注意事项

1）包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义不要和标准库冲突

2）变量名、函数名、常量名，采用驼峰法

var stuName string ="Tom"
var goodPrice int32 =124//第一个单词字母小写往后的单词采用大写的形式

3）如果使用变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用（可以简单理解成，首字母大写是公有的，首字母小写是私有的）

预定标识符

保留关键字的介绍：

（5）运算符：

运算符是一种特殊的符号，用以表示数据的运算，赋值和比较等

1）算术运算符

主要是对数值型的变量进行运算，比如加减乘除，在Go程序中使用最多

package main

import(
	"fmt"
)

func main() {
//重点讲解 /,%
//如果参与运算的数都是整数，那么除后，去掉小数部分，保留整数部分。不会四舍五入
fmt.Println(10/4) //是2不是2.5
var n1 float32 = 10 /4  //?结果也是2
fmt.Println(n1)

//如果我们需要保留小数部分，则需要有浮点数参与运算
var n2 float32 = 10.0 /4
fmt.Println(n2) //2.5
}
//演示%的用法
//演示 % 的使用
//看一个公式 a%b=a - (a/b) *b
fmt.Println("10%3=",10 % 3) //结果余数是1
fmt.Println("-10%3=",-10 % 3) //结果余数是-1 : -10 - [(-10)/3]*3 =-10 -(-9)=-1
fmt.Println("10%-3=",10 % -3) //结果余数是 1
fmt.Println("-10%-3=",-10 % -3) //结果余数是 -1
//演示 ++ --
var i int = 10
i++  //等价 i = i+1
fmt. Println("i的值是",i)  //11
i-- //等价i = i -1
fmt. Println("i的值是",i)  //10

（6）细节说明：

1）对于除号 ”/“，他的整数和小数除是有区别的，整数之间做除法时，只保留整数部分而舍弃小数部分，例如 x := 19/5 结果是3

2）当对一个数取模式时，可以等价 a%b =a- a/b *b,这样我们就可以看到取模的本质运算

3）Golang的自增自减只能作为一个独立语言时，不能这样使用 b :=a++或者b :=a–

4）Golang的++和–只能写在变量的后面，不能写在变量的前面，既：a++ a–没有++a 或者–a

5）Golang的设计者去掉c/java中的自增自减的容易混淆的写法让Golang的语法更加简洁统一

练习：

（1）假如还有97天放假 问 xx个星期零xx天

（2）定义一个变量保存华氏温度，华氏温度转换为摄氏温度的公式是：5/9*(华氏温度-100)求出华氏温度对应的摄氏温度

package main

import (
	"fmt"
)

func main(){
	//题1
 var day int  =97
 var week int = day/7
 var mo int = day%7
fmt.Printf("还有%d天放假,是%d个星期%d天",day,week,mo)
 
var huashi float32 = 134.2
var sheshi float32 = 5.0 / 9 * (huashi - 100)
fmt.Printf("%v对应的摄氏温度=%v",huashi,sheshi) 19 
}

2）赋值运算符

介绍

赋值运算符就是将某个运算后的值，赋给指定的变量

赋值运算符的分类：

案例演示

（1）赋值基本案例

（2）有两个变量，a和b ，要求将其交换，最终打印结果

（3）+=的使用案例

package main
	
	import (
		"fmt"
	)

	func main() {
		//赋值运算符的使用演示
		// var i int 
		// i = 10   //基本赋值

		//有两个变量，a和b要求将其进行交换，最终打印结果
		//a =9 b=2 ==>a =2 b =9
		a := 9
		b := 2
        //定义一个临时变量
		t :=a
		a =b
		b =t
    fmt.Printf("交换后的情况如下 a=%v,b=%v",a,b)
 
	//复和赋值的操作
	a +=7  //等价 a = a+7
	fmt.Println("a+=7的值为",a)


	}

赋值运算符的特点

（1）运算顺序从右往左

（2）赋值运算符的左边只能是变量 ，右边 可以是变量、表达式、常量值

（3）复合运算符等价于下面的效果

a+=3 a=a+3

3）比较运算符/关系运算符

(1)关系运算符的结果都是bool型，也就是要么为true,要么为false

(2)关系表达式经常用字在if结构中或者循环条件中

关系运算符一览表

细节说明

• 关系运算符的结果都是bool型，也就是要么为true,要么为false
• 关系运算符组成的表达式，我们称为关系表达式 a>b
• 比较运算符”==“不能写成 “=”

面试题

package main

import(
	"fmt"
)
func main(){
	//有两个变量a和b，要求将其进行交换，但是不允许使用中间变量，最终打印效果
	var a int = 10
	var b int = 20
	a = a + b  //30 
	b = a - b  // 10
	a = a -b  //30-10 =20

	fmt.Printf("a=%v和b=%v",a,b) //20 和 10
}

4）逻辑运算符

介绍

用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个bool值

逻辑运算一览表：

案例演示

package main
import (
	"fmt"
)

func main() {
  //演示如何使用逻辑运算符
  var age int =40
  if  age > 30 && age < 50{
	fmt.Println("ok1")
  }

  if  age > 30 && age < 40{
	fmt.Println("ok2")
  }

  //演示逻辑或的使用  ||
  if  age > 30 || age < 50{
	fmt.Println("ok3")
  }

  if  age > 30 || age < 40{
	fmt.Println("ok4")
  }
 //演示逻辑非的使用 !
 if  !(age > 30) {
	fmt.Println("ok5") //不输出
  }
}

注意事项和使用细节

• &&也叫短路与，如果第一个条件为false，则第二个条件不会判断，最终结果为false
• ||也叫短路或，如果第一个条件为true，则第二个条件不会判断，最终结果为true

案例演示：

//声明一个测试函数(测试)
func test() bool {
	fmt.Println("test....")
return true
}

func main() {
	var i  int = 10
	//短路与的
	//说明：i<9 这个为false 第二条件根本不会去判断不会调用test函数
   if i < 9 && test(){
	fmt.Println("ok")
   }
   //短路或
   //说明：i>9 这个为true 第二条件根本不会去判断不会调用test函数
   if i > 9 || test(){
	fmt.Println("ok")
   }

    

运算符的优先级

（1）运算符有着不同的优先级，所谓优先级就是表达式运算中的运算顺序，如下表，上一行运算符总优先于下一行

（2）只有单目运算符、赋值运算符是从右往左运算的

（3）大致的顺序整理

1. 括号，++.–
2. 单目运算
3. 算术运算符
4. 移位运算
5. 关系运算
6. 位运算
7. 逻辑运算符
8. 赋值运算符
9. 逗号

6）其他运算符

位运算符

课堂练习

（1）两个数的最大值

（2）求三个数的最大值

func main() {
	//求两个数的最大值
	var n1 int =10
	var n2 int =40
	var max int
	if n1 > n2{
		max =n1
	}else{
		max =n2
	}
	fmt.Println("两个数的最大值为：",max)

	//求出三个数的最大值
	//先求出两个数的最大值然后让第三个数取比较

	var n3 int =45
    if n3 > max {
		max =n3
	}
	fmt.Println("三个数中的最大值是=",max)
}

键盘输入语句

介绍

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取’

步骤：

1）导入fmt包

2）调用fmt包的fmt.Scanln()或者fmt.Scanf()

案例演示：

要求：可以从控制台上接受用户信息。[姓名，年龄，薪水,是否通过考试]

1）使用fmt.Scanln()获取

fmt.Println("请输入姓名")
   //当程序执行到fmt.Scanln(name)是，程序会停止运行，并等待用户的输入
   fmt.Scanln(&name)

   fmt.Println("请输入年龄")
   fmt.Scanln(&age)

   fmt.Println("请输入薪水")
   fmt.Scanln(&sal)

   fmt.Println("是否通过考试")
   fmt.Scanln(&isPass)

fmt.Printf("名字是%v \n 年龄是%v \n 薪水是 %v \n 是否通过考试 %v ",name,age,sal,isPass)

2）使用fmt.Scanf()获取

/方式2.一次性输入这些信息 fmt.Scanf()可以按指定的格式输入信息
fmt.Println("姓名，年龄，薪水，是否通过考试,输入时采用空格隔开")
fmt.Scanf("%s %d %f %t ",&name,&age,&sal,&isPass)
fmt.Printf("名字是%v \n 年龄是%v \n 薪水是 %v \n 是否通过考试 %v ",name,age,sal,isPass)

4.go语言机制转换

1）进制介绍

• 二进制 : 0,1 满2进1在golang中不能直接使用二进制表示一个整数，因为他沿袭了C语言的风格要输出就%b

• 十进制:0~9满10进1

• 八进制:0~7满8进1，以数字0开头表示

• 十六进制：0~9A-F满16进1以0x或0x开头表示

  此处A~F不区分大小写

  如：0x21AF+1=02x21B0

2)案例使用

func main(){
	var i int =5;

	fmt.Printf("%d的二进制是%b\n",i,i) //输出的结果是：5的二进制是101
    //八进制：0~7，满8进1，以数字0开头进行表示
    var j int = 011
	fmt.Println("j=",j) //9
   //0~9及A-F以0x或0X表示
    var k int = 0x11
	fmt.Println("k=",k) //17

}

进制转换的介绍

第一组（其他进制转换为十进制）

1）二进制转十进制

规则：从最低位开始（右边的），将每个位上的数提取出来，乘以2的（位数-1）次方然后求和

案例：请将二进制：1011转成十进制的数
1011=1*1+1*2+0*2*2+1*2*2*2=1+2+0+8=11

2）八进制转十进制

规则：从最低位开始（右边的），将每个位上的数提取出来，乘以8的（位数-1）次方然后求和

请将0123转成十进制的数
3+2*8+1*8*8=83

3）十六进制转十进制

规则：从最低位开始（右边的），将每个位上的数提取出来，乘以8的（位数-1）次方然后求和

请将0x34A转成十进制的数
10+4*16+3*16*16=842

第二组（十进制转其他进制）

1）十进制转二进制

规则：将该数不断除于2，直到商为0为止，然后将得到的余数倒过来就是对应的二进制

案例；请将56转成2进制

2）十进制转八进制

规则：将该数不断除于8，直到商为0为止，然后将得到的余数倒过来就是对应的二进制

3）十进制转十六进制

规则：将该数不断除于16，直到商为0为止，然后将得到的余数倒过来就是对应的二进制

第三组

1）二进制转八进制

规则：将二进制数每三位一组（从低位开始组合），转成对应的八进制数即可

案例将二进制 11010101转成八进制

11010101=0325

2）二进制转十六进制

规则：将二进制每四位数一组（从低位开始组合），转换对应的十六进制数即可

案例：请将二进制：11010101转成16进制数为：0XD5

11100101 转化为八进制：0345

1110010110转化为十六进制：0x396

第四组

1）将八进制数每1位转成对应的一个3位的二进制数即可

案例：请将0237转成二进制

0237=10011111

2)将十六进制每1位转成1个4位的二进制数

0x3D=0x111101

原码 补码反码

golang有三个位运算

2的补码：00000010

3的补码 00000011

2&3=00000010 =2

2|3=00000011=3

2^3=00000001

-2^2=-4

-2的原码为：10000010

-2的反码为：11111101

-2的补码：11111110

2的补码 00000010

故-2^2=11111100 的原码是先求出他的反码然后进行取反操作

反码=补码-1：11111011==》原码（符号位不变其他取反）：10000100=-4

-1：10000001=》反码=》11111110补码：11111111 +00000001=全是0文章来源地址https://www.toymoban.com/news/detail-674377.html

func main(){
	
	//位运算的知识演示
	fmt.Println(2&3) //2
	fmt.Println(2|3)//3
	fmt.Println(2^3)//1
	//下面是带有负数的二进制
	fmt.Println(-2^2)//-4

}

golang有两个移位运算符

>> 右移、 <<左移
右移运算符 >>:低位溢出，符号位不，并用符号位补溢出的高位
左移运算符<< 符号位不变，低位补0

案例演示：

都要将原来的数变成补码进行运算
a:=1>>2//00000001=>00000000=0 右移即补码左边补0
c:=1<<2 //00000001=>00000100=4左移即补码右边补0
fmt.Println(1>>2)//0
fmt.Println(1<<2)//4

…(img-EvonRpVt-1693040914591)]

2的补码：00000010

3的补码 00000011

2&3=00000010 =2

2|3=00000011=3

2^3=00000001

-2^2=-4

-2的原码为：10000010

-2的反码为：11111101

-2的补码：11111110

2的补码 00000010

故-2^2=11111100 的原码是先求出他的反码然后进行取反操作

反码=补码-1：11111011==》原码（符号位不变其他取反）：10000100=-4

-1：10000001=》反码=》11111110补码：11111111 +00000001=全是0

func main(){
	
	//位运算的知识演示
	fmt.Println(2&3) //2
	fmt.Println(2|3)//3
	fmt.Println(2^3)//1
	//下面是带有负数的二进制
	fmt.Println(-2^2)//-4

}

到了这里，关于go学习-指针 标识符的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！