精华内容
下载资源
问答
  • C语言中的结构体数组

    万次阅读 多人点赞 2017-01-15 00:45:10
    结构体数组的引用结构体数组的概念元素为结构体类型数组称为结构体数组,在实际应用过程,经常使用结构体数组来表示具有相同数据结构一个群体struct student{ int xh; char *name; char *sex; }stu[20];...

    C语言中的结构体数组

    1.结构体 数组概念
    2. 结构体数组定义和初始化
    3. 结构体数组的引用

    结构体数组的概念

    元素为结构体类型的数组称为结构体数组,在实际的应用过程中,经常使用结构体数组来表示具有相同数据结构的一个群体

    struct student{
        int xh;
        char *name;
        char *sex;
    }stu[20];
    定义了一个结构体数组stu,共有30个元素,stu[0]--stu[29];
    每个数组的元素都是struct student类型
    

    结构体数组定义和初始化

    1:先声明结构体,再去定义结构体数组

    struct 结构体名{
        成员列表;
    };
    struct 结构体名 数组名[长度] = {{成员值列表},...{成员值列表}};
    struct 结构体名 数组名[长度] = {结构体变量1,...,结构体变量n};
    

    2:声明结构体的同时去定义结构体数组(结构体名可以省略);

    struct [结构体名]
    {
        成员列表;
    }数组名[长度] ={{成员值列表}...{成员值列表}};  
    

    结构体数组的引用

    结构体数组名[下标].成员名
    通过下表可以获得结构体数组中指定的结构体变量,然后再通过点运算符,可以获得结构体变量中的成员
    如:
        struct student{
            int  xh;
            char name[];
        }stu[4];
        strcpy(stu[0].name,"Tom");
        stu[1].xh = 1;
    

    下面是对应的结构体数组的实际操作代码:

    #include<stdio.h>
    #include<stdlib.h>
    
    //结构体中声明中尽量使用字符指针进行字符串操作,在初始化的时候会方便
    //如果使用的是字符数组,那么会就要使用strcpy进行拷贝初始化
    struct address{
        char *country;
        char *city;
    };
    
    struct teacher{
        char *name;
        int age;
        struct address addr;
    };
    
    void out_teacher(struct teacher tea);
    
    void out_all_teachers(struct teacher [],int num);
    
    int main(int argc,char *argv[]){
        //先定义结构体变量,再进行定义结构体数组
        struct teacher teacher_one = {"zhangsan",20,{"china","shanghai"}};
        struct teacher teacher_two = {"lisi",25,{"china","hefei"}};
        struct teacher teachers_one [] = {teacher_one,teacher_two};
        out_all_teachers(teachers_one,2);
        printf("-----------------------------\n");
        //在定义结构体数组的时候,直接进行结构体数组的初始化工作
        struct teacher  teachers_two [] = {{"wangwu",30,{"china","tianjin"}},{"zhaoliu",40,{"china","jiaozuo"}},{"tianqi",50,{"china","shenzhen"}}};
        out_all_teachers(teachers_two,3);
    
        return 0;
    }
    
    void out_teacher(struct teacher tea){
        printf("name:%s",tea.name);
        printf("age:%d\n",tea.age);
        printf("country:%s\n",tea.addr.country);
        printf("city:%s\n",tea.addr.city);
    }
    
    void out_all_teachers(struct teacher teachers[],int num){
        int i = 0;
        for(i = 0; i < num ; i++){
            out_teacher(teachers[i]);
            printf("======================\n");
        }   
    }

    代码能够run,如果有需要的话,可以直接拉下来run一下,看看结构体数组是怎么进行初始化操作和使用的。谢谢大家的访问,如有写的不好的地方,希望大家能够及时的提出来,谢谢观看

    展开全文
  • 结构体数组

    千次阅读 多人点赞 2019-05-29 20:46:22
    他与前面讲过数组类型几乎一摸一样,只不过需要注意是,结构体数组的每一个元素都是一个结构体类型变量,都包含结构体所有成员项。 定义结构体数组的方法很简单,同定义结构体变量一样,只不过将变量...

    结构体数组的定义与引用

    一个结构体变量可以存放一个学生的一组信息,可是如果有10个学生?难道要定义10个结构体变量?,很明显不现实,这时就要使用数组。结构体中也有数组,称为结构体数组。他与前面讲过的数组类型几乎一摸一样,只不过需要注意的是,结构体数组的每一个元素都是一个结构体类型的变量,都包含结构体中所有的成员项。

    定义结构体数组的方法很简单,同定义结构体变量一样的,只不过将变量改成数组。或者说桶前面介绍的普通数组一模一样的,只不过将变量改成数组。

    struct STUDENT stu[10];
    

    这就定义了一个结构体数组,一共 10 个元素,每一个元素都是一个结构体变量,都包含所有的结构体成员。
    结构体数组的引用与引用一个结构体变量在原理上是一样的。只不过是结构体数组中有多个结构体变量,我们只需要利用 for 循环一个一个地使用结构体数组中的元素。

    下面我们来写一个程序

    #include<stdio.h>
    #include<string.h>
    struct STU
    {
    	char name[20];
    	int age;
    	char sex;
    	char num[20];
    }
    
    void OutputSTU(struct STU stu[5]);
    int main(void)
    {
    	int i;
    	struct STU stu[5];
    	for(i=0; i<5; ++i)
    	{
    		printf("请输出第 %d 个学生的信息:\n", i+1);
    		scanf("%s%d %c%s", stu[i].name, &stu[i].age, &stu[i].sex, stu[i].num);
    		OutputSTU(stu);
    		return 0;
    	}
    }
    
    void OutputSTU(struct STU stu[5])
    {
    	struct STU stumax = stu[0];
    	int j;
    	for(j=1; j<5; j++)
    	{
    		if(strcmp(stumax.num, stu[j].num) < 0)
    		{
    			stumax = stu[j];
    		}
    	}
    	printf("学生姓名:%s 学生年龄:%d 学生性别:%c 学生学号:%s\n", stumax.name, stumax.age, stumax.sex, stumax.num);
    }
    

    在这里插入图片描述

    展开全文
  • 7.2 结构体数组定义和引用 当需要使用大量结构体变量时,可使用结构体定义数组,该数组包含与...引用结构体数组中元素的一般形式为: 结构体数组名[n].成员名 [] 符号优先级与.符号相同,适用于自...

    7.2 结构体数组的定义和引用

    当需要使用大量的结构体变量时,可使用结构体定义数组,该数组包含与结构体相同的数据结构所组成的连续存储空间。如下例所示:

    struct student stu_a[50];        // 声明长度为 50 的结构体数组 stu_a

    引用结构体数组中元素的一般形式为:

    结构体数组名[n].成员名

    [] 符号的优先级与.符号相同,适用于自左向右结合性,所以运算时首先获得的是结构体数组的元素,然后再获得该元素的成员。如果该成员是数组,引用该成员数组元素的一般形式为:

    结构体数组名[n].成员名[n]。同理,如果该成员是结构体变量,引用形式为:结构体数组名[n].成员.子成员。依次类推,如何复杂的成员都可以被访问。如下例所示:

    #include <stdio.h>
    
    int main(void)
    {
    	struct student
    	{
    		char name[50];		// 姓名
    		char dept[50];		// 专业
    		long no;			// 学号
    		float score[4];		// 成绩
    	};
    
    	struct student stu_a[2] = {
    		"Tom", "Math", 2009001, 87.5, 70.5, 93, 91,
    		"Jerry", "Math", 2009002, 90, 78.5, 83.5, 66
    	};
    
    	int i;
    
    	for (i = 0; i < 2; i++)
    	{
    		printf("%8s %8s %ld %5.2f %5.2f %5.2f %5.2f\n",
    			stu_a[i].name,
    			stu_a[i].dept,
    			stu_a[i].no,
    			stu_a[i].score[0],
    			stu_a[i].score[1],
    			stu_a[i].score[2],
    			stu_a[i].score[3]
    		);
    	}
    }

    程序中声明了结构体数组 stu_a[],并在声明时用数据为其初始化。然后用 printf() 函数将结构体数组中的数据输出。

    转载于:https://www.cnblogs.com/52php/p/5681795.html

    展开全文
  • 点击上方蓝色“后端开发杂谈”关注我们, 专注于后端日常开发技术分享map 数据结构与实际的数据结构map 中的数据被存放在一个数组中的, 数组的元素是桶(bucket), 每个桶至多包含8个键值对数据. 哈希值低位(low-order ...

    点击上方蓝色“后端开发杂谈”关注我们, 专注于后端日常开发技术分享

    map 数据结构与实际的数据结构

    map 中的数据被存放在一个数组中的, 数组的元素是桶(bucket), 每个桶至多包含8个键值对数据. 哈希值低位(low-order bits)用于选择桶, 哈希值高位(high-order bits)用于在一个独立的桶中区别出键. 哈希值高低位示意图如下:

    1f5281544b347173f90fe113d0d401bb.png
    image
    源码位于 src/runtime/map.go.

    结构体

    // A header for a Go map.
    type hmap struct {
        count     int    // 代表哈希表中的元素个数, 调用len(map)时, 返回的就是该字段值.
        flags     uint8  // 状态标志, 下文常量中会解释四种状态位含义.
        B         uint8  // buckets(桶)的对数log_2(哈希表元素数量最大可达到装载因子*2^B)
        noverflow uint16 // 溢出桶的大概数量.
        hash0     uint32 // 哈希种子.

        buckets    unsafe.Pointer // 指向buckets数组的指针, 数组大小为2^B, 如果元素个数为0, 它为nil.
        oldbuckets unsafe.Pointer // 如果发生扩容, oldbuckets是指向老的buckets数组的指针, 老的buckets数组大小是新
                                  // 的buckets的1/2.非扩容状态下, 它为nil. 它是判断是否处于扩容状态的标识

        nevacuate  uintptr        // 表示扩容进度, 小于此地址的buckets代表已搬迁完成.

        extra *mapextra // 这个字段是为了优化GC扫描而设计的. 当key和value均不包含指针, 并且都可以inline时使用.
                        // extra是指向mapextra类型的指针.
    }

    // mapextra holds fields that are not present on all maps.
    type mapextra struct {
        // 就使用 hmap 的 extra 字段来存储 overflow buckets, 

        // 如果 key 和 value 都不包含指针, 并且可以被 inline(<=128 字节), 则将 bucket type 标记为不包含指针 (使用
        // ptrdata 字段, 为0表示不包含指针). 这样可以避免 GC 扫描整个 map. 但是 bmap.overflow 是一个指针. 这时候我
        // 们只能把这些 overflow 的指针都放在 hmap.extra.overflow 和 hmap.extra.oldoverflow 中了.
        //  
        // 当 key 和 elem 不包含指针时, 才使用 overflow 和 oldoverflow. 
        // overflow 包含的是 hmap.buckets 的 overflow bucket, 
        // oldoverflow 包含扩容时的 hmap.oldbuckets 的 overflow bucket.
        overflow    *[]*bmap
        oldoverflow *[]*bmap

        // 指向空闲的 overflow bucket 的指针(第一个空闲的bucket地址)
        nextOverflow *bmap
    }

    // A bucket for a Go map.
    type bmap struct {
        // tophash包含此桶中每个键的哈希值最高字节(高8位)信息(也就是前面所述的high-order bits).
        // 如果tophash[0] 
        tophash [bucketCnt]uint8
    }

    常量值

    const (
        // 一个桶中最多能装载的键值对(key-value)的个数为8
        bucketCntBits = 3
        bucketCnt     = 1 <// 8

        // 触发扩容的装载因子为13/2=6.5
        loadFactorNum = 13
        loadFactorDen = 2

        // 键和值超过128个字节, 就会被转换为指针
        maxKeySize  = 128
        maxElemSize = 128

        // 数据偏移量应该是bmap结构体的大小, 它需要正确地对齐. 
        // 对于amd64p32而言, 这意味着: 即使指针是32位的, 也是64位对齐. 
        dataOffset = unsafe.Offsetof(struct {
            b bmap
            v int64
        }{}.v)

        // 每个桶(如果有溢出, 则包含它的overflow的链桶) 在搬迁完成状态(evacuated states)下, 要么会包含它所有的键值对,
        // 要么一个都不包含(但不包括调用evacuate()方法阶段,该方法调用只会在对map发起write时发生,在该阶段其他goroutine
        // 是无法查看该map的). 简单的说,桶里的数据要么一起搬走,要么一个都还未搬.
        //
        // tophash除了放置正常的高8位hash值, 还会存储一些特殊状态值(标志该cell的搬迁状态). 正常的tophash值, 
        // 最小应该是5,以下列出的就是一些特殊状态值. 
        emptyRest      = 0 // 空的cell, 并且比它高索引位的cell或者overflows中的cell都是空的. (初始化bucket时,就是该状态)
        emptyOne       = 1 // 空的cell, cell已经被搬迁到新的bucket
        evacuatedX     = 2 // 键值对已经搬迁完毕,key在新buckets数组的前半部分
        evacuatedY     = 3 // 键值对已经搬迁完毕,key在新buckets数组的后半部分
        evacuatedEmpty = 4 // cell为空,整个bucket已经搬迁完毕
        minTopHash     = 5 // tophash的最小正常值

        // flags
        iterator     = 1 // 可能有迭代器在使用buckets
        oldIterator  = 2 // 可能有迭代器在使用oldbuckets
        hashWriting  = 4 // 有协程正在向map写人key
        sameSizeGrow = 8 // 等量扩容

        // 用于迭代器检查的bucket ID
        noCheck = 1<8*sys.PtrSize) - 1 // 系统的最大值
    )

    bmap(即map当中的bucket)内存结构

    // src/cmd/compile/internal/gc/reflect.go:bmap
    // bucket 结构 
    func bmap(t *types.Type) *types.Type {
        if t.MapType().Bucket != nil {
            return t.MapType().Bucket
        }

        bucket := types.New(TSTRUCT)
        keytype := t.Key()
        elemtype := t.Elem()
        dowidth(keytype)
        dowidth(elemtype)
        if keytype.Width > MAXKEYSIZE {
            keytype = types.NewPtr(keytype)
        }
        if elemtype.Width > MAXELEMSIZE {
            elemtype = types.NewPtr(elemtype)
        }

        field := make([]*types.Field, 05)

        // The first field is: uint8 topbits[BUCKETSIZE].
        arr := types.NewArray(types.Types[TUINT8], BUCKETSIZE)
        field = append(field, makefield("topbits", arr))

        arr = types.NewArray(keytype, BUCKETSIZE)
        arr.SetNoalg(true)
        keys := makefield("keys", arr)
        field = append(field, keys)

        arr = types.NewArray(elemtype, BUCKETSIZE)
        arr.SetNoalg(true)
        elems := makefield("elems", arr)
        field = append(field, elems)

        // 确保 overflow 指针是结构中的最后一个内存, 因为运行时假定它可以使用size-ptrSize作为 overflow 指针的偏移量. 
        // 一旦计算了偏移量和大小, 我们就要仔细检查下面的属性(在已经忽略检查代码).
        //
        // BUCKETSIZE为8, 因此该结构在此处已对齐为64位.
        // 在32位系统上, 最大对齐方式为32位, 并且溢出指针将添加另一个32位字段, 并且该结构将以无填充结尾.
        // 在64位系统上, 最大对齐方式为64位, 并且溢出指针将添加另一个64位字段, 并且该结构将以无填充结尾.
        // 但是, 在nacl/amd64p32上, 最大对齐方式是64位, 但是溢出指针只会添加一个32位字段, 因此, 如果该结构需要64位填充
        // (由于key或elem的原因), 则它将最后带有一个额外的32位填充字段.
        // 通过在此处发出填充.
        if int(elemtype.Align) > Widthptr || int(keytype.Align) > Widthptr {
            field = append(field, makefield("pad", types.Types[TUINTPTR]))
        }

        // 如果keys和elems没有指针, 则map实现可以在侧面保留一个 overflow 指针列表, 以便可以将 buckets 标记为没有指针.
        // 在这种情况下, 通过将 overflow 字段的类型更改为 uintptr, 使存储桶不包含任何指针.
        otyp := types.NewPtr(bucket)
        if !types.Haspointers(elemtype) && !types.Haspointers(keytype) {
            otyp = types.Types[TUINTPTR]
        }
        overflow := makefield("overflow", otyp)
        field = append(field, overflow)

        // link up fields
        bucket.SetNoalg(true)
        bucket.SetFields(field[:])
        dowidth(bucket)

        t.MapType().Bucket = bucket

        bucket.StructType().Map = t
        return bucket
    }

    hmap (即map) 内存结构

    // src/cmd/compile/internal/gc/reflect.go:hmap
    func hmap(t *types.Type) *types.Type {
        if t.MapType().Hmap != nil {
            return t.MapType().Hmap
        }

        bmap := bmap(t)

        // type hmap struct {
        //    count      int
        //    flags      uint8
        //    B          uint8
        //    noverflow  uint16
        //    hash0      uint32
        //    buckets    *bmap
        //    oldbuckets *bmap
        //    nevacuate  uintptr
        //    extra      unsafe.Pointer // *mapextra
        // }
        // must match runtime/map.go:hmap.
        fields := []*types.Field{
            makefield("count", types.Types[TINT]),
            makefield("flags", types.Types[TUINT8]),
            makefield("B", types.Types[TUINT8]),
            makefield("noverflow", types.Types[TUINT16]),
            makefield("hash0", types.Types[TUINT32]), // Used in walk.go for OMAKEMAP.
            makefield("buckets", types.NewPtr(bmap)), // Used in walk.go for OMAKEMAP.
            makefield("oldbuckets", types.NewPtr(bmap)),
            makefield("nevacuate", types.Types[TUINTPTR]),
            makefield("extra", types.Types[TUNSAFEPTR]),
        }

        hmap := types.New(TSTRUCT)
        hmap.SetNoalg(true)
        hmap.SetFields(fields)
        dowidth(hmap)

        // The size of hmap should be 48 bytes on 64 bit and 28 bytes on 32 bit platforms.
        // 5("count", "buckets", "oldbuckets", "nevacuate", "extra")
        if size := int64(8 + 5*Widthptr); hmap.Width != size {
            Fatalf("hmap size not correct: got %d, want %d", hmap.Width, size)
        }

        t.MapType().Hmap = hmap
        hmap.StructType().Map = t
        return hmap
    }

    bmap 也就是 bucket(桶)的内存模型图解如下(代码逻辑就是上述的 bmap 函数).

    fe1f8374463afe753bb304806b5e9b49.png
    image

    该桶的第7,8位cell还未有对应的键值对. 注意: key和value是各自存储起来的, 并非想象中的 key/value/key/value…的形式. 这样的做法好处在于消key/value之间的padding, 例如map[int64]int. 还有,在8个键值对数据后面还有一个overflow指针, 因为桶中最多只能装8个键值对, 如果有多余的键值对落到当前桶, 那么就需要再构建一个桶(溢出桶), 通过 overflow 指针链接起来.

    最后, 这里展示一个 B=4 的完整 map 结构:

    1355721151946b80408fea4d29ab0422.png
    image
    • 参考链接
      1.8 万字详解 Go 是如何设计 Map 的

    e32b9dadc27b2864f4996dfc9f72e011.png

    展开全文
  • struct dc_msg { ...想调用 msg_body[MAX_MSG_LEN]0-10,也就是前11个数组的元素,将他们的值从十进制转换成十六进制,将转换后的值付给新的a[11]。有些术语说的可能不够专业,新手,刚刚开始学习,请高手赐教!
  • C++通过指向结构体变量的指针引用结构体变量中的成员C++中,一个结构体变量的指针就是该变量所占据的内存段的起始地址,指针变量也可以用来指向结构体数组中的元素。 C++提供了指向结构体变量的运算符->,例如:p...
  • C++通过指向结构体变量的指针引用结构体变量中的成员C++中,一个结构体变量的指针就是该变量所占据的内存段的起始地址,指针变量也可以用来指向结构体数组中的元素。C++提供了指向结构体变量的运算符->,例如:p-...
  • 即若干个字符变量的集合,数组中的每个元素都是字符型的变量 char 组名[]; 2)短整型的数组 short int 组名[]; 3)整型的数组 int 组名[]; 4)长整型的数组 long int 组名[]; 5)浮点型的数组(单、双) float ...
  • C语言——结构数组

    2019-11-04 09:36:56
    只不过结构体数组中有多个结构体变量,我们只需利用 for 循 环一个一个地使用结构体数组中的元素。 下面我尝试编写一个程序,从键盘输入 5 个学生的基本信息,如姓名、年龄、性别、学号,然后将学号最大的学生的基本...
  • 本讲首先介绍了C语言指向结构体变量和结构体数组的指针变量使用接着介绍了结构体数据作为函数参数使用最后介绍了链表概念和基本操作要求大家掌握指向结构体变量指针变量和指向结构体数组及数组元素的指针...
  • C语言中的结构体指针

    千次阅读 多人点赞 2017-01-16 23:45:08
    结构体数组指针 结构体引用与不完全声明 结构体指针概念概念:结构体变量地址,指向某个结构体变量(同时也是结构体变量第一个元素的地址),我们可以通过结构体变量可以指向结构体包含一些成员定义: ...
  • 结构体

    2013-09-20 11:30:38
    指针变量也可以用来指向结构体数组中的元素。 1. 通过指向结构体变量的指针引用结构体变量中的成员   为了使用方便和直观,C++提供了指向结构体变量的运算符->,例如p->num表示指针p当前指向的结构体变量中的...
  • 结构体变量指针

    2014-03-12 22:53:26
    指针变量也可以用来指向结构体数组中的元素。 1. 通过指向结构体变量的指针引用结构体变量中的成员 下面通过一个简单例子来说明指向结构体变量的指针变量的应用。例7.3 指向结构体变量的指针的应用。 #...
  • 数组是最基本的构造类型,它是一组相同数据类型数据的有序集合, 数组中的元素在内存中连续存放, 用数组名和下标可以唯一地确定数组元素。 一维数组的定义:类型名 数组名[数组长度] 二维数组的定义: 类型名 ...
  • 一个结构体变量的指针就是该变量所占据的内存段的起始地址。...指针变量也可以用来指向结构体数组中的元素。 通过指向结构体变量的指针引用结构体变量中的成员 下面通过一个简单例子来说明指向结构体变
  • 声明数组变量就是将原本需要一个个单独声明的变量比如:num1,num2…转换成声明一个nums这样的变量,然后再通过num[0]…来表示原本单独的变量,并通过索引的方式访问数组中的某个元素。 在物理上,数组是由...
  • 指向结构体变量的指针 一个结构体变量的指针:该... 指针也可以用来指向结构体数组中的元素。 A 通过指向结构体变量的指针引用结构体成员 例子1: 结构体变量的指针变量的应用 #include &lt;iostrea...
  • C++结构体与指针

    千次阅读 2017-04-11 11:00:29
    指针变量也可以用来指向结构体数组中的元素。 通过指向结构体变量的指针引用结构体变量中的成员 下面通过一个简单例子来说明指向结构体变量的指针变量的应用。 【例7.3】指向结构体变量的指针的应用。 #include ...
  • C语言结构体指针

    2019-04-01 19:51:57
    指针变量也可指向结构体数组中的元素。 指向结构体变量的指针 因为指针指向结构体变量的地址,因此可以使用指针访问结构体中的成员。定义结构体指针的一般形式是: 结构体类型 *指针名; struct Student *pStruct; ...
  • 数组

    2019-12-24 23:51:10
    数组 一维数组的定义 1.定义一维数组的格式如下: 类型标识符 数组[名常量表达式]; 其中,类型标识符可以是任何基本数据...数组定义好后,就可以“引用数组中的任意一个元素引用格式为“数组名[下标]。其中,下...
  • c语言结构体引用元素“.”与“->”辨析 后缀表达式后跟一个圆点和一个标识符仍是后缀表达式。第一个操作数表达式类型必须是结构或联合,标识符必须是结构或联合成员名字。结果值是结构或联合命名成员,...
  • datatype用于指定被存储在数组中的元素的类型。 [ ]指定数组的秩(维度)。秩指定数组的大小。 arrayName指定数组的名称。 初始化数组 声明一个数组不会在内存中初始化数组。当初始化数组变量时,您可以赋值给...
  • C语言结构体

    2019-04-18 15:38:00
    数组是相同元素的集合,它每个元素是通过下标引用或指针间接访问结构体也是一些值的的集合,这些值称为它 成员,但一个结构成员可能具有不同类型。 数组元素可以通过下标访问,这是因为数组元素长度...
  • 概念:前面系列文章介绍了基本类型变量,如BOOL,整形,浮点型,也介绍了数组,数组中各个元素属于同一类型。但是仅仅这些类型还是不够,有时候还需要把不同类型数据组合成一个整体以便于引用结构体可以包含...
  • 一、结构体数组中的元素是属于同一个类型的。有时需要将不同类型的数据组合成一个整体,以便于引用。如,一个学生的学号、姓名、性别、年龄、成绩、家庭地址等项。这些项都与某一学生相联系。如果分别定义为互相...
  • 结构体指针定义和引用

    千次阅读 2011-11-18 12:00:31
    前面课程我们学习了一些简单数据类型(整型、实型、字符型)...而数组的全部元素都具有相同数据类型,或者说是相同数据类型一个集合。 在日常生活,我们常会碰到一些需要填写登记表,如住宿表、成绩表、通

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 152
精华内容 60
关键字:

引用结构体数组中的元素