关于struct函数的定义，初始化，清零，释放，清零

1.struct函数的定义struct players * media_player[100]（存一次内容就去使用）

typedef struct players
{
	MediaPlayerHandle playe_r ;
	MediaPlayerStatus statu_s ;


} players;
struct players * media_player[100] ; //创建

int main(int argc, char *argv[])
{	
  	int  i = 0 ;
	int   MAXSIZE = atoi(argv[3]) ;

	for(i=0 ; i<MAXSIZE ;i++)
	{
        media_player[i] = (players *) malloc(sizeof(players) * 1) ;//初始化
		...................去执行
	}

for(i=0 ; i < MAXSIZE ; i++)//释放
	{
		free(media_player[i]) ;
	}
	return 0 ;
}

2.struct函数的定义struct gpio_stu * gpio （一次存完内容，一个一个的取值使用）

typedef struct gpio_stu
{
    int pin ;
    int io_modes ;
    int value ;
}gpio_stu;

struct gpio_stu * gpio = NULL ; //创建

int main(int argc, char *argv[])
{	
  	int  i = 0 ;
  	int  PIN = 52；
	int   MAXSIZE = atoi(argv[3]) ;
	 gpio = (gpio_stu *) malloc(sizeof(gpio_stu) * (MAXSIZE)) ;初始化
	for(i=0 ; i<MAXSIZE ;i++)
	{
        gpio [i].pin =  PIN ;//(可在任何函数（主或者子）直接赋值)
		...................去执行
	}

free(gpio); //释放动态变量
	return 0 ;
}

3.struct函数环形队列方式存取
1)struct函数的定义struct rev get_message[100] （使用完立即释放，用于频繁的接收数据，形队列方式存数据）

typedef struct rev
{

    char   *Topic ;
    char   *MsgID ;
    void   * Body ;
    int    Size ;
}rev;
struct rev  get_message[100] = {0} ; //创建

error_t busMsgRecvCallback(void* context, const char* topic,
                    const char* msgID, void* body, int size)//此处为一个回调函数
{
    if(inIDX>=100)//计存入struct函数的第几个数
   {
       inIDX=0 ; 
   }
    get_message[inIDX].Topic = (char *)malloc(strlen(topic)+1) ;
    memset(get_message[inIDX].Topic , 0 , strlen(topic)+1); //清零
    memcpy(get_message[inIDX].Topic ,topic ,strlen(topic)) ;//赋值
    get_message[inIDX].MsgID = (char *)malloc(strlen(msgID)+1) ;
    memset(get_message[inIDX].MsgID , 0 , strlen(msgID)+1);
    memcpy(get_message[inIDX].MsgID ,msgID ,strlen(msgID)) ;   
    get_message[inIDX].Size = size ;
    get_message[inIDX].Body = (void *)malloc(size+1) ;   
    memset(get_message[inIDX].Body , 0 , strlen(body)+1);
    memcpy(get_message[inIDX].Body ,body ,size) ;
    log_i("inIDX =%d\n", inIDX) ;
    inIDX++ ;
    d= 1;
    return CT_EOK;
}


......sturct取值使用
if((topic!= NULL) && (i!=1) && (body != NULL) && (msgID != NULL))//也可以不释放，struct数组赋值可以覆盖
    {
        free(topic) ;
        free(msgID);
        free(body) ;
    }
	

struct变量清零void *memset(void *s, int ch, size_t n);//例子如上文

将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s
原型：extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组,c：是赋给buffer的值,count：是buffer的长度.

struct变量赋值void *memcpy(void *destin, void *source, unsigned n);//例子如上文

从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，即从源source中拷贝n个字节到目标destin中
destin-- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
source-- 指向要复制的数据源，类型强制转换为 void* 指针。
n-- 要被复制的字节数。

2).struct函数的定义struct rev get_message[100] （使用完立即释放，用于频繁的接收数据，环形队列方式取数据）

typedef struct rev
{

    char   *Topic ;
    char   *MsgID ;
    void   * Body ;
    int    Size ;
}rev;
struct rev  get_message[100] = {0} ;//创建
/*********************************/
int main(int argc, char *argv[])
{
 ......
 while(1)
 {
  	struct rev * msg = NULL ;
  	msg = getMessage();
  	if(msg != NULL)
   	{
      	jump = rev_message_compare(msg->Topic , msg->MsgID ,  msg->Body) ;
      	free(msg) ;
   	}
  }
}
/*********************************/
struct rev * getMessage()
{
    struct rev  * msg; 
    if(outIDX == inIDX) 
    {
        
        return NULL ;  
       
    }
    if(outIDX >= 100)
    {
        outIDX = 0;
    } 
    msg = ( struct rev *)malloc(sizeof(struct rev)) ;
    if(NULL == msg) return NULL ;
    msg->Topic = get_message[outIDX].Topic ;
    msg->MsgID = get_message[outIDX].MsgID ;
    msg->Size = get_message[outIDX].Size ;
    msg->Body = get_message[outIDX].Body;
    
    outIDX++ ;
    return msg ;
}

/*********************************/
int rev_message_compare(char *topic , char *msgID , void *body)
{
    .........
    count_num(1 , topic , msgID , body);//使用
}