精华内容
下载资源
问答
  • Go之数组

    2020-05-04 23:21:10
    1. 数组的概念 数组是同一种数据类型元素的集合。 Go语言中,声明确定数组,使用的时候可以修改数组中的...数组长度必须是常量,一旦定义,长度不能变,数组可以通过下标访问,下标是从0开始,最后一个元素...

    1. 数组的概念

    数组是同一种数据类型元素的集合。 在Go语言中,声明的时确定数组,使用的时候可以修改数组中的成员,但其大小不可变化。

    //基本语法
    //定义一个长度为10的整型数组,数组名为array
    var array[10] int
    

    2. 数组的定义

    var 数组名[数组长度] 数组类型
    数组长度必须是常量,一旦定义,长度不能变,数组可以通过下标访问,下标是从0开始,最后一个元素的下标为 len - 1

    var arr1[10] int
    var arr2[11] int
    arr1 = arr2 //此时arr1和arr2是不同类型
    

    3. 数组的初始化

    package main
    
    import "fmt"
    
    func main(){
    //数组初始化1:
    	//数组默认初始化,默认为零
    	var array [3]int
    
    	//使用指定的初始化值进行初始化,未完成初始化的值为默认值
    	var array1 = [3]int{1, 2}
    	
    	//使用指定的初始化值进行初始化
    	var array2 = [3]int{1, 2, 3}
    
    	fmt.Println(array)  //[0 0 0]
    	fmt.Println(array1) //[1 2 0]
    	fmt.Println(array2) //[1 2 3]
    /
    //数组初始化2:
    	var array3 [3]int
    
    	//编译器自动推断数组长度
    	var array4 = [...]int{1, 2}
    	var array5 = [...]int{1, 2, 3, 4}
    
    	fmt.Println(array3) //[0 0 0]
    	fmt.Println(array4) //[1 2]
    	fmt.Println(array5) //[1 2 3 4]
    
    //数组初始化3:
    	//通过下标进行初始化
    	array6 := [...]int{1: 10, 4: 15}
    
    	fmt.Println(array6) //[0 10 0 0 15]
    	fmt.Printf("%T", array6) //[5]int
    }
    

    4. 数组的遍历

    package main
    
    import "fmt"
    
    func main(){
    	var array = [...]string{"西安", "上海", "重庆", "深圳"}
    	//通过for循环遍历
    	for i:= 0; i < len(array); i++{
    		fmt.Println(array[i])
    	}
    
    	//通过for range
    	for index, value := range array{
    		fmt.Println(index, value)
    	}
    }
    

    5. 多维数组

    二维数组也是行主序的,所以只有第一层可以省略

    package main
    
    import "fmt"
    
    func main(){
    	//二维数组的定义及初始化
    	array := [3][2]string{
    		{"陕西", "西安"}
    		{"四川", "成都"}
    		{"广东", "深圳"}
    	}
    
    	//二维数组的遍历
    	for _, i = range array{
    		for _, j = range i{
    			fmt.Printf("%s\t",j)
    		}
    		fmt.Println()
    	}
    }
    

    展开全文
  • go语言学习 Array数组

    2021-03-24 21:02:12
    比如:var a [5]int, 数组的长度必须是常量,并且长度是数组类型的一部分。一旦定义,长度不能变。 [5]int和[10]int是不同的类型。 数组可以通过下标进行访问,下标是从0开始,最后一个元素下标是:len-1,访问...

    数组是同一种数据类型元素的集合。 在Go语言中,数组从声明时就确定,使用时可以修改数组成员,但是数组大小不可变化。

    定义

    var 数组变量名 [元素数量]T

    比如:var a [5]int, 数组的长度必须是常量,并且长度是数组类型的一部分。一旦定义,长度不能变。 [5]int[10]int是不同的类型。

    数组可以通过下标进行访问,下标是从0开始,最后一个元素下标是:len-1,访问越界(下标在合法范围之外),则触发访问越界,会panic。

    初始化

    初始化数组时可以使用初始化列表来设置数组元素的值。

    func main() {
    	var testArray [3]int                        //数组会初始化为int类型的零值
    	var numArray = [3]int{1, 2}                 //使用指定的初始值完成初始化
    	var cityArray = [3]string{"北京", "上海", "深圳"} //使用指定的初始值完成初始化
    	fmt.Println(testArray)                      //[0 0 0]
    	fmt.Println(numArray)                       //[1 2 0]
    	fmt.Println(cityArray)                      //[北京 上海 深圳]
    }
    

    按照上面的方法每次都要确保提供的初始值和数组长度一致,一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度,例如:

    func main() {
    	var testArray [3]int
    	var numArray = [...]int{1, 2}
    	var cityArray = [...]string{"北京", "上海", "深圳"}
    	fmt.Println(testArray)                          //[0 0 0]
    	fmt.Println(numArray)                           //[1 2]
    	fmt.Printf("type of numArray:%T\n", numArray)   //type of numArray:[2]int
    	fmt.Println(cityArray)                          //[北京 上海 深圳]
    	fmt.Printf("type of cityArray:%T\n", cityArray) //type of cityArray:[3]string
    }
    

    我们还可以使用指定索引值的方式来初始化数组,例如:

    func main() {
    	a := [...]int{1: 1, 3: 5}
    	fmt.Println(a)                  // [0 1 0 5]
    	fmt.Printf("type of a:%T\n", a) //type of a:[4]int
    }
    

     数组的遍历

    func main() {
    	var a = [...]string{"北京", "上海", "深圳"}
    	// 方法1:for循环遍历
    	for i := 0; i < len(a); i++ {
    		fmt.Println(a[i])
    	}
    
    	// 方法2:for range遍历
    	for index, value := range a {
    		fmt.Println(index, value)
    	}
    }

     多维数组

    func main() {
    	a := [3][2]string{
    		{"北京", "上海"},
    		{"广州", "深圳"},
    		{"成都", "重庆"},
    	}
    	for _, v1 := range a {
    		for _, v2 := range v1 {
    			fmt.Printf("%s\t", v2)
    		}
    		fmt.Println()
    	}
    }
    

    多维数组只有第一层可以使用...来让编译器推导数组长度。例如:

    //支持的写法
    a := [...][2]string{
    	{"北京", "上海"},
    	{"广州", "深圳"},
    	{"成都", "重庆"},
    }
    //不支持多维数组的内层使用...
    b := [3][...]string{
    	{"北京", "上海"},
    	{"广州", "深圳"},
    	{"成都", "重庆"},
    }

    注意事项

    数组是值类型,赋值和传参会复制整个数组。因此改变副本的值,不会改变本身的值。

    1. 数组支持 “==“、”!=” 操作符,因为内存总是被初始化过的。
    2. [n]*T表示指针数组,*[n]T表示数组指针 。

     

    展开全文
  • Go语言之基本数据类型之数组 文章目录Go语言之基本数据类型之数组数组定义数组初始化数组遍历数组的比较二维数组补充知识点...数组的长度必须是常量,因为数组长度需要编译器确定,以下这种定义方式是错误的。 var b

    Go语言基本数据类型之数组

    数组定义

    数组是由固定长度的特定类型元素组成的序列,数组的长度是固定的,不允许改变。

    访问数组可以根据索引下标来访问,索引的范围 0 到 数组长度 左闭右开区间。

    数组定义时,必须声明数组的长度

    var aaa [3]int
    // var 变量名 [数组长度]元素类型
    

    数组的长度必须是常量,因为数组长度需要在编译器确定,以下这种定义方式是错误的。

    var b int = 3
    var aaa [b]int //报错 数组长度不允许是变量
    

    数组初始化

    数组初始化的几种方式如下

    1. 数组可以只声明,默认初始化的值为元素类型的初始值
    2. 定义时指定数组元素值
    3. 数组长度由数组中元素的个数推导而出
    4. 自定义数组中特定下标的元素值,没有被指定的则为元素类型的初始值
      var aaa [3]int 
      var bbb = [3]int{1, 2, 3}
      var ccc = [...]int{1, 2, 3}
      var ddd = [...]int{1: 1, 4: 4}
      fmt.Println(aaa)  //[0 0 0]
      fmt.Println(bbb) //[1 2 3]
      fmt.Println(ccc) //[1 2 3]
      fmt.Println(ddd) //[0 1 0 0 4]
    

    数组遍历

    1. 常规for循环遍历,根据下标来索引
      var eee = [3]string{"hello", "world", "golang"}
      for i := 0; i < len(eee); i++ {
        fmt.Println(eee[i])
      }
    
    1. 使用for-range 遍历 ,语法类似于for-each
    	var eee = [3]string{"hello", "world", "golang"}
    	for _, e := range eee { //_为index下标,匿名变量
    		fmt.Println(e)
    	}
    

    数组的比较

    数组的长度是数组的一部分,所以不同长度的数组是无法比较的,

    如果一个数组元素类型是可以相互比较的,那么数组类型也是可以相互比较的,这时候我们可以直接通过==比较运算符来比较两个数组。只有每个元素都相等,才返回true。

    	f := [3]int{1, 2, 3}
    	g := [4]int{1, 2, 3}
    	h := [3]int{1, 2, 3}
    	if f == g //invalid operation: f == g (mismatched types [3]int and [4]int)
    	fmt.Println(f == h)//true
    

    二维数组

    开发中经常会用到二维数组,二维数组就是数组的嵌套

    	//二维数组
    	twoArray := [3][2]string{
    		{"hello", "world"},
    		{"中国", "你好"},
    		{"平安", "快乐"},
    	}
    

    对于嵌套数组外层的数组长度是可以根据内层数组数量来推导的

    	twoArray2 := [...][2]string{
    		{"hello", "world"},
    		{"中国", "你好"},
    		{"平安", "快乐"},
    	} 
    

    但内层不允许推导

    	twoArray3 := [3][...]string{ //编译报错
    		{"hello", "world"},
    		{"中国", "你好"},
    		{"平安", "快乐"},
    	} //use of [...] array outside of array literal
    

    补充知识点

    for range遍历字符串

    “%t"打印布尔型,”%T"打印数据类型 ,"%c"打印字符

    1. 字符串是由于unicode编码字符组成的集合,那么for range之后, s是一个rune类型,所以打印出了字符,循环的索引都是当前rune的起始位置。
    	ss := "中国人"
    	for index, s := range ss {
    		fmt.Printf("下标->%d  字符->%#U  类型->%T", index, s, s)
    		fmt.Println()
    	}
    下标->0  字符->U+4E2D '中'  类型->int32
    下标->3  字符->U+56FD '国'  类型->int32
    下标->6  字符->U+4EBA '人'  类型->int32
    
    1. 索引字符串可以访问单个字节,而不是字符。
    	ss := "中国人"
    	for i := 0; i < len(ss); i++ { //ss[i]是字节值
    		fmt.Printf("下标->%d  字符->%#U  类型->%T", i, ss[i], ss[i])
    		fmt.Println()
    	}
    
    下标->0  字符->U+00E4 'ä'  类型->uint8
    下标->1  字符->U+00B8 '¸'  类型->uint8
    下标->2  字符->U+00AD  类型->uint8
    下标->3  字符->U+00E5 'å'  类型->uint8
    下标->4  字符->U+009B  类型->uint8
    下标->5  字符->U+00BD '½'  类型->uint8
    下标->6  字符->U+00E4 'ä'  类型->uint8
    下标->7  字符->U+00BA 'º'  类型->uint8
    下标->8  字符->U+00BA 'º'  类型->uint8
    
    1. 如果想要直接下标访问 需要将字符串转成rune数组。
    	//不用遍历 直接下标访问
    	ss := "中国人"
    	runes := []rune(ss)
    	fmt.Printf("%c", runes[0])
    

    注:字符串的本质是字节组成的slice!

    下一篇将会介绍slice切片

    展开全文
  • go--数组、切片和map

    2019-04-06 21:21:00
    数组 数组是同一种数据类型元素的集合。 Go语言中,数组声明时就确定,使用...数组的长度必须是常量,并且长度是数组类型的一部分。一旦定义,长度不能变。 [5]int和[10]int是不同的类型。 数组可以通过下标进...

    数组

    数组是同一种数据类型元素的集合。 在Go语言中,数组从声明时就确定,使用时可以修改数组成员,但是数组大小不可变化。数组的声明方式

    // 定义一个长度为3元素类型为int的数组a
    var a [3]int

    数组的定义

    var 数组变量名 [元素数量]元素类型

    数组的长度必须是常量,并且长度是数组类型的一部分。一旦定义,长度不能变。 [5]int和[10]int是不同的类型。

    数组可以通过下标进行访问,下标是从0开始,最后一个元素下标是:len-1,访问越界(下标在合法范围之外),则触发访问越界,会panic。

    数组的初始化

    // 使用初始化列表
    func main() {
        var testArray [3]int                        //数组会初始化为int类型的零值
        var numArray = [3]int{1, 2}                 //使用指定的初始值完成初始化
        var cityArray = [3]string{"北京", "上海", "深圳"} //使用指定的初始值完成初始化
        fmt.Println(testArray)                      //[0 0 0]
        fmt.Println(numArray)                       //[1 2 0]
        fmt.Println(cityArray)                      //[北京 上海 深圳]
    }
    
    // 让编译器根据初始值的个数自行推断数组的长度
    func main() {
        var testArray [3]int
        var numArray = [...]int{1, 2}
        var cityArray = [...]string{"北京", "上海", "深圳"}
        fmt.Println(testArray)                          //[0 0 0]
        fmt.Println(numArray)                           //[1 2]
        fmt.Printf("type of numArray:%T\n", numArray)   //type of numArray:[2]int
        fmt.Println(cityArray)                          //[北京 上海 深圳]
        fmt.Printf("type of cityArray:%T\n", cityArray) //type of cityArray:[3]string
    }
    
    // 使用指定索引值的方式来初始化数组
    func main() {
        a := [...]int{1: 1, 3: 5}
        fmt.Println(a)                  // [0 1 0 5]
        fmt.Printf("type of a:%T\n", a) //type of a:[4]int
    }

    数组的遍历

    遍历数组有以下两种方法:

    // 方法1:for循环遍历
    for i := 0; i < len(a); i++ {
        fmt.Println(a[i])
    }
    
    // 方法2:for range遍历
    for index, value := range a {
        fmt.Println(index, value)
    }

    多维数组

    多维数组(以二位数组为例)的定义方法如下:

    func main() {
        a := [3][2]string{
            {"北京", "上海"},
            {"广州", "深圳"},
            {"成都", "重庆"},
        }
        fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]
        fmt.Println(a[2][1]) //支持索引取值:重庆
    }

    注意:多维数组只有第一层可以使用...来让编译器推导数组长度。

    数组是值类型

    数组是值类型,赋值和传参会复制整个数组。因此改变副本的值,不会改变本身的值。

    切片

    切片(Slice)是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活,支持自动扩容。

    切片是一个引用类型,它的内部结构包含地址长度容量

    切片的定义

    var 变量名称[]元素类型
    
    // 例如
    var a []string              //声明一个字符串切片
    var b = []int{}             //声明一个整型切片并初始化
    var c = []bool{false, true} //声明一个布尔切片并初始化

    基于数组定义切片

    由于切片的底层就是一个数组,所以我们可以基于数组定义切片。

    func main() {
        // 基于数组定义切片
        a := [5]int{55, 56, 57, 58, 59}
        b := a[1:4]                     //基于数组a创建切片,包括元素a[1],a[2],a[3]
        fmt.Println(b)                  //[56 57 58]
        fmt.Printf("type of b:%T\n", b) //type of b:[]int
    
        c := a[1:] //[56 57 58 59]
        d := a[:4] //[55 56 57]
        e := a[:]  //[55 56 57 58 59]
    }

    切片再切片

    func main() {
        //切片再切片
        a := [...]string{"北京", "上海", "广州", "深圳", "成都", "重庆"}
        fmt.Printf("a:%v type:%T len:%d  cap:%d\n", a, a, len(a), cap(a))
        b := a[1:3]
        fmt.Printf("b:%v type:%T len:%d  cap:%d\n", b, b, len(b), cap(b))
        c := b[1:5]
        fmt.Printf("c:%v type:%T len:%d  cap:%d\n", c, c, len(c), cap(c))
    
        a:[北京 上海 广州 深圳 成都 重庆] type:[6]string len:6  cap:6
        b:[上海 广州] type:[]string len:2  cap:5
        c:[广州 深圳 成都 重庆] type:[]string len:4  cap:4
    }

    使用make()函数构造切片

    我们上面都是基于数组来创建的切片,如果需要动态的创建一个切片,我们就需要使用内置的make()函数。

    make([]元素类型, 切片中元素的数量, 切片的容量)
    
    func main() {
        a := make([]int, 2, 10)
        fmt.Println(a)      //[0 0]
        fmt.Println(len(a)) //2
        fmt.Println(cap(a)) //10
    }

    上面代码中a的内部存储空间已经分配了10个,但实际上只用了2个。 容量并不会影响当前元素的个数,所以len(a)返回2,cap(a)则返回该切片的容量。

    切片的本质

    切片的本质就是对底层数组的封装,它包含了三个信息:底层数组的指针、切片的长度(len)和切片的容量(cap)。

    举个例子,现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7},切片s1 := a[:5],相应示意图如下。
    1128810-20190406221249776-556760967.png

    切片s2 := a[3:6],相应示意图如下:
    1128810-20190406221305525-1814904373.png

    切片不能直接比较

    切片之间是不能比较的,我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组,一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil,例如下面的示例:

    var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
    s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
    s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

    所以要判断一个切片是否是空的,要是用len(s) == 0来判断,不应该使用s == nil来判断。

    append()方法为切片添加元素

    Go语言的内建函数append()可以为切片动态添加元素。 每个切片会指向一个底层数组,这个数组能容纳一定数量的元素。当底层数组不能容纳新增的元素时,切片就会自动按照一定的策略进行“扩容”,此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时。

    • append()函数将元素追加到切片的最后并返回该切片。
    • 切片numSlice的容量按照1,2,4,8,16这样的规则自动进行扩容,每次扩容后都是扩容前的2倍。

    append()函数还支持一次性追加多个元素。

    var citySlice []string
    // 追加一个元素
    citySlice = append(citySlice, "北京")
    // 追加多个元素
    citySlice = append(citySlice, "上海", "广州", "深圳")
    // 追加切片
    a := []string{"成都", "重庆"}
    citySlice = append(citySlice, a...)
    fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]

    切片的扩容策略

    可以通过查看$GOROOT/src/runtime/slice.go源码,其中扩容相关代码如下:

    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        if old.len < 1024 {
            newcap = doublecap
        } else {
            // Check 0 < newcap to detect overflow
            // and prevent an infinite loop.
            for 0 < newcap && newcap < cap {
                newcap += newcap / 4
            }
            // Set newcap to the requested cap when
            // the newcap calculation overflowed.
            if newcap <= 0 {
                newcap = cap
            }
        }
    }

    由上可知,切片的扩容策略为:

    • 首先判断,如果新申请容量(cap)大于2倍的旧容量(old.cap),最终容量(newcap)就是新申请的容量(cap)。
    • 否则判断,如果旧切片的长度小于1024,则最终容量(newcap)就是旧容量(old.cap)的两倍,即(newcap=doublecap),
    • 否则判断,如果旧切片长度大于等于1024,则最终容量(newcap)从旧容量(old.cap)开始循环增加原来的1/4,即(newcap=old.cap,for {newcap += newcap/4})直到最终容量(newcap)大于等于新申请的容量(cap),即(newcap >= cap)
    • 如果最终容量(cap)计算值溢出,则最终容量(cap)就是新申请容量(cap)。

    切片的深拷贝

    由于切片是引用类型,所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

    Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中,copy()函数的使用格式如下:
    ```go
    copy(数据来源切片, 目标切片名[]元素类型)

    从切片中删除元素

    Go语言中并没有删除切片元素的专用方法,我们可以使用切片本身的特性来删除元素。

    func main() {
        // 从切片中删除元素
        a := []int{30, 31, 32, 33, 34, 35, 36, 37}
        // 要删除索引为2的元素
        a = append(a[:2], a[3:]...)
        fmt.Println(a) //[30 31 33 34 35 36 37]
    }

    总结一下就是:要从切片a中删除索引为index的元素,操作方法是a = append(a[:index], a[index+1:]...)

    map

    Go语言中提供的映射关系容器为map,其内部使用散列表(hash)实现。

    map是一种无序的基于key-value的数据结构,Go语言中的map是引用类型,必须初始化才能使用。

    map的定义

    map[键类型]值类型

    map类型的变量默认初始值为nil,需要使用make()函数来分配内存。语法为:

    make(map[KeyType]ValueType, [cap])

    其中cap表示map的容量,该参数虽然不是必须的,但是我们应该在初始化map的时候就为其指定一个合适的容量

    判断某个键是否存在

    Go语言中有个判断map中键是否存在的特殊写法,格式如下:

    value, ok := map[key]
    
    func main() {
        scoreMap := make(map[string]int)
        scoreMap["张三"] = 90
        scoreMap["小明"] = 100
        // 如果key存在ok为true,v为对应的值;不存在ok为false,v为值类型的零值
        v, ok := scoreMap["张三"]
        if ok {
            fmt.Println(v)
        } else {
            fmt.Println("查无此人")
        }
    }

    使用delete()函数删除键值对

    使用delete()内建函数从map中删除一组键值对,delete()函数的格式如下:

    delete(map, key)

    按照指定顺序遍历map

    func main() {
        rand.Seed(time.Now().UnixNano()) //初始化随机数种子
    
        var scoreMap = make(map[string]int, 200)
    
        for i := 0; i < 100; i++ {
            key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
            value := rand.Intn(100)          //生成0~99的随机整数
            scoreMap[key] = value
        }
        //取出map中的所有key存入切片keys
        var keys = make([]string, 0, 200)
        for key := range scoreMap {
            keys = append(keys, key)
        }
        //对切片进行排序
        sort.Strings(keys)
        //按照排序后的key遍历map
        for _, key := range keys {
            fmt.Println(key, scoreMap[key])
        }
    }

    元素为map类型的切片和值为切片类型的map

    func main() {
        var mapSlice = make([]map[string]string, 3)
        for index, value := range mapSlice {
            fmt.Printf("index:%d value:%v\n", index, value)
        }
        fmt.Println("after init")
        // 对切片中的map元素进行初始化
        mapSlice[0] = make(map[string]string, 10)
        mapSlice[0]["name"] = "小王子"
        mapSlice[0]["password"] = "123456"
        mapSlice[0]["address"] = "沙河"
        for index, value := range mapSlice {
            fmt.Printf("index:%d value:%v\n", index, value)
        }
    }
    
    func main() {
        var sliceMap = make(map[string][]string, 3)
        fmt.Println(sliceMap)
        fmt.Println("after init")
        key := "中国"
        value, ok := sliceMap[key]
        if !ok {
            value = make([]string, 0, 2)
        }
        value = append(value, "北京", "上海")
        sliceMap[key] = value
        fmt.Println(sliceMap)
    }

    转载于:https://www.cnblogs.com/peilanluo/p/10662943.html

    展开全文
  • 数组与指针

    2012-04-24 16:28:09
    1、数组包括定义初始化和数组的操作,在声明数组的维数时必须用大于等于1的常量表达式定义,包括整形字面值常量、枚举常量以及整形的const对象。数组的初始化可以用显示初始化的方法,如:int ia[]={1,2,3};编译器...
  • 下标时编译器自动分配空间,但仅能初始化使用,若之后想扩充,则必须初始化自己声明。 4.用数组(ar[])表示字符串会把静态存储区中的字符串拷贝一个副本存储于数组中,此时ar被视为该数组首元素的地址。 ...
  • 1.29总结

    2019-09-30 05:52:19
    大部分学习的内容和java基础中学习的 数组内容相同 数组中需要注意什么? 数组中的每个元素必须是相同的数据类型。 数组是一个连续的内存空间 数组中的元素是变量或... 数组的元素类型就是声明数组时定义的...
  • constC与C++中的区别

    2019-09-28 06:45:32
    所以不能作为数组定义下标,因为它必须常量。  C中,const int a;可以的,因为这只是声明一个变量,告诉编译器,我这里是声明,指明别的地方有内存分配。但C++中这样写不正确的,C++...
  • 声明格式:TypeName ArrayName[ArraySize] ,其中ArraySize必须为整型常量或者const值或常量表达式,即所有的值编译已知,不能为变量。 数组的初始化规则:① 只有定义数组才能使用初始化,不能将一个数组赋给另...
  • constC和C++中的区别

    2020-07-13 17:58:23
    所以不能作为数组定义下标,因为它必须常量。   C中,const int a;可以的,因为这只是声明一个变量,告诉编译器,我这里是声明,指明别的地方有内存分配。但C++中这样写不正确的,C++中const默认...
  • 必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    6.22 如何一个文件中判断声明为extern的数组的大小(例如,数组定义和大小另一个文件中)?sizeof操作符似乎不行。 6.23 sizeof返回的大小以字节计算的,怎样才能判断数组中有多少个元素呢? 第7章 内存...
  • 1.11 extern函数声明什么意思? 1.12 关键字auto到底有什么用途? 类型定义(typedef) 1.13 对于用户定义类型,typedef 和#define有什么区别? 1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *...
  • 6.22 如何一个文件中判断声明为extern的数组的大小(例如,数组定义和大小另一个文件中)?sizeof操作符似乎不行。  6.23 sizeof返回的大小以字节计算的,怎样才能判断数组中有多少个元素呢?  第7章 内存...
  •  1.11 extern函数声明什么意思?  1.12 关键字auto到底有什么用途?  类型定义(typedef)  1.13 对于用户定义类型,typedef 和#define有什么区别?  1.14 我似乎不能成功定义一个链表。我试过typedef ...
  • 1.11 extern函数声明什么意思? 35 1.12 关键字auto到底有什么用途? 36 类型定义(typedef) 36 1.13 对于用户定义类型,typedef 和#define有什么区别? 36 1.14 我似乎不能成功定义一个链表。我试过...
  • 1.11 extern函数声明什么意思? 35 1.12 关键字auto到底有什么用途? 36 类型定义(typedef) 36 1.13 对于用户定义类型,typedef 和#define有什么区别? 36 1.14 我似乎不能成功定义一个链表。我试过...
  • 数组是一种数据格式,能够存储多个同类型的值。 ※创建数组,可以使用声明语句,...表达式arraySize必须是整形常量,不允许是变量; ※访问数组,可以单独访问某个元素,方法是通过下标和索引来对元素进行编号。c++
  •  第6章 数组和指针 数组和指针的基本关系 6.1 我一个源文件中定义了chara[6],另一个源文件中声明了externchar*a。为什么不行? 6.2 可是我听说chara[]和char*a等价的。这样的吗? 6.3 那么,...
  • 1.11 extern函数声明什么意思? 1.12 关键字auto到底有什么用途? 类型定义(typedef) 1.13 对于用户定义类型,typedef 和#define有什么区别? 1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.11 extern函数声明什么意思? 6 1.12 关键字auto到底有什么用途? 7 类型定义(typedef) 7 1.13 对于用户定义类型,typedef 和#define有什么区别? 7 1.14 我似乎不能成功定义一个链表。我试过...
  • 1.11 extern函数声明什么意思? 6 1.12 关键字auto到底有什么用途? 7 类型定义(typedef) 7 1.13 对于用户定义类型,typedef 和#define有什么区别? 7 1.14 我似乎不能成功定义一个链表。我试过...
  • 前面已经回顾了C++中的基本类型,而复合类型就是利用基本类型来创建的,数组是由多个同类型元素组成的,...2.声明:类型 数组名[个数]:个数必须在编译就确定下来,可以个符号常量常量表达式、字面值 3.数组...
  • 必须知道的495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    1.4 extern 函数声明什么意思? . . . . . . . . . . . . . . . . . 2 1.5 关键字auto 到底有什么用途? . . . . . . . . . . . . . . . . . . . 2 1.6 我似乎不能成功定义一个链表。我试过typedef struct f ...

空空如也

空空如也

1 2 3
收藏数 57
精华内容 22
关键字:

在声明数组时下标必须是常量