Go语言数据类型详细介绍

目录
  • 一、Go 语言两大数据类型
  • 二、基础类型
  • 三、复合类型
    • 指针
  • 四、数组(array)
  • 五、切片(slice)
  • 六、字典/映射(map)
  • 七、通道(channel)
  • 八、结构体(struct)
  • 九、接口(interface)
  • 十、错误(error)

一、Go 语言两大数据类型

Go 语言数据类型包含基础类型和复合类型两大类。

基础类型包括:

  • 布尔类型 bool。
  • 数值类型 int,int8,int16,int32,int64,float32,float64。
  • uint8,uint16,uint32,uint64。
  • 字符串 string,byte,rune。

复合类型包括:

  • 指针、数组、切片、字典、通道、结构体、接口。

下面用代码加注释的方式说明:

二、基础类型

声明一个bool类型的变量,只有true和false两个值,初始值为false

var isLogin bool
    
// 声明一个int类型的变量,初始值为0
//(int8,int16,int32 uint8,uint16....类似,只是有符号和无符号的区别)
// 最常用的就是int,如果需要更大的范围可以用int64或者uint64
var count int
        
// 声明一个string类型的变量,初始值为""
var s string
        
//声明一个byte类型的变量
var b byte
    
//声明一个rune类型的变量
//int32的别名,表示单个Unicode字符
var r rune

三、复合类型

指针

go的指针和c语言的指针类型,都是表示一个变量的地址,不同的是,go的指针要比c的指针简单的多,老规矩,代码注释,如下:

package main

import "fmt"

func main() {
    
    var count = 100 //定义变量count
    
    var ptr *int     //定义一个指针ptr,此指针可以保存int类型变量的地址
    ptr = &count    //ptr保存的是变量count的地址, & 符号是取变量地址的符号
    
    fmt.Println("count=",count) //打印count的值
    fmt.Println("ptr=", *ptr)    //打印ptr指向的变量的值,此句打印100
}

运行结果如下:

count= 100
ptr= 100

四、数组(array)

数组为一组相同数据类型数据的集合,大小固定,不能更改,每个元素称为element,声明的数组元素默认值都是对应类型的0值。而且数组在Go语言中是一个值类型(value type)所有值类型变量在赋值和作为参数传递时都会产生一次复制动作,即对原值的拷贝

package main

import "fmt"

func main() {
    
    // 1.声明后赋值  (var <数组名称> [<数组长度>]<数组元素>)
    var arr [2]int   // 数组元素的默认值都是 0
    fmt.Println(arr) // 输出:[0 0]
    arr[0] = 1
    arr[1] = 2
    fmt.Println(arr) // 输出:[1 2]
    
    // 2.声明并赋值 (var <数组名称> = [<数组长度>]<数组元素>{元素1,元素2,...})
    var intArr = [2]int{1, 2}
    strArr := [3]string{`aa`, `bb`, `cc`}
    fmt.Println(intArr) // 输出:[1 2]
    fmt.Println(strArr) // 输出:[aa bb cc]
    
    // 3.声明时不设定大小,赋值后语言本身会计算数组大小
    // var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{元素1,元素2,...}
    var arr1 = [...]int{1, 2}
    arr2 := [...]int{1, 2, 3}
    fmt.Println(arr1) // 输出:[1 2]
    fmt.Println(arr2) // 输出:[1 2 3]
    //arr1[2] = 3 // 编译报错,数组大小已设定为2
    
    // 4.声明时不设定大小,赋值时指定索引
    // var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{索引1:元素1,索引2:元素2,...}
    var arr3 = [...]int{1: 22, 0: 11, 2: 33}
    arr4 := [...]string{2: "cc", 1: "bb", 0: "aa"}
    fmt.Println(arr3) // 输出:[11 22 33]
    fmt.Println(arr4) // 输出:[aa bb cc]
    
    // 遍历数组
    for i := 0; i < len(arr4); i++ {
        v := arr4[i]
        fmt.Printf("i:%d, value:%s\n", i, v)
    }
}

五、切片(slice)

因为数组的长度定义后不可修改,所以需要切片来处理可变长数组数据。切片可以看作是一个可变长的数组,是一个引用类型。

它包含三个数据:

  • 指向原生数组的指针
  • 切片中的元素个数
  • 切片已分配的存储空间大小

注:了解c++和java的同学,可以参考vector和List,切片就是类似这两个数据结构,直接上代码:

package main

import "fmt"

func main() {
    var sl []int             // 声明一个切片
    sl = append(sl, 1, 2, 3) // 往切片中追加值
    fmt.Println(sl)          // 输出:[1 2 3]

    var arr = [5]int{1, 2, 3, 4, 5} // 初始化一个数组
    var sl1 = arr[0:2]              // 冒号:左边为起始位(包含起始位数据),右边为结束位(不包含结束位数据);不填则默认为头或尾
    var sl2 = arr[3:]
    var sl3 = arr[:5]

    fmt.Println(sl1) // 输出:[1 2]
    fmt.Println(sl2) // 输出:[4 5]
    fmt.Println(sl3) // 输出:[1 2 3 4 5]

    sl1 = append(sl1, 11, 22) // 追加元素
    fmt.Println(sl1)          // 输出:[1 2 11 22]
}

使用make关键字直接创建切片,

语法:make([]类型, 大小,预留空间大小),make() 函数用于声明slice切片、map字典、channel通道。

如下:

package main

import "fmt"

func main() {
    var s1 = make([]int, 5)          // 定义元素个数为5的切片
    s2 := make([]int, 5, 10)         // 定义元素个数5的切片,并预留10个元素的存储空间(预留空间不知道有什么用?)
    s3 := []string{`aa`, `bb`, `cc`} // 直接创建并初始化包含3个元素的数组切片
    
    fmt.Println(s1, len(s1)) // 输出:[0 0 0 0 0] 5
    fmt.Println(s2, len(s2)) // 输出:[0 0 0 0 0] 5
    fmt.Println(s3, len(s3)) // [aa bb cc] 3
    
    s1[1] = 1 // 声明或初始化大小中的数据,可以指定赋值
    s1[4] = 4
    //s1[5] = 5 // 编译报错,超出定义大小
    s1 = append(s1, 5)       // 可以追加元素
    fmt.Println(s1, len(s1)) // 输出:[0 1 0 0 4 5] 6
    
    s2[1] = 1
    s2 = append(s2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
    fmt.Println(s2, len(s2)) // 输出:[0 1 0 0 0 1 2 3 4 5 6 7 8 9 10 11] 16
    
    // 遍历切片
    for i := 0; i < len(s2); i++ {
        v := s2[i]
        fmt.Printf("i: %d, value:%d \n", i, v)
    }
}

六、字典/映射(map)

map是一种键值对的无序集合,与 slice 类似也是一个引用类型。map 本身其实是个指针,指向内存中的某个空间。

声明方式与数组类似,声明方式:var 变量名 map[key类型值类型 或直接使用 make 函数初始化:make(map[key类型]值类型, 初始空间大小)。

其中key值可以是任何可以用==判断的值类型,对应的值类型没有要求。

直接上代码,如下:

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 声明后赋值
    var m map[int]string
    fmt.Println(m) // 输出空的map:map[]
    //m[1] = `aa`    // 向未初始化的map中赋值报错:panic: assignment to entry in nil map

    // 声明并初始化,初始化使用{} 或 make 函数(创建类型并分配空间)
    var m1 = map[string]int{}
    var m2 = make(map[string]int)
    m1[`a`] = 11
    m2[`b`] = 22
    fmt.Println(m1) // 输出:map[a:11]
    fmt.Println(m2) // 输出:map[b:22]

    // 初始化多个值
    var m3 = map[string]string{"a": "aaa", "b": "bbb"}
    m3["c"] = "ccc"
    fmt.Println(m3) // 输出:map[a:aaa b:bbb c:ccc]

    // 删除 map 中的值
    delete(m3, "a") // 删除键 a 对应的值
    fmt.Println(m3) // 输出:map[b:bbb c:ccc]

    // 查找 map 中的元素
    v, ok := m3["b"]
    if ok {
        fmt.Println(ok)
        fmt.Println("m3中b的值为:", v) // 输出:m3中b的值为: bbb
    }
    // 或者
    if v, ok := m3["b"]; ok { // 流程处理后面讲
        fmt.Println("m3中b的值为:", v) // 输出:m3中b的值为: bbb
    }

    fmt.Println(m3["c"]) // 直接取值,输出:ccc

    // map 中的值可以是任意类型
    m4 := make(map[string][5]int)
    m4["a"] = [5]int{1, 2, 3, 4, 5}
    m4["b"] = [5]int{11, 22, 33}
    fmt.Println(m4)                // 输出:map[a:[1 2 3 4 5] b:[11 22 33 0 0]]
    fmt.Println(unsafe.Sizeof(m4)) // 输出:8,为8个字节,map其实是个指针,指向某个内存空间
}

七、通道(channel)

说到通道 channel,则必须先了解下 Go 语言的 goroutine 协程(轻量级线程)。channel就是为 goroutine 间通信提供通道。goroutine是 Go 语言提供的语言级的协程,是对 CPU 线程和调度器的一套封装。

channel 也是类型相关的,一个 channel 只能传递一种类型的值。

声明:var 通道名 chan 通道传递值类型 或 make 函数初始化:make(chan 值类型, 初始存储空间大小)

说白了,通道类似消息队列,主要应用在并发编程里面比较多,

直接上代码,如下:

package main

import (
    "fmt"
    "time"
)

func main() {
    var ch1 chan int            // 声明一个通道
    ch1 = make(chan int)        // 未初始化的通道不能存储数据,初始化一个通道
    ch2 := make(chan string, 2) // 声明并初始化一个带缓冲空间的通道

    // 通过匿名函数向通道中写入数据,通过 <- 方式写入
    go func() { ch1 <- 1 }()
    go func() { ch2 <- `a` }()

    v1 := <-ch1 // 从通道中读取数据
    v2 := <-ch2
    fmt.Println(v1) // 输出:1
    fmt.Println(v2) // 输出:a

    // 写入,读取通道数据
    ch3 := make(chan int, 1) // 初始化一个带缓冲空间的通道
    go readFromChannel(ch3)
    go writeToChannel(ch3)

    // 主线程休眠1秒,让出执行权限给子 Go 程,即通过 go 开启的 goroutine,不然主程序会直接结束
    time.Sleep(1 * time.Second)
}

func writeToChannel(ch chan int) {
    for i := 1; i < 10; i++ {
        fmt.Println("写入:", i)
        ch <- i
    }
}

func readFromChannel(ch chan int) {
    for i := 1; i < 10; i++ {
        v := <-ch
        fmt.Println("读取:", v)
    }
}

运行结果如下:

// ------  输出:--------
1
a
写入: 1
写入: 2
写入: 3
读取: 1
读取: 2
读取: 3
写入: 4
写入: 5
写入: 6
读取: 4
读取: 5
读取: 6
写入: 7
写入: 8
写入: 9
读取: 7
读取: 8
读取: 9

goroutine channel 的详细用法会有相应的博客专门来讲这一章节,具体可在我的个人主页里面,找一下相关的博客参考。

八、结构体(struct)

结构体是一种聚合的数据类型,是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员,和java中的class是一个意思:

package main

import "fmt"

// 定义一个结构体 person
type person struct {
    name string
    age  int
}

func main() {
    var p person   // 声明一个 person 类型变量 p
    p.name = "max" // 赋值
    p.age = 12
    fmt.Println(p) // 输出:{max 12}

    p1 := person{name: "mike", age: 10} // 直接初始化一个 person
    fmt.Println(p1.name)                // 输出:mike

    p2 := new(person) // new函数分配一个指针,指向 person 类型数据
    p2.name = `张三`
    p2.age = 15
    fmt.Println(*p2) // 输出:{张三 15}
}

九、接口(interface)

接口用来定义行为。Go 语言不同于面向对象语言,没有类的概念,也没有传统意义上的继承。Go 语言中的接口,用来定义一个或一组行为,某些对象实现了接口定义的行为,则称这些对象实现了(implement)该接口,类型即为该接口类型。

定义接口也是使用 type 关键字,格式为:

// 定义一个接口
type InterfaceName interface {
    FuncName1(paramList) returnType
    FuncName2(paramList) returnType
    ...
}

实列:

package main

import (
    "fmt"
    "strconv"
)

// 定义一个 Person 接口
type Person interface {
    Say(s string) string
    Walk(s string) string
}

// 定义一个 Man 结构体
type Man struct {
    Name string
    Age  int
}

// Man 实现 Say 方法
func (m Man) Say(s string) string {
    return s + ", my name is " + m.Name
}

// Man 实现 Walk 方法,strconv.Itoa() 数字转字符串
func (m Man) Walk(s string) string {
    return "Age: " + strconv.Itoa(m.Age) + " and " + s
}

func main() {
    var m Man       // 声明一个类型为 Man 的变量
    m.Name = "Mike" // 赋值
    m.Age = 30
    fmt.Println(m.Say("hello"))    // 输出:hello, my name is Mike
    fmt.Println(m.Walk("go work")) // 输出:Age: 30 and go work

    jack := Man{Name: "jack", Age: 25} // 初始化一个 Man 类型数据
    fmt.Println(jack.Age)
    fmt.Println(jack.Say("hi")) // 输出:hi, my name is jack
}

十、错误(error)

error 类型本身是 Go 语言内部定义好的一个接口,接口里定义了一个 Error() 打印错误信息的方法,源码如下:

type error interface {
    Error() string
}

自定义错误信息:

package main

import (
    "errors"
    "fmt"
)

func main() {
    // 使用 errors 定制错误信息
    var e error
    e = errors.New("This is a test error")
    fmt.Println(e.Error()) // 输出:This is a test error

    // 使用 fmt.Errorf() 定制错误信息
    err := fmt.Errorf("This is another error")
    fmt.Println(err) // 输出:This is another test error
}

到此这篇关于Go语言数据类型详细介绍的文章就介绍到这了,更多相关Go数据类型内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Go语言七篇入门教程二程序结构与数据类型

    目录 1. 程序结构 1.1 名称 1.2 声明 1.3 注释 1.4 单双引号 1.5 输出 2. 数据类型 2.1 整型 2.2 浮点型 2.3 复数 2.4 布尔型 2.5 字符串 2.6 常量 2.7 数组 2.8 切片 2.9 map 2.10 结构体 2.11 JSON 3. 流程控制 3.1 条件语句 3.2 选择语句 3.3 循环语句 如何学习Go 1. 程序结构 1.1 名称 如果一个实体名称在函数中声明,它只在函数局部有效.如果声明在函数外,它将对包里面的所有源文件可见. 实

  • Pandas数据类型之category的用法

    创建category 使用Series创建 在创建Series的同时添加dtype="category"就可以创建好category了.category分为两部分,一部分是order,一部分是字面量: In [1]: s = pd.Series(["a", "b", "c", "a"], dtype="category") In [2]: s Out[2]: 0 a 1 b 2 c 3

  • Go语言变量与基础数据类型详情

    目录 一.基础介绍 1.Go 的特性 2.Go 的常用命令 3.Hello Word 二.变量 1.定义方式 三.常量 四.基础数据类型 1.数字 2.浮点型(小数,32/64表示小数点后长度多少位) 3.布尔(Bool) 4.字符串 一.基础介绍 Go 是静态(编译型)语言,是区别于解释型语言的弱类型语言(静态:类型固定,强类型:不同类型不允许直接运算) 例如 python 就是动态强类型语言 1.Go 的特性 跨平台的编译型语言,交叉编译 管道(channel),切片(slice),并发(r

  • Mongodb 利用mongoshell进行数据类型转换的实现方法

    $type操作符 检测类型 种类 代号 别名 Double 1 "double" String 2 "string" Object 3 "object" Array 4 "array" Binary data 5 "binData" Undefined 6 "undefined" Deprecated. ObjectId 7 "objectId" Boolean 8

  • Go语言特点及基本数据类型使用详解

    目录 一.Golang 简介 1.Go 语言的特点 2.Golang 的变量作用域 3.Golang 执行流程的两种方式 二.Golang 的基本操作 1.在 Linux 上安装 Golang 语言开发包 2.Golang 变量的基本使用 3.Golang 中整数的类型 4.Golang 基本数据类型的默认值 5.基本数据类型转换为 String 类型 一.Golang 简介 Golang(又称为 Go)是 Google 公司开发出的一种静态强类型.编译型.并发型,并具有垃圾回收功能的编程语言.

  • MongoDB 常用的数据类型和基本操作

    NO.1 MongoDB的常用数据类型 MongoDB中的文档类似json,我们知道,在json中,最常用的数据类型有null.bool.数组.字符串.数据.json对象等等.相对比较少,比如对于时间类型的数据,json是无法表示的,而MongoDB中对json进行了简单的优化,像json,但是又不是json.下面我们慢慢说 MongoDB的常用数据类型和MySQL比较像,你可以对比着看.它的常用数据类型有: 1.null 用于表示空值或者不存在的字段 {"x":null} 2.boo

  • Golang通脉之数据类型详情

    目录 1.标识符与关键字 1.1 标识符 1.2 关键字 2.变量 2.1 什么是变量 2.2 变量类型 2.3 变量声明 3.常量 3.1 iota 4.基本数据类型 4.1 整型 4.2 浮点型 4.3 复数 4.4 布尔值 4.5 字符串 4.6 byte和rune类型 4.7 类型转换 5.运算符 5.1 算数运算符 5.2 关系运算符 5.3 逻辑运算符 5.4 位运算符 5.5 赋值运算符 5.6 运算符优先级 1.标识符与关键字 在了解数据类型之前,先了解一下go的标识符和关键字

  • 详细介绍在pandas中创建category类型数据的几种方法

    在pandas中创建category类型数据的几种方法之详细攻略 T1.直接创建 category类型数据 可知,在category类型数据中,每一个元素的值要么是预设好的类型中的某一个,要么是空值(np.nan). T2.利用分箱机制(结合max.mean.min实现二分类)动态添加 category类型数据 输出结果 [NaN, 'medium', 'medium', 'fat'] Categories (2, object): ['medium', 'fat']    name    ID

  • python mongo 向数据中的数组类型新增数据操作

    我就废话不多说了,大家还是直接看图吧~ 补充知识:pymongo插入数据时更新和不更新的使用 (1)update的setOnInsert 当该key不存在的时候执行插入操作,当存在的时候则不管,可以使用setOnInsert db.test.update({'_id': 'id'}, {'$setOnInsert': {'a': 'a'}, true) 当id存在的时候,忽略setOnInsert. (2)update的set 当key不存在的时候执行插入操作,当存在的时候更新除key以外的se

  • Go语言数据类型详细介绍

    目录 一.Go 语言两大数据类型 二.基础类型 三.复合类型 指针 四.数组(array) 五.切片(slice) 六.字典/映射(map) 七.通道(channel) 八.结构体(struct) 九.接口(interface) 十.错误(error) 一.Go 语言两大数据类型 Go 语言数据类型包含基础类型和复合类型两大类. 基础类型包括: 布尔类型 bool. 数值类型 int,int8,int16,int32,int64,float32,float64. uint8,uint16,uin

  • C语言 数据类型详细介绍

    C 数据类型 在 C 语言中,数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统.变量的类型决定了变量存储占用的空间,以及如何解释存储的位模式. C 中的类型可分为以下几种: 序号 类型与描述 1 基本类型: 它们是算术类型,包括两种类型:整数类型和浮点类型. 2 枚举类型: 它们也是算术类型,被用来定义在程序中只能赋予其一定的离散整数值的变量. 3 void 类型: 类型说明符 void 表明没有可用的值. 4 派生类型: 它们包括:指针类型.数组类型.结构类型.共用体类型和函数类型.

  • C语言数组详细介绍

    目录 什么是数组 一维数组 二维数组 数组越界 数组名 结尾 什么是数组 数组(Array)是一种用来存储同一种类型的集合,是一种有序的线性结构表.并且数组元素的地址是连续的. 数组最大的优点就是支持随机访问,当想访问数组的某个数时,只需要找到数组的对应下标就可以直接找到该数组对应元素.但是数组也有相应的缺点,那就是数组的元素个数和数组空间大小在创建时就已经被固定死了,如果数组的空间没有使用完也会造成空间浪费,并且因为数组的地址是连续的,这本应该是一个优点的,但是这导致数组在进行删除或增加元素时

  • C语言 超详细介绍与实现线性表中的带头双向循环链表

    目录 一.本章重点 二.带头双向循环链表介绍 2.1什么是带头双向循环链表? 2.2最常用的两种链表结构 三.带头双向循环链表常用接口实现  3.1结构体创建 3.2带头双向循环链表的初始化  3.3创建新节点 3.4尾插 3.5打印链表 3.6头插 3.7尾删 3.8头删 3.9查找data(返回data的节点地址) 3.10在pos位置之前插入节点 3.11删除pos位置的节点 四.实现接口总结 五.在线oj训练与详解 一.本章重点 带头双向循环链表介绍 带头双向循环链表常用接口实现 实现接

  • C语言 超详细介绍与实现线性表中的无头单向非循环链表

    目录 一.本章重点 二.链表介绍 三.无头单向非循环链表常用接口实现 3.1动态申请一个节点 3.2单链表打印 3.3单链表尾插 3.4单链表的头插 3.5单链表的尾删 3.6单链表头删 3.7单链表查找 3.8单链表在pos位置之前插入x 3.9单链表删除pos位置的节点 四.在线oj训练 4.1移除链表元素(力扣) 4.2反转单链表(力扣) 一.本章重点 无头单向非循环链表介绍 无头单向非循环链表常用接口实现 在线oj训练 二.链表介绍 概念:链表是一种物理存储结构上非连续.非顺序的存储结构

  • Lua中的基本数据类型详细介绍

    基础介绍 Lua是一种动态类型的语言.在语言中没有类型定义的语法,每个值都带有其自身的类型信息.在Lua中有8中基本类型,分别是: 1.nil(空)类型 2.boolean(布尔)类型 3.number(数字)类型 4.string(字符串)类型 5.userdata(自定义类型) 6.function(函数)类型 7.thread(线程)类型 8.table(表)类型 以上是Lua中的8中基本类型,我们可以使用type函数,判断一个值得类型,type函数返回一个对应类型的字符串描述.例如: 复

  • C语言 运算符详细介绍及示例代码

    C 运算符 运算符是一种告诉编译器执行特定的数学或逻辑操作的符号.C 语言内置了丰富的运算符,并提供了以下类型的运算符: 算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 杂项运算符 本章将逐一介绍算术运算符.关系运算符.逻辑运算符.位运算符.赋值运算符和其他运算符. 算术运算符 下表显示了 C 语言支持的所有算术运算符.假设变量 A 的值为 10,变量 B 的值为 20,则: 运算符 描述 实例 + 把两个操作数相加 A + B 将得到 30 - 从第一个操作数中减去第二个操作数 A

  • Python基本数据类型详细介绍

    1.空(None)表示该值是一个空对象,空值是Python里一个特殊的值,用None表示.None不能理解为0,因为0是有意义的,而None是一个特殊的空值.2.布尔类型(Boolean)在Python中,None.任何数值类型中的0.空字符串"".空元组().空列表[].空字典{}都被当作False,还有自定义类型,如果实现了__nonzero__()或__len__()方法且方法返回0或False,则其实例也被当作False,其他对象均为True布尔值和布尔代数的表示完全一致,一个

  • java数据类型与二进制详细介绍

    java数据类型与二进制详细介绍 在java中 Int 类型的变量占 4个字节 Long 类型的变量占8个字节 一个程序就是一个世界,变量是这个程序的基本单位. Java基本数据类型 1.        整数类型 2.        小数(浮点数)类型 3.        布尔类型 4.        字符类型 整数类型 整数类型可以表示一个整数,常用的整数类型有:byte,short,int,long Byte  一个字节  -128到127 注:0有两个表示0000 0000正零  1000

  • C语言中左移和右移运算符详细介绍

    C语言中左移和右移运算符详细介绍 左移运算符(<<) 左移运算符是用来将一个数的各二进制位左移若干位,移动的位数由右操作数指定(右操作数必须是非负值),其右边空出的位用0填补,高位左移溢出则舍弃该高位. 右移运算符(>>) 右移运算符是用来将一个数的各二进制位右移若干位,移动的位数由右操作数指定(右操作数必须是非负值),移到右端的低位被舍弃,对于无符号数,高位补0. 对于有符号数,某些机器将对左边空出的部分用符号位填补(即"算术移位"),而另一些机器则对左边空出

随机推荐