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

    1、结构体

    基本定义:结构体,通俗讲就像是打包封装,把一些有共同特征(比如同属于某一类事物的属性,往往是某种业务相关属性的聚合)的变量封装在内部,通过一定方法访问修改内部变量。

    标准定义:

    例1:

    #include <stdio.h> 

    struct student  //结构体类型的说明与定义分开。 声明

    {

    int age;   /*年龄*/

    float score;  /*分数*/

    char sex;     /*性别*/

    };


    int main ()

    {

      struct student a={ 20,79,'f'}; //定义

    printf("年龄:%d 分数:%.2f 性别:%c\n", a.age, a.score, a.sex  );

    return 0;

    }


    例2:

    #include <stdio.h> 

    struct student  //结构体类型的说明与定义在一起。 声明和定义

    {

    int age;   /*年龄*/

    float score;  /*分数*/

    char sex;     /*性别*/

    }student_test;


    int main ()

    {

      student_test a={ 20,80,'m'}; //结构体使用

    student_test a; //结构体使用

    a.age = 20; //结构体成员变量采用 . 连接

    a.score = 80;

    a.sex = 'm';


    printf("年龄:%d 分数:%.2f 性别:%c\n", a.age, a.score, a.sex  );

    return 0;

    }


    例3:

    #include <stdio.h> 

    typedef struct //结构体类型的说明与定义在一起。 声明和定义

    {

    int age;   /*年龄*/

    float score;  /*分数*/

    char sex;     /*性别*/

    }student_test;


    int main ()

    {

      student_test a={ 20,80,'m'}; //结构体使用

    printf("年龄:%d 分数:%.2f 性别:%c\n", a.age, a.score, a.sex  );

    student_test a; //结构体使用

    a.age = 20; //结构体成员变量采用 . 连接

    a.score = 80;

    a.sex = 'm';

    printf("年龄:%d 分数:%.2f 性别:%c\n", a.age, a.score, a.sex  );


    student_test *p={ 20,80,'m'}; //结构体使用

            printf("年龄:%d 分数:%.2f 性别:%c\n", p->age, p->score, p->sex  );

    student_test *p; //结构体使用,定义指针变量

    p->age = 20; //结构体成员变量采用 -> 连接,因为定义为指针类型结构体

    p->score = 80;

    p->sex = 'm';

    printf("年龄:%d 分数:%.2f 性别:%c\n", p->age, p->score, p->sex  );


    return 0;

    }



    2、数组

    链接:

    http://c.biancheng.net/cpp/html/50.html

    http://blog.csdn.net/mcgrady_tracy/article/details/7529892

    一维数组的定义方式

    在C语言中使用数组必须先进行定义。一维数组的定义方式为:
        类型说明符 数组名 [常量表达式];
    其中,类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义的数组标识符。方括号中的常量表达式表示数据元素的个数,也称为数组的长度。例如:
    1. int a[10]; /* 说明整型数组a,有10个元素 */
    2. float b[10], c[20]; /* 说明实型数组b,有10个元素,实型数组c,有20个元素 */
    3. char ch[20]; /* 说明字符数组ch,有20个元素 */

    数组元素通常也称为下标变量。必须先定义数组,才能使用下标变量。在C语言中只能逐个地使用下标变量,而不能一次引用整个数组。例如,输出有10个元素的数组必须使用循环语句逐个输出各下标变量:

    1. for(i=0; i<10; i++)
    2. printf("%d",a[i]);
    而不能用一个语句输出整个数组。因此,下面的写法是错误的:
    1. printf("%d",a);

    二、 二维数组

    1. 二维数组定义

    int a[6][10];

    这样我们便定义了一个二维数组,这个数组是一个包含60个元素的矩阵,有6行10列。如何去看待一个二维数组,可以这样去看,先将a看成一个一维的数组,它有6个元素,但是它的每个元素又是一个包含10个元素的数组。

    关于二维数组在内存中的存储形式,例如一个3行6列数组它是这样的:



    2. 二维数组的初始化

    同一维数组一样,可以对数组的所有元素进行初始化同样也可以只对数组的部分元素进行初始化。


    3. 数组元素的访问

    还是数组名加下标的方式,不过下标有两个下标,一个是行下标,另一个是列下标,其它同一维数组没有什么两样。


    3、指针;

    学习链接

    http://c.biancheng.net/cpp/html/71.html

    http://blog.csdn.net/jacy_y/article/details/6960629

    C语言指针的概念:

    指针(pointer):是一个变量的地址。

    指针变量:是一个变量,其值是另一个变量的地址。


    计算机中所有的数据都必须放在内存中,不同类型的数据占用的字节数不一样,例如 int 占用4个字节,char 占用1个字节。为了正确地访问这些数据,必须为每个字节都编上号码,就像门牌号、身份证号一样,每个字节的编号是唯一的,根据编号可以准确地找到某个字节。
    下图是 4G 内存中每个字节的编号(以十六进制表示):


    我们将内存中字节的编号称为地址(Address)指针(Pointer)。地址从 0 开始依次增加,对于 32 位环境,程序能够使用的内存为 4GB,最小的地址为 0,最大的地址为 0XFFFFFFFF。


    一切都是地址:

    C语言用变量来存储数据,用函数来定义一段可以重复使用的代码,它们最终都要放到内存中才能供 CPU 使用。

    数据和代码都以二进制的形式存储在内存中,计算机无法从格式上区分某块内存到底存储的是数据还是代码。当程序被加载到内存后,操作系统会给不同的内存块指定不同的权限,拥有读取和执行权限的内存块就是代码,而拥有读取和写入权限(也可能只有读取权限)的内存块就是数据。

    CPU 只能通过地址来取得内存中的代码和数据,程序在执行过程中会告知 CPU 要执行的代码以及要读写的数据的地址。如果程序不小心出错,或者开发者有意为之,在 CPU 要写入数据时给它一个代码区域的地址,就会发生内存访问错误。这种内存访问错误会被硬件和操作系统拦截,强制程序崩溃,程序员没有挽救的机会。

    CPU 访问内存时需要的是地址,而不是变量名和函数名!变量名和函数名只是地址的一种助记符,当源文件被编译和链接成可执行程序后,它们都会被替换成地址。编译和链接过程的一项重要任务就是找到这些名称所对应的地址。


    变量名和函数名为我们提供了方便,让我们在编写代码的过程中可以使用易于阅读和理解的英文字符串,不用直接面对二进制地址,那场景简直让人崩溃。

    需要注意的是,虽然变量名、函数名、字符串名和数组名在本质上是一样的,它们都是地址的助记符,但在编写代码的过程中,我们认为变量名表示的是数据本身,而函数名、字符串名和数组名表示的是代码块或数据块的首地址。





    展开全文
  • c语言结构体数组指针

    千次阅读 2013-03-16 23:10:45
    今晚写了一个结构体指针的代码,出现了好多问题,经过同学的一步一步分析,终于出结果了。 出现的第一个问题是scanf(“%ld,%d\n”),一旦加了\n,将会直接导致输入出现问题 在一个问题就是char name[20],在...

    #include<stdio.h>
    #define N  3
    struct student
    {
      long int num;
      char name[20];
      float score[3];
       float aver;
    };
    int main()
    {
       void Input(struct student stu[]);
       struct student max(struct student stu[]);
       void print(struct student stud);
       struct student stu[N],*p=stu;
       Input(p);
       print(max(p));
       return 0;
    }
    void Input(struct student stu[])
    {
    int i;
    for(i=0;i<N;i++)
     {
     printf("输入第 %d  个学生的信息\n依次输入学号,姓名,三门课的成绩\n",i+1);
     scanf("%ld%s%f%f%f",&stu[i].num,stu[i].name,&stu[i].score[0],&stu[i].score[1],&stu[i].score[2]);
     stu[i].aver=(stu[i].score[0]+stu[i].score[1]+stu[i].score[2])/3.0;
     }
    }
    struct student max(struct student stu[])
    {
    int i,m=0;
    for(i=1;i<N;i++)
     if(stu[i].aver>stu[m].aver)
      m=i;
      return stu[m];
    }
    void print(struct student stud)
    {
    printf("成绩最高学生的信息\n");
    printf("%ld,%s,%.2f,%.2f,%.2f,%.2f\n",stud.num,stud.name,stud.score[0],stud.score[1],stud.score[2],stud.aver);
    }
    


    
    今晚写了一个结构体指针的代码,出现了好多问题,经过同学的一步一步分析,终于出结果了。
    

    出现的第一个问题是scanf(“%ld,%d\n”),一旦加了\n,将会直接导致输入出现问题

    在一个问题就是char name[20],在输入时,不能加&(取地址符)


    展开全文
  • C语言结构体数组指针的动态分配

    千次阅读 2020-03-03 23:44:28
    刚开始,由于485设备的种类并不是很多,而且主机的每个485口下挂的设备数目,也不是很多,因此采用了静态结构体数组的方式来做设备属性和数值的缓存(Shadow)。但是目前485种类是越来越多,而且规定每个485口下,...

    目前有在开发一个linux的底层驱动,涉及到很多种Modbus设备。程序是通过解析json配置文件,来获知到底是访问的什么设备。刚开始,由于485设备的种类并不是很多,而且主机的每个485口下挂的设备数目,也不是很多,因此采用了静态结构体数组的方式来做设备属性和数值的缓存(Shadow)。但是目前485种类是越来越多,而且规定每个485口下,最多可以挂64个设备,如果全部用静态数组的形式,则够主机的RAM喝一壶的。。

    例如单是一种VRV外机的P板,一个485口最多可以挂64个P板,每个P板可以带64台内机,每台内机,可能有十几个属性。假定是12个属性(每个属性占2字节),12*2*64*64 = 98KB了。这种消耗太大了。

    于是,我们换一种方法,就是采用动态分配的方式。当程序解析出具体的设备类型后,在通过malloc函数,动态申请一块内存,供设备属性和数值的缓存使用。代码如下:

    int main(void)
    {
    	void *pDevShadow; //刚开始并不知道是何种设备,因此使用void类型定义
    
    	//.........
    	//伪代码,假如判断出设备是JM_DEWPOINT1类型
    	//申请64个设备的RAM空间
    	pDevShadow = (STRUCT_JM_DEWPOINT1 *)malloc(sizeof(STRUCT_JM_DEWPOINT1[64]));
    	//如果申请失败,则返回或则进行错误处理
    	if(pDevShadow == NULL)return 0;
    
    	printf("p Addr 0x%X, p+1 Addr 0x%X, P+sizeof Addr 0x%X\r\n", pDevShadow, pDevShadow+1, pDevShadow+sizeof(STRUCT_JM_DEWPOINT1));
    	printf("sizeof pDevShadow is %d bytes\r\n", sizeof(STRUCT_JM_DEWPOINT1[64]));
    	
    	//额外定义一个结构体指针,这样比较好操作。
    	STRUCT_JM_DEWPOINT1 *pDewpoint;
    	pDewpoint = pDevShadow;
    	printf("pDew Addr is 0x%X, pDev+1 Addr is 0x%X\r\n", pDewpoint, pDewpoint+1);
    	pDewpoint->Version = 0x02;
    	pDewpoint->PowerRecover = 1;
    	
    	free(pDevShadow);
    	pDevShadow = NULL;
    }

    代码里,我加了一些测试,就是想看下,各个指针是否指向了正确的地址。我们来看一下。

    p Addr 0x81008, p+1 Addr 0x81009, P+sizeof Addr 0x81038
    sizeof pDevShadow is 3072 bytes
    pDew Addr is 0x81008, pDev+1 Addr is 0x81038

    这里我们看到,pDevShadow, pDevShadow+1的地址,就相差一个字节,因此可以得出,当访问完第一个结构体,想要访问第二个结构体是,是不能使用p+1这种方式的,而是应该使用pDevShadow+sizeof(STRUCT_JM_DEWPOINT1)这个地址。

    但是每次使用pDevShadow+sizeof(STRUCT_JM_DEWPOINT1)会显得很繁琐,因此额外定义一个相应设备的结构体指针,则就会显得方便很多。结构体数组操作起来会很方便。。另外还有个好处就是,写代码的时候,自动补全的功能也能用起来。

    PS:以上其实是C语言的一些基本语法问题。之所以写这篇文章,是因为今天白天,我不小心就是拿p+1当做是第二个结构体来操作了,然后就遇到了Linux直接跳Bus Error。参考了以下的文章后,我就猜是指针地址不对。。。于是回家再测试了下代码,发现确实是地址不对。。

    https://blog.csdn.net/cjsycyl/article/details/14000621

    展开全文
  • 结构体是一种集合,它里面包含了多个变量或数组,它们的类型可以相同,也可以不同,每个这样的变量或数组都称为结构体的成员(Member)。请看下面的一个例子: struct stu{ char name[]; //姓...

    1.结构体的定义与使用

    • 结构体是一种构造数据类型
    • 把不同类型的数据组合成一个整体

    结构体的定义形式:

    struct 结构体名{
        结构体所包含的变量或数组
    };

    结构体是一种集合,它里面包含了多个变量或数组,它们的类型可以相同,也可以不同,每个这样的变量或数组都称为结构体的成员(Member)。请看下面的一个例子:

    struct stu{
        char name[];  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在学习小组
        float score;  //成绩
    };

    注意:大括号后面的分号;不能少,这是一条完整的语句。

    stu 为结构体名,它包含了 5 个成员,分别是 name、num、age、group、score。结构体成员的定义方式与变量和数组的定义方式相同,只是不能初始化

    结构体也是一种数据类型,它由程序员自己定义,可以包含多个其他类型的数据。
    像 int、float、char 等是由C语言本身提供的数据类型,不能再进行分拆,我们称之为基本数据类型;而结构体可以包含多个基本类型的数据,也可以包含其他的结构体,我们将它称为复杂数据类型或构造数据类型。

    • 先定义结构体类型,再定义结构体变量
     struct   student 
    {       
     int num;
     char  name[20];
     char sex;
     int age; 
     float score;
     char addr[30];
     };
     struct student stu1,stu2;         
    • 定义结构体类型的同时定义结构体变量
     struct   data
     {      
      int day int month;
      int year
     }time1,time2; 
    • 直接定义结构体变量
     struct 
    {
     char name[20];
     char sex; 
     int num; 
     float score[3]
     }person1,person2; 

    2.结构体变量的初始化

    和其它类型变量一样,对结构体变量可以在定义时指定初始值。

    #include <stdio.h>
     
    struct Books
    {
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    } book = {"C 语言", "RUNOOB", "编程语言", 123456};
     
    int main()
    {
        printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
    }

    输出结果:

    title : C 语言
    author: RUNOOB
    subject: 编程语言
    book_id: 123456

    3.访问结构成员

    为了访问结构的成员,我们使用成员访问运算符(.)

    引用形式:<结构体类型变量名>.<成员名>

    注意:结构体变量不能整体引用,只能引用变量成员

    成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法:

    #include <stdio.h>
    int main(){
        struct{
            char *name;  //姓名
            int num;  //学号
            int age;  //年龄
            char group;  //所在小组
            float score;  //成绩
        } stu1;
    
        //给结构体成员赋值
        stu1.name = "Tom";
        stu1.num = 12;
        stu1.age = 18;
        stu1.group = 'A';
        stu1.score = 136.5;
    
        //读取结构体成员的值
        printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", stu1.name, stu1.num, stu1.age, stu1.group, stu1.score);
    
        return 0;
    }

    运行结果:
    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!

    除了可以对成员进行逐一赋值,也可以在定义时整体赋值,例如: 

    struct{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    } stu1, stu2 = { "Tom", 12, 18, 'A', 136.5 };

    不过整体赋值仅限于定义结构体变量的时候,在使用过程中只能对成员逐一赋值,这和数组的赋值非常类似。

    需要注意的是,结构体是一种自定义的数据类型,是创建变量的模板,不占用内存空间;结构体变量才包含了实实在在的数据,需要内存空间来存储。

    4.结构作为函数参数

    可以把结构作为函数参数,传参方式与其他类型的变量或指针类似。例如:

    #include <stdio.h>
    #include<string.h>
    
    struct Books
    {
    	char title[50];
    	char author[50];
    	char subject[100];
    	int book_id;
    };
    
    void printBook(struct Books book);//函数声明
    
    int main()
    {
    	struct Books Book1;//声明Book1,类型为Books
    	struct Books Book2;
    
    	/* Book1 详述 */
    	strcpy(Book1.title, "C Programming");
    	strcpy(Book1.author, "Nuha Ali");
    	strcpy(Book1.subject, "C Programming Tutorial");
    	Book1.book_id = 6495407;
    	printBook(Book1);
    	return 0;
    }
    void printBook(struct Books book)
    {
    	printf("Book title:%s\n", book.title);
    	printf("Book author:%s\n", book.author);
    	printf("Book subject:%s\n", book.subject);
    	printf("Book book_id:%d\n", book.book_id);
    }

    运行结果:

    Book title:C Programming
    Book author:Nuha Ali
    Book subject:C Programming Tutorial
    Book book_id:6495407

    5.结构体数组

    所谓结构体数组,是指数组中的每个元素都是一个结构体。在实际应用中,结构体数组常被用来表示一个拥有相同数据结构的群体,比如一个班的学生、一个车间的职工等。

    定义结构体数组和定义结构体变量的方式类似,请看下面的例子:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[5];
    //表示一个班有5个人

    结构体数组在定义的同时也可以初始化,例如:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[5] = {
        {"Li ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"He fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    };

    当对数组中全部元素赋值时,也可以不给出数组长度,如:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[] = {
        {"Li ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"He fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    };

    结构体数组的使用也很简单。例如,计算全班学生的总成绩、平均成绩和140分一下的人数:

    #include <stdio.h>
    
    struct{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    }class[] = {
        {"Li ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"He fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    };
    
    int main(){
        int i, num_140 = 0;
        float sum = 0;
        for(i=0; i<5; i++){
            sum += class[i].score;
            if(class[i].score < 140) num_140++;
        }
        printf("sum=%.2f\naverage=%.2f\nnum_140=%d\n", sum, sum/5, num_140);
        return 0;
    }

    运行结果:

    sum=707.50
    average=141.50
    num_140=2

    6.指向结构的指针

    可以定义指向结构的指针,方式与定义指向奇特类型变量的指针类似,

    定义形式:struct 结构体名 *结构体指针名;

    struct Books *struct_pointer;

    定义之后可以在上述定义的指针变量中存储结构变量的地址。例:

    struct_pointer = &Book1;

    为了使用指向该结构的指针访问结构的成员,必须使用->运算符,如下所示:

    struct_pointer->title;

    定义结构体指针的实例:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    } stu1 = { "Tom", 12, 18, 'A', 136.5 };
    //结构体指针
    struct stu *pstu = &stu1;

    也可以在定义结构体的同时定义结构体指针:

    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;

    注意:结构体变量名和数组名不同,数组名在表达式中会被转换为数组指针,而结构体变量名不会,无论在任何表达式中它表示的都是整个集合本身,要想取得结构体变量的地址,必须在前面加&符号,所以给p赋值只能写成

    struct stu *p=&stu1;

    而不能写成:

    struct stu *p=stu1;

    注意:结构体和结构体变量是两个不同的概念:结构体是一种数据类型,是一种创建变量的模板,编译器不会为它分配内存空间,就像 int、float、char 这些关键字本身不占用内存一样;结构体变量才包含实实在在的数据,才需要内存来存储。下面的写法是错误的,不可能去取一个结构体名的地址,也不能将它赋值给其他变量:

    struct stu *pstu = &stu;
    struct stu *p=stu;

    7.获取结构体成员

    通过结构体指针可以获取结构体成员,一般形式为:

    (*pointer).memberName

    或者:

    pointer->memberName

    第一种写法中,.的优先级高于*,(*pointer)两边的括号不能少,如果去掉括号写成*pointer.memberName,那么就等效于*(pointer.memberName),这样意义就不对了。

    第二种写法中,->是一个新的运算符,习惯称它为“箭头”,有了它,可以通过结构体指针直接取得结构体成员,这也是->在C语言中的唯一用途。

    上面两种写法是等效的,我们通常采用第二种写法,这样更加直观。

    实例:结构体指针的使用

    #include <stdio.h>
    int main(){
        struct{
            char *name;  //姓名
            int num;  //学号
            int age;  //年龄
            char group;  //所在小组
            float score;  //成绩
        } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;
    
        //读取结构体成员的值
        printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", (*pstu).name, (*pstu).num, (*pstu).age, (*pstu).group, (*pstu).score);
        printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", pstu->name, pstu->num, pstu->age, pstu->group, pstu->score);
    
        return 0;
    }

    运行结果:

    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!
    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!

    示例:结构体数组指针的使用

    #include <stdio.h>
    
    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    }stus[] = {
        {"Zhou ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"Liu fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    }, *ps;
    
    int main(){
        //求数组长度
        int len = sizeof(stus) / sizeof(struct stu);
        printf("Name\t\tNum\tAge\tGroup\tScore\t\n");
        for(ps=stus; ps<stus+len; ps++){
            printf("%s\t%d\t%d\t%c\t%.1f\n", ps->name, ps->num, ps->age, ps->group, ps->score);
        }
    
        return 0;
    }

    运行结果:

    Name            Num     Age     Group   Score
    Zhou ping       5       18      C       145.0
    Zhang ping      4       19      A       130.5
    Liu fang        1       18      A       148.5
    Cheng ling      2       17      F       139.0
    Wang ming       3       17      B       144.5

    参考资料:

    C语言结构体和指针

    C语言结构体数组

    C结构体

    展开全文
  • C语言结构体数组+结构体类型指针+指向结构体数组的指针+typedef类型结构体数组两种结构体数组的定义形式用sizeof运算符求结构体数组所占字节数结构体类型指针指向结构体数组的指针typedef类型 结构体数组 如果要处理...
  • #include<stdio.h> struct student { char studentName[10]; int studentID; float Chinese; float Math; float English; float PE; };...求大神帮忙看看,感激不尽
  • C语言--结构体数组和结构体指针

    万次阅读 多人点赞 2018-08-16 21:06:49
    1.结构体数组 具有相同结构体类型的变量构成的数组,称为结构体数组。与普通数值型数组的不同之处在于每个数组元素都是一个结构体变量,它们都分别包含各个成员项。 定义结构体数组一般形式是 struct 结构体名 { ...
  • 怎么实现一个函数里给结构体数组分配内存以及赋值,在另一个函数里使用这个结构体数组结构体数组大小是变长的。 求大神赐教!
  • 结构体数组 所谓结构体数组就是数组里每个元素都是一个结构体。 定义一个结构体数组和定义结构体变量的方式差不多: struct stu{ char*name; int age; char group; int num; float score; }class[5]; 结构体...
  • C语言——结构体数组和结构体指针

    千次阅读 2019-02-22 20:35:02
    一、结构体数组 第一种方法是在声明结构体的时候进行定义: struct 结构体名称 { 结构体成员; }数组名[长度] 第二种方法是先声明一个结构体类型,再用此类型定义一个结构体数组: struct 结构体名称 { ...
  • 一、结构体、结构体数组、结构体指针的定义和初始化
  • 结构体数组的定义格式: struct 结构体名 结构体变量[元素大小]; 例: struct myinfo a[10]; 结构体指针的定义格式: struct 结构体名 *指针名; 例: struct myinfo *p; 结构体指针用于存储结构体变量的地址; 例: ...
  • 当结构体指针变量指向一个结构体变量数组的时候,此时指针变量的值就是结构体数组的首地址 关于如何定义结构体数组,和将结构体指针指向结构体变量数组,不是重点。 重点是,明白结构体指针的是怎么移动的, 我个人...
  • 数组指针是一个指针,该指针指向的是一个数组; 定义: int (*p)[size] //数组指针,存储size个int类型的数据 指针函数与函数指针 指针函数 指针函数是一个函数,该函数返回的是一个指针; 函数指针 函数指针是一个...
  • C语言结构体数组实例

    千次阅读 2019-08-23 20:15:34
    结构体数组 + 结构体成员是函数指针; 可以根据需求自己判断,并调用相应的函数,实现想要的功能。 比如:根据不同的名字的判断,去告诉我想要对每个人说的话。 #include <stdio.h> //函数声明 int zhao_f...
  • 第一次写博客,有点小激动。话不多说,进入正题。 c语言最常见的几种东西:结构体,数组,指针和函数。单个定义很好理解,组合在一起就会让人头大。先说函数、数组和指针的...1.1 数组指针 ...
  • 一、结构体指针 与一般指针类似结构体也可以使用结构体指针进行引用使用。结构体指针的定义方式如下: struct Student stu = { 1001,"Li Lei",'M',1.87 }; //定义一个Student 的结构体变量stu struct Student *p...
  • //用结构体数组指针完成:有三个学生信息,存放在结构体数组中,要求输出全部信息 #include struct Stu { int num; char name[20]; char sex; int age; }; int main() { struct Stu student[3]={{317,"han",'m'...
  • 一:结构体指针 指向结构体变量的指针,称为结构体指针 Stu stu1={0}; Stu *p=&stu1; 这里Stu*:表示结构体指针类型(类型) p:表示结构体指针变量(变量名) &stu1:表示结构体变量地址...二:结构体数组指针的关系
  • 前话:时隔半年的博客,哎,大二课太多了,没办法,这不最近结了几门课,有点空闲时间,正愁写点什么好,恰巧翻到了...那么问题来了,是使用链表还是结构体数组呢?对当时的我来说没得选,因为学的太菜(狗头保命),

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,570
精华内容 1,028
关键字:

c语言结构体数组指针

c语言 订阅