C语言中定义了结构体一定要先进行初始化么?如果不初始化直接使用会有啥后果?
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C语言中定义了结构体一定要先进行初始化么?如果不初始化直接使用会有啥后果?相关的知识,希望对你有一定的参考价值。
要先进行初始化,如struct student int number; int score;;就是先定义,目的是让系统给它分配空间和地址,让后再定义一个结构体类型 如 struct student std;
这时结构体才能使用,
要不然你真接使用,系统之间没有给你地址和空间,你的数据要放那里都不知道 参考技术A 要的,不然得不到结果
go——结构
Go语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体定义需要使用type和struct语句。struct语句定义一个新的数据类型,结构体中有一个或多个成员。
type语句设定了结构体的名称。格式如下:
type struct_name struct { name string talk Talk }
一旦定义了结构体类型,它就能用于变量的声明,语法格式如下:
variable_name := structure_name{value1,value2} //顺序必须与结构体的定义一致
或者:
variable_name := structure_name{key1:value1,key2:value2} //结构体名称:值
结构体类型中的每个字段都需要独占一行。一般情况下,字段声明需由字段名称和表示字段类型的字面量组成。
还有一种只有类型字面量的无名称字段,称为嵌入字段。
虽然嵌入字段可以用来无缝集成额外字段和方法,但是其嵌入规则和使用规则都比较复杂。
结构体类型的值一般由复合字面量来表达。
复合字面量可以由类型字面量和花括号包裹的键值对列表组成。
这里,键就是结构体类型中某个字段的名称,而值(又称元素)就是要赋给该字段的那个值。
表示结构体值的复合字面量可以简称为结构体字面量。
在同一个结构体字面量中,一个字段名称只能出现一次。
字段名必须唯一,可用"_"补位,支持使用自身指针类型成员.
字段名,排列顺序属于类型组成部分.除对齐处理外,编译器不会优化和调整内存布局。
package main import "fmt" type node struct { _ int //没给值会使用默认值 id int next *node } func main() { n1 := node{ id: 1, } n2 := node{ id: 2, next: &n1, } fmt.Println(n1, n2) //{0 1 <nil>} {0 2 0xc000048400} }
可按顺序初始化全部字段,或使用命名方式初始化指定字段。
package main import "fmt" func main() { type user struct { name string age int } u1 := user{"Tom", 12} //如果顺序初始化字段,就必须赋值全部字段 u2 := user{"Kebi"} //too few values in user literal,字段数量不够 u3 := user{ //命名初始化 name: "maoixan", age: 18, } fmt.Println(u1, u3) }
推荐使用命名初始化,这样在扩充结构字段或调整字段顺序时,不会导致语句初始化错误.
可以直接匿名结构类型变量,还可以将结构体用作字段类型。
package main import "fmt" func main() { u := struct { //直接定义匿名结构变量 name string age int8 }{ name: "kebi", age: 18, } type file struct { name string attr struct { //定义匿名结构类型字段 owner int perm int } } f := file{ name: "test.py", // attr: { //missing type in composite literal,对于结构体中的结构体赋值方式有所不同 // owner: 10, // perm: 755, // }, } f.attr.owner = 10 //正确方式 f.attr.perm = 755 fmt.Println(u, f) //{kebi 18} {test.py {10 755}} }
只有在所有字段类型全部支持时,才可做相等操作。
package main import "fmt" func main() { type data struct { x int y map[string]int //字典类型不支持==, } d1 := data{ x: 100, } d2 := data{ x: 100, } fmt.Println(d1 == d2) //struct containing map[string]int cannot be compared }
可使用指针直接操作结构字段,但不能是多级指针。
package main import "fmt" func main() { type user struct { name string age int } p := &user{ //获取指针 name: "kebi", age: 26, } p.name = "maoxian" //通过指针找到对应的程序实体 p.age++ fmt.Println(p) //&{maoxian 27} p2 := &p //&p属于二级指针 *p2.name = "xiaoniao" //p2.name undefined (type **user has no field or method name) }
空结构
空结构struct{}是指没有字段的结构类型。
它比较特殊,因为无论是其自身,还是作为数组元素类型,其长度都为0。
package main import ( "fmt" "unsafe" ) func main() { var a struct{} //匿名结构体 var b [100]struct{} //以结构体作为元素类型的数组 fmt.Println(unsafe.Sizeof(a), unsafe.Sizeof(b)) //0 0 s := b[:] b[1] = struct{}{} //重新赋值 s[2] = struct{}{} fmt.Println(s[3], len(s), cap(s)) //{} 100 100 }
实际上,这类长度为0的对象通常指向runtime.zerobase变量。
package main import "fmt" func main() { a := [10]struct{}{} b := a[:] c := [0]int{} fmt.Printf("%p, %p, %p ", &a[0], &b[0], &c) //0x5771c8, 0x5771c8, 0x5771c8 }
空结构可作为通道元素类型,用于事件通知。
package main import "fmt" func main() { exit := make(chan struct{}) go func() { fmt.Println("hello, world!") exit <- struct{}{} }() <-exit fmt.Println("end.") }
匿名字段
所谓匿名字段是指没有名字,仅有类型的字段,也称作嵌入字段或嵌入类型。
从编译器角度看,这只是隐式地以类型名作为字段名称。
可直接引用匿名字段的成员,但初始化时必须当作独立字段。
package main import "fmt" type attr struct { perm int } type file struct { name string attr //仅有类型名 } func main() { f := file{ name: "test.dat", attr: attr{ //将类型名当作字段名 perm: 755, }, } f.perm = 500 //直接设置匿名字段成员 fmt.Println(f, f.perm) //直接读取匿名字段成员 }
如果嵌入其它包中的类型,则隐式字段名称不包括包名。
不仅仅是结构体,除接口指针和多级指针以外的任何命名类型都可以作为匿名字段。
package main import "fmt" type data struct { *int //嵌入指针类型 string } func main() { x := 100 d := data{ int: &x, //使用基础类型作为字段名 string: "abc", } fmt.Printf("%#v ", d) } /* main.data{ int:(*int)(0xc00000a168), string:"abc" } */ 不能将基础类型和其指针类型同时嵌入,因为两者隐式名字相同,下面就是错误示例。 // type data struct { // *int // int // }
虽然可以像普通字段那样访问匿名字段成员,但会存在重名问题。
默认情况下,编译器从当前显式命名开始,逐步向内查找匿名字段成员。
如果匿名字段成员被外层同名字段遮蔽,那么必须使用显式字段名。
package main import "fmt" type file struct { name string } type data struct { file name string //与匿名字段file.name重名 } func main() { d := data{ name: "data", file: file{"file"}, //这种方式赋值并没有影响 } fmt.Println(d.name, d.file.name) //data file d.name = "data2" d.file.name = "file2" fmt.Println(d.name, d.file.name) //data2 file2 }
如果多个相同层级的匿名字段成员重名,就只能使用显式字段名访问,因为编译器无法确定目标。
package main import "fmt" type file struct { name string } type log struct { name string } type data struct { file //file和log层次相同 log //file.name和log.name重名 } func main() { d := data{ file: file{"1.txt"}, log: log{"test.log"}, } fmt.Println(d) //{{1.txt} {test.log}} d2 := data{} // d2.name = "name" //ambiguous selector d2.name d2.file.name = "file" //显式命名字段 d2.log.name = "log" fmt.Println(d2) //{{file} {log}} }
严格说来,Go并不是传统意义上的面向对象编程语言,或者说仅实现了最小面向对象的机制。
匿名嵌入不是继承,无法实现多态处理。
虽然配合方法集,可用接口来显现一些类似的操作,但其本质完全不同。
字段标签
字段标签(tag)并不是注释,而是用来对字段进行描述的元数据。
尽管它不属于数据成员,但却是类型的组成部分。
在运行期,可以反射获取标签信息。常被用作格式校验,数据库关系映射等。
package main import ( "fmt" "reflect" ) type user struct { name string `昵称` sex int `性别` } func main() { u := user{"Tom", 1} v := reflect.ValueOf(u) t := v.Type() for i, n := 0, t.NumField(); i < n; i++ { fmt.Printf("%s: %v ", t.Field(i).Tag, v.Field(i)) } } /* 昵称: Tom 性别: 1 */
以上是关于C语言中定义了结构体一定要先进行初始化么?如果不初始化直接使用会有啥后果?的主要内容,如果未能解决你的问题,请参考以下文章