精华内容
下载资源
问答
  • C语言结构体数组初始化 一、使用场景 在C编码中,经常需要对结构体数组进行初始化。 使用这种方法,能够使得代码更加的清晰,易读。 例如:需要根据返回码,一个status code 做不同的操作。 int process_by_status...

    C语言结构体数组初始化

    一、使用场景

    1. 在C编码中,经常需要对结构体数组进行初始化。

      使用这种方法,能够使得代码更加的清晰,易读。

      例如:需要根据返回码,一个status code 做不同的操作。

      int process_by_status_code(int status_code)
      {
          if(status_code == 180)
          {
              //do process 1
          }
          else if(status_code == 183)
          {
              //do process 2
          }
          else if(status_code == 200)
          {
              //do process 3
          }
          //........此处省略100中情况。
          return 0;
      }
      

      需要注意,使用这种方式编码,随着要处理的情况不断增多,函数必然会越来越大。而且根据《unix编程艺术》中说的,人类大脑更加的善于处理数据,而不是逻辑。

      因此可能可以换一种写法:

      typedef struct int (*status_code_process_callback)(void *param);
      typedef struct status_code_process_map
      {
          int status_code;
          status_code_process_callback fn_process;
      }status_code_process_map;
      
      status_code_process_map g_status_code_process_map_list[]=
      {
          {180,process_180},
          {183,process_183},
          {200,process_200},
          //.....此处省略N中情况。
      };
      
      int process_180(void *param)
      {
          //do 180 process
          return 0;
      }
      int process_183(void *param)
      {
          //do 183 process
          return 0;
      }
      
      
      int process_by_status_code(int status_code)
      {
          int i = 0;
          for(i = 0; i < sizeof(g_status_code_process_map_list)/sizeof(g_status_code_process_map_list[0]); i++)
          {
              if(g_status_code_process_map_list[i].fn_process)
              {
                  return g_status_code_process_map_list[i].fn_process(&status_code);
              }
          }
          return 0;
      }
      

      这样写,别人看代码,就很容易看到:

    从而更快速理解其中的隐藏逻辑。阅读代码效率更高。

    二、问题和解决

    1. 如果在映射表中需要添加参数,怎么办?

      typedef struct int (*status_code_process_callback)(void *param);
      typedef struct status_code_process_map
      {
          int status_code;
          void *param;//需要添加一个参数。
          status_code_process_callback fn_process;
      }status_code_process_map;
      
      

      那,初始化就不合理了。

      对于可能变化成员,或者变化成员顺序的初始化,需要使用这种方法:

      status_code_process_map g_status_code_process_map_list[]=
      {
          {
              .status_code = 180,
              .fn_process = process_180
          },
          {
              .status_code = 183,
              .fn_process = process_183//可以部分初始化
          },
          {
              .status_code = 200,
              .param = NULL,
              .fn_process = process_200
          }
          //.....此处省略N中情况。
      };
      
      

      使用这种方法,可以对抗成员的添加或者顺序变化。

    2. 如果某些行不想被初始化,或者不需要被初始化。或者希望提升访问的效率。怎么办?

      status_code_process_map g_status_code_process_map_list[]=
      {
          {180,process_180},
          {183,process_183},//这一行,我认为不需要出现在这里 ,但是又希望其空间是被分配的
          {200,process_200},
          //.....此处省略N中情况。
      };
      
      //这里只能使用status_code进行查找。能否直接调用呢?
      int process_by_status_code(int status_code)
      {
          int i = 0;
          for(i = 0; i < sizeof(g_status_code_process_map_list)/sizeof(g_status_code_process_map_list[0]); i++)
          {
              if(g_status_code_process_map_list[i].fn_process)
              {
                  return g_status_code_process_map_list[i].fn_process(&status_code);
              }
          }
          return 0;
      }
      

      可以使用枚举:

      enum
      {
        E_STATUS_180,
        E_STATUS_183,
        E_STATUS_200,
        //此处省略N种情况
      };
      
      status_code_process_map g_status_code_process_map_list[]=
      {
          [E_STATUS_180]{180,process_180},
          [E_STATUS_183]{183,process_183},//这一行,我认为不需要出现在这里 ,但是又希望其空间是被分配的
          [E_STATUS_200]{200,process_200},
          //.....此处省略N中情况。
      };
      

      使用这种写法,可以省略掉183的初始化,也可以使用g_status_code_process_map_list[E_STATUS_200] 直接访问对应的情况。

    三、参考

    1. 《Unix编程艺术》
    2. https://www.cnblogs.com/hansjorn/p/4693840.html
    展开全文
  • Java调用C语言动态库(JNA方式):回调函数、结构体数组传参、结构体数组返回-附件资源
  • 题目:学生记录由学号和成绩组成,N名学生的数据已放入主函数中的结构体数组中,请 编写函数fun,其功能是:把分数最低的学生数据放入b所指的数组中,注意:分数 最低的学生可能不止一个,函数返回分数最低的学生...

    题目:学生记录由学号和成绩组成,N名学生的数据已放入主函数中的结构体数组中,请编写函数fun,其功能是:把分数最低的学生数据放入b所指的数组中,注意:分数最低的学生可能不止一个,函数返回分数最低的学生人数。
    编译环境:VS2010

    #include<stdio.h>
    #define N 16
    typedef struct
    {
    	char num[10];
    	int s;
    }STREC;
    int fun(STREC *a, STREC *b)
    {
     /******begin******/
    
    /******end******/
    }
    void main()
    {
       STEREC s[N] = {{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
                   {"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
                   {"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
                   {"GA011",91},{"GA017",64},{"GA018",64},{"GA016",72}};
                    STREC  h[N];
           int  i,n;
           n=fun( s,h );
           printf("The %d lowest score :\n",n);
           for(i=0;i<n; i++)
                   printf("%s  %4d\n",h[i].num,h[i].s);
           printf("\n");
    }
    

    答案与解析

    1.结构体成员名访问+数组指针

    int i, j = 0,min = a[0].s;
    for(i = 0;i < N;i++)
    	if(min > a[i].s)
    		min = a[i].s;
    for(i = 0;i < N;i++)
    	if(min == a[i].s)
    		b[j++] == a[i];
    return j;
    

    2.通过指针访问结构体成员

     STREC *p = a;
     int min = p -> s;
     int i, cnt = 0;
     for(i = 0;i < N;i++)
     {    
        if(min > p -> s) min = p -> s;
        p++;
     }
      for(i = 0;i < N;i++)
     {
          if(a -> s == min)
         { 
    	 *b = *a;
    	  b++;
    	  cnt++;    
         } 
         a++;
     }
    return cnt;
    

    PS:此处输入数据时易误写成while(p !=NULL)但是请注意只有链表才能用此类写法,而本题只是一个结构体数组。

    展开全文
  • 指针数组 指针数组是一个数组数组的元素保存的是指针;...指针函数是一个函数,该函数返回的是一个指针; 函数指针 函数指针是一个指针,该指针指向一个函数; #include <stdio.h> int* getIntPoint(cons

    指针数组

    指针数组是一个数组,数组的元素保存的是指针;
    定义:
    int *p[size] //表示数组存的是指针,有size个指针数据

    数组指针

    数组指针是一个指针,该指针指向的是一个数组;
    定义:

    int (*p)[size] //数组指针,存储size个int类型的数据

    指针函数与函数指针

    指针函数

    指针函数是一个函数,该函数返回的是一个指针;

    函数指针

    函数指针是一个指针,该指针指向一个函数;

    #include <stdio.h>
     
    int* getIntPoint(const int a) //指针函数,是一个函数 返回一个指针;
    {
    	int *p = nullptr ;
    	p = new int ;
    	*p = a; 
     	return p ;
    }
     
     
    int main(int argc, char const *argv[])
    {
    	int *(*p)(int)  = getIntPoint ; //函数指针,该指针指向一个函数;
    	int* pInt = p(5); //使用函数指针;
    	printf("%d\n",*pInt);
    	delete pInt ;
    	return 0;
    }
    
    #include <stdio.h>
    void print();
    int main(void)
    {
    	void (*fuc)(); 
    	fuc = print ; 
    	fuc(); 	
    } 
    void print()
    {
    	printf("hello world!\n");
    }
    

    回调函数

    函数指针变量可以作为某个函数的参数来使用的,回调函数就是一个通过函数指针调用的函数。

    #include <stdlib.h>  
    #include <stdio.h>
     
    // 回调函数
    void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
    {
        for (size_t i=0; i<arraySize; i++)
            array[i] = getNextValue();
    }
     
    // 获取随机值
    int getNextRandomValue(void)
    {
        return rand();
    }
     
    int main(void)
    {
        int myarray[10];
        populate_array(myarray, 10, getNextRandomValue);
        for(int i = 0; i < 10; i++) {
            printf("%d ", myarray[i]);
        }
        printf("\n");
        return 0;
    }
    

    结构体数组

    数组中存储的元素都是一个结构体,类似整型数组中存储的是int型。
    申明结构体数组:
    结构体名 数组名【size】

    结构体指针

    指向结构体的指针。
    结构指针变量说明的一般形式为:

    struct 结构体名 *结构体指针变量名
    struct student *p = &Boy; //假设事先定义了 struct student Boy;

    #include<stdio.h>
    #include<string.h>
    #include<malloc.h>
    
    typedef struct Errlog
    {
    	char str_file[1000];
    	int num;
    	int err;
    }errlog;
    
    int main(void)
    {
    	errlog err1[3];//结构体数组
    	errlog *err2;//结构体指针
    	errlog *err3[3];//结构体指针数组,表示数组存的是指针,有3个指针数据
    	errlog (*err4)[3];//结构体数组指针,是一个指针,该指针指向的是一个数组,该数组存储3个errlog类型的数据
    
    }
    
    

    理解:结构体数组指针就是一个指针,感觉没有实际意义,可用普通指针代替。

    展开全文
  • 当接口函数的参数为结构体数组,并且结构体成员也为结构体数组时,调用方法: dll接口函数 类型 ,结构体类型 : typedef unsigned int UINT; typedef struct code_word { char Feild[ 8 ]; BOOL ...

    一、开发环境


    系统、开发环境:win7、eclipse 32位、jdk 32位、jre 32位

            由于这里使用的dll文件是32位的,而我本身的环境是64位的,包括eclipse、jdk、jre都是64位,所以这里需要开发环境共存(32位、64位共存),如果本来就是32位环境就不用重新搭建环境了。从以下连接分别下载32位软件:

    1.eclipse,不用安装,解压后即可使用,解压目录:D:\eclipse

    Eclipse IDE for Java EE Developers,   247 MB        Windows 32 Bit

    http://www.eclipse.org/downloads


    2.jdk 32位,安装目录:D:\Program Files\java\jdk32

    Windows x86 123.49MB       jdk-7u45-windows-i586.exe

    http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html


    3.jre 32位,安装目录:D:\Program Files\java\jre32

    Windows Offline(32-bit)     fileSize:   27.7MB

    http://www.java.com/en/download/manual.jsp


            要让32位和64位eclipse共存,需要修改eclipse目录下的文件:eclipse.ini
    在原环境变量(JAVA_HOME指向64位目录)不改变的情况下在上面文件内增加两行:
    -vm
    D:\Program Files\java\jdk32\bin\javaw.exe
    以上的作用使32位eclipse指向32位jdk。

    4.JNA下载,这里是放在百度云里面的,下载两个文件:jna-3.5.1.jar、platform-3.5.1.jar,放到目录:D:\Program Files\java\JNA_3.5.1
    http://pan.baidu.com/s/1iWobp

    至于JNA是什么,它本身是基于JNI技术的,然后进行封装以方便dll调用。这里不再详述,网上很多。


    二、调用方法


    1.简单函数调用

            关于jar包导入就不提了,创建工程:DemoTools,这里使用的dll是:libSDK.dll,把该文件放到工程目录下。
    dll提供的接口函数:
    int System_Init (int version, char* encoding);

    java代码->声明部分:
    1. import com.sun.jna.Library;
    2. import com.sun.jna.Native;
    3. public class getSDK {
    4. public interface Function extends Library {
    5. Function instanceDll = (Function)Native.loadLibrary("libSDK.dll",Function.class);
    6. public int System_Init(int version, String encoding);
    7. }
    8. }

    java代码->调用部分:

    result = getSDK.Function.instanceDll.System_Init(1, "");

    参数类型比较简单时,调用也比较容易。

    2.回调函数调用

    当dll的接口函数需要回调函数作为参数时,使用以下方法实现:
    dll接口函数及回调函数类型:

    1. typedef void (*Callback_Status)(char *station_id, char *station_ip, int status);
    2. int Start_Server(char *ip, int port, Callback_Status fun);

    java代码->回调函数声明:
    1. import com.sun.jna.win32.StdCallLibrary.StdCallCallback;
    2. public class getSDK {
    3. public interface Callback_Status extends StdCallCallback {
    4. public void Status(String station_id, String station_ip, int status);
    5. }
    6. }
    java代码->回调函数实现:
    1. public class getSDK {
    2. public static class Status_Realize implements Callback_Status{
    3. public void Status(String station_id, String station_ip, int status) {
    4. if (status == 2) {
    5. GUI.Station_online(station_id, station_ip, 1, 0);
    6. } else if (status == 3) {
    7. GUI.Station_online(station_id, station_ip, 2, 0);
    8. }
    9. }
    10. }

    java代码->dll接口调用:
    1. public static getSDK.Callback_Status callback_status = new getSDK.Status_Realize();
    2. result = getSDK.Function.instanceDll.Start_Server("0.0.0.0", 1234, callback_status);

    3.回调函数含有结构体数组参数

    当回调函数其中一个参数是结构体数组时的处理方法:
    dll接口函数回调函数类型,结构体类型
    1. typedef struct result_data {
    2. char Station_id[3];
    3. char Label_id[7];
    4. int Signal;
    5. int Power;
    6. int Status;
    7. }Tstatus, *PTstatus;
    8. typedef void (*Callback_Data)(char *station_id, char *station_ip, Tstatus ret_data[], int count);
    9. int Start_Server (char *server_ip, int listen_port, Callback_Status callback_status, Callback_Data callback_data);
    java代码->回调函数、结构体定义:
    1. import com.sun.jna.Structure;
    2. public class getSDK {
    3. public interface Function extends Library {
    4. public static class Tstatus extends Structure {
    5. public byte[] Station_id = new byte[3];
    6. public byte[] Label_id = new byte[7];
    7. public int Signal;
    8. public int Power;
    9. public int Status;
    10. public static class ByReference extends Tstatus implements
    11. Structure.ByReference {}
    12. public static class ByValue extends Tstatus implements
    13. Structure.ByValue {}
    14. @SuppressWarnings({ "rawtypes", "unchecked" })
    15. @Override
    16. protected List getFieldOrder() {
    17. List a = new ArrayList();
    18. a.add("Station_id");
    19. a.add("Label_id");
    20. a.add("Signal");
    21. a.add("Power");
    22. a.add("Status");
    23. return a;
    24. }
    25. }
    26. public int Start_Server(String server_ip, int port, getSDK.Callback_Status Callback_Status,getSDK.Callback_Data Callback_Data);
    27. }
    28. public interface Callback_Data extends StdCallCallback {
    29. public void Data(String station_id, String station_ip, Pointer data, int count);
    30. }
    31. }

    java代码->回调函数实现:
    1. public class getSDK {
    2. public static class Data_Realize implements Callback_Data{
    3. public void Data(String station_id, String station_ip, Pointer data, int count) {
    4. int srow, frow;
    5. srow = 0;
    6. frow = 0;
    7. for (int i = 0; i < count; i++) {
    8. byte[] stationbuf = new byte[2];
    9. byte[] labelbuf = new byte[6];
    10. int[] signal = new int[1];
    11. int[] power = new int[1];
    12. int[] status = new int[1];
    13. data.read(0 + i * 24, stationbuf, 0, 2);
    14. data.read(3 + i * 24, labelbuf, 0, 6);
    15. data.read(12 + i * 24, signal, 0, 1);
    16. data.read(16 + i * 24, power, 0, 1);
    17. data.read(20 + i * 24, status, 0, 1);
    18. String labelID = new String(labelbuf);
    19. String stationID = new String(stationbuf);
    20. GUI.message.append(String.valueOf(power[0]));
    21. GUI.message.append(String.valueOf(signal[0]));
    22. GUI.message.append(String.valueOf(status[0]));
    23. }
    24. }
    25. }
    26. }

    java代码->接口调用:
    1. public static getSDK.Callback_Status callback_status = new getSDK.Status_Realize();
    2. public static getSDK.Callback_Data callback_data = new getSDK.Data_Realize();
    3. result = getSDK.Function.instanceDll.Start_Server("0.0.0.0", 1234, callback_status, callback_data);

            这里的难点就在处理回调函数的结构体数组参数,参数是从dll传出来的,java里面用指针接收,而获取结构体内部的每个值就需要用读内存的方式读取出来,这里就需要对结构体在内存中的存储方式比较了解才行,因为read函数需要指定:内存起始位置、接收数据数组变量、数组变量的第几个元素、取内存大小,4个参数。
    上面源码中i*24作用是取到结构体数组的第二、第三、、、个元素。也就是这里的结构体占内存大小为24,看下面:
             在32位系统中char占1个字节,int占4个字节,算下来结构体TStatus应该是22个字节,实际上还有一个内存对齐的概念,结构体前两个char数组共10个字节(是连续存储的),而结构体分配内存的大小必须是该结构体中占字节最大类型的倍数,所以应该分配4字节的倍数即12字节,所以前两个char数组实际分配了12个字节,在取数据时,第三个int的偏移量是12,整个结构体的大小为12 + 3*4(三个int变量)= 24字节

    4.接口函数参数为结构体数组

    当接口函数的参数为结构体数组,并且结构体成员也为结构体数组时,调用方法:
    dll接口函数类型,结构体类型
    1. typedef unsigned int UINT;
    2. typedef struct code_word {
    3. char Feild[8];
    4. BOOL Inverse;
    5. UINT Length;
    6. CHAR Payload[255];
    7. }Cword, *pCword;
    8. typedef struct label_data {
    9. char Label_id[7];
    10. UINT Count;
    11. Cword NCword[50];
    12. }Ldata, *pLdata;
    13. int Start_Update (char *station_id, int count, Ldata data[]);

    java代码->结构体定义,接口函数声明:
    1. public class getSDK {
    2. public interface Function extends Library {
    3. public static class Cword extends Structure {
    4. public byte[] Feild = new byte[8];
    5. public boolean Inverse;
    6. public int length;
    7. public byte[] Payload = new byte[255];
    8. public static class ByValue extends Cword implements
    9. Structure.ByValue {}
    10. @SuppressWarnings({ "rawtypes", "unchecked" })
    11. @Override
    12. protected List getFieldOrder() {
    13. List a = new ArrayList();
    14. a.add("Feild");
    15. a.add("X_coord");
    16. a.add("Y_coord");
    17. a.add("Font");
    18. a.add("Inverse");
    19. a.add("length");
    20. a.add("Payload");
    21. return a;
    22. }
    23. }
    24. public static class Ldata extends Structure {
    25. public byte[] Label_id = new byte[7];
    26. public int Count;
    27. public Cword.ByValue[] NCword = new Cword.ByValue[50];
    28. public static class ByReference extends Ldata implements
    29. Structure.ByReference {
    30. }
    31. public static class ByValue extends Ldata implements
    32. Structure.ByValue {
    33. }
    34. @SuppressWarnings({ "rawtypes", "unchecked" })
    35. @Override
    36. protected List getFieldOrder() {
    37. List a = new ArrayList();
    38. a.add("Label_id");
    39. a.add("Patten");
    40. a.add("Count");
    41. a.add("NCword");
    42. return a;
    43. }
    44. }
    45. public int Start_Update(String station_id, int count, Ldata.ByValue[] data);
    46. }
    47. }

    java代码->接口函数调用:
    1. public class GUI {
    2. public static int labelcount = 5;
    3. public static String[] labellist = new String[]{"000834","000835","041908",
    4. "041909","04190A","04190B","04190C","04190D","04190E","04190F","041910",
    5. "041911","041912","041913","041914","041915","041916","041917","041918"};
    6. bsend.addActionListener(new ActionListener() {
    7. public void actionPerformed(ActionEvent e) {
    8. int i;
    9. int result;
    10. getSDK.Function.Ldata.ByValue tdata = new getSDK.Function.Ldata.ByValue();
    11. getSDK.Function.Ldata.ByValue[] data = (getSDK.Function.Ldata.ByValue[])tdata.toArray(labelcount);
    12. for (i = 0; i < labelcount; i++) {
    13. data[i].Label_id = labellist[i].getBytes();
    14. }
    15. for (i = 0; i < labelcount; i++) {
    16. data[i].Count = 4;
    17. }
    18. getSDK.Function.Cword.ByValue cdata = new getSDK.Function.Cword.ByValue();
    19. getSDK.Function.Cword.ByValue[] ctdata = (getSDK.Function.Cword.ByValue[])cdata.toArray(50);
    20. ctdata[0].Feild = "Text".getBytes();
    21. ctdata[0].Inverse = false;
    22. ctdata[0].length = "test".getBytes().length;
    23. ctdata[0].Payload = "test".getBytes();
    24. ctdata[1].Feild = "Text".getBytes();
    25. ctdata[1].Inverse = false;
    26. ctdata[1].length = "hello".getBytes().length;
    27. ctdata[1].Payload = "hello".getBytes();
    28. ctdata[2].Feild = "Text".getBytes();
    29. ctdata[2].Inverse = false;
    30. ctdata[2].length = "单位".getBytes().length;
    31. ctdata[2].Payload = "单位".getBytes();
    32. ctdata[3].Feild = "Text".getBytes();
    33. ctdata[3].Inverse = false;
    34. ctdata[3].length = "规格".getBytes().length;
    35. ctdata[3].Payload = "规格".getBytes();
    36. for (i = 0; i < labelcount; i++) {
    37. data[i].NCword = ctdata;
    38. }
    39. result = getSDK.Function.instanceDll.Start_Update((String)station.getSelectedItem(), labelcount, data);
    40. }
    41. });
    42. }

            这里比较关键的是结构体数据的定义,结构体声明中有两个方法:ByValue 和 ByReference, 分别是值和引用,这里使用ByValue方式创建结构体,然后在通过toArray的方式生成结构体数组,为的是保证定义的数组是内存连续的,如果这里直接用:
    getSDK.Function.Ldata.ByValue[] tdata = new getSDK.Function.Ldata.ByValue[labelcount];
    的方式,得到的内存是不连续的,当你传递这种方式定义的变量给dll时,dll只能取到第一个结构体元素的值,造成数据丢失。
    展开全文
  • 例题:给定程序中,函数fun 的功能是:将形参student所指结构体数组中年龄最小者的数据作为函数值返回,并在main函数中输出。 注意:请勿改动主函数main与其它函数中的任何内容,仅在fun函数的横线上填写所需的若干...
  • 设计程序,学生的记录由学号和成绩组成,N名学生的数据已在主函数中放入结构体数组s中, 请编写函数fun,它的功能是:把指定分数范围内的学生数据放在b所指的数组中,分数范围内的学生人数由函数值返回。例如,输入的...
  • **设计程序,已知学生的记录由学号和学习成绩构成,N名学生的数据已存入a结构体数组中。请编写函数 fun,函数的功能是:找出成绩最低的学生记录,通过形参返回主函数(规定只有一个最低分 ** #include <stdio.h>...
  • N名学生的数据已在主函数中放入结构体数组s中, 请编写函数fun,它的功能是:把高于等于平均分的学生数据放在b所指的数组中,高于等于平均分的学生人数通过形参n传回,平均分通过函数值返回。 ** #include <stdio....
  • 例题:已知学生的记录由学号和学习成绩组成,M名学生的数据已存入stu结构体数组中。请编写函数fun,该函数的功能是:找出成绩最高的学生记录,通过形参返回主函数(规定只有一个最高分)。已给出函数的首部,请完成该...
  • 请编写一个函数void function(char *ss),其功能时:已知学生的记录是由学号和学习成绩构成,n名学生的数据已存入s结构体数组中。请编写函数fun,该函数的功能是:找出成绩最高的学生记录,通过形参返回主函数(规定...
  • C语言函数不可以返回数组却可以返回结构体这是为什么呢 最近有读者问我为什么C语言函数可以返回结构体却不可以返回数组有这样的问题并不奇怪因为C语言数组和结构体本质上都是管理一块内存那为何编译器要区别对待二者...
  • 已知学生的记录由学号和学习成绩构成,M名学生的数据已存入a结构体数组中。请编写函数fun,该函数的功能是:找出成绩最高的学生记录,通过形参返回主函数(规定只有一个最高分)。已给出函数的首部,请完成该函数。 ...
  • 例题:学生的记录由学号和成绩组成,M名学生的数据已在主函数中放入结构体数组score中,请编写函数fun,它的功能是把分数最低的学生数据放在low所指的数组中,注意:分数最低的学生可能不只一个,函数返回分数最低的...
  • 例题:学生的记录由学号和成绩组成,M名学生的数据已在主函数中放入结构体数组stu中,请编写函数fun,它的功能是:函数返回指定学号的学生数据,指定的学号在主函数中输入。若没找到指定学号,在结构体变量中给学号...
  • 例题:学生的记录由学生和成绩组成,M名学生的数据已在主函数中放入结构体数组stu中,请编写函数fun,它的功能是:把分数最高的学生数据放在high所指的数组中,注意:分数最高的学生可能不止一个,函数返回分数最高...
  • C语言动态分配数组

    2020-06-07 17:17:36
    C语言动态分配数组 函数动态分配空间 函数名 参数及返回类型 注意事项 malloc void *malloc(size_t size) 1. void *为常指针 2. 不要忘记空字符的空间 malloc(n+## 标题1) 3.未进行初始化 calloc void *...
  • M名学生的数据已在主函数中放入结构体数组student中,请编写函数fun,它的功能是:把高于平均分的学生数据放在c所指的数组中,高于平均分的学生人数通过形参n传回,平均分通过函数值返回。 ** 请勿改动主函数main与...
  • M名学生的数据已在主函数中放入结构体数组stu中,请编写函数fun,它的功能是:把小于等于平均分的学生数据放在1所指的数组中,大于等于平均分的学生人数通过形参n传回,平均分通过函数值返回。 请勿改动主函数main与...
  • 例题:学生的记录由学号和成绩组成,M名学生的数据已在主函数中放入结构体数组STU,请编写函数fun,它的功能是:把指定分数范围内的学生数据放在q所指的数组中,指定分数范围内的学生人数由函数值返回。 例如,输入的...
  • 关注、星标公众号,直达精彩内容来源:今日头条作者:IT刘小虎最近有读者问我,为什么C语言函数可以返回结构体,却不可以返回数组。有这样的问题并不奇怪,因为C语言数组和结构体本质上都是管理一...
  • 程序填空题,人员的记录由编号和出生年、月、日组成,N名人员的数据已在主函数中存入结构体数组std中,且编号唯一。函数fun的功能是:找出指定编号人员的数据,作为函数值返回,由主函数输出,若指定编号不存在,返回数据...
  • 题目:学生的记录由学好和成绩组成,N名学生的数据在主函数中放入结构体数组s中,函数fun的功能:把分数最低的学生数据放在b所指的数组中,注意:分数最低的学生可能不止一个,函数返回分数最低的学生的人数。...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 291
精华内容 116
关键字:

c语言返回结构体数组

c语言 订阅