c语言面向对象：字节数组与字节缓冲

字节数组类
char datas[LENGTH]; 这是一个c语言定义的数组，以下代码将其变为一个ZBytesClass类。

ZBytesClass.h

/********************
 * Black Spoor      *
 ********************/

#ifndef _BLACKSPOOR_ZBYTESCLASS_H_
#define _BLACKSPOOR_ZBYTESCLASS_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct ZBytesClass
{
 char * bytes; //数组的起始地址
 int length;  //数组的长度

 void (*Init)(struct ZBytesClass *,int);
 void (*Dispose)(struct ZBytesClass *);
}ZBytesClass;

extern ZBytesClass * ZBytesClassCreate(void);

#endif

ZBytesClass.c

/********************
 * Black Spoor      *
 ********************/

#include "ZBytesClass.h"

static void Init(struct ZBytesClass * bytes,int length);
static void Dispose(struct ZBytesClass * bytes);

static void Init(struct ZBytesClass * bytes,int length)
{
 if(bytes != NULL)
 {
  char * buf = (char *)malloc(length);
  memset(buf,0,length);
  bytes->bytes = buf;
  bytes->length = length;
 }
}

static void Dispose(struct ZBytesClass * bytes)
{
 if(bytes != NULL)
 {
  if(bytes->bytes != NULL)
  {
   free(bytes->bytes);
  }
  free(bytes);
 }
}

ZBytesClass * ZBytesClassCreate(void)
{
 ZBytesClass * stu = (ZBytesClass *)malloc(sizeof(ZBytesClass));
 memset(stu,0,sizeof(ZBytesClass));

 stu->Init = Init;
 stu->Dispose = Dispose;
 stu->SetDatas = SetDatas;

 return stu;
}

以上我们定义了一个 ZBytesClass 结构体，并使其变为一个数组类。
利用ZBytesClass，再定义一个字节缓冲区类 ZByteBufferClass

ZByteBufferClass.h

/********************
 * Black Spoor      *
 ********************/

#ifndef _BLACKSPOOR_BYTEBUFFERCLASS_H
#define _BLACKSPOOR_BYTEBUFFERCLASS_H

#include "ZBytesClass.h"

typedef struct ZByteBufferClass
{
 ZBytesClass * bytesClass;

 int bufferlength;//缓存区尺寸
 int datalength;//有效数据字节个数
 int iput; //写指针
 int iget; //读指针

 //初始化
 void (*Init)(struct ZByteBufferClass * ,int buflen);
 //销毁
 void (*Dispose)(struct ZByteBufferClass * );
 //写数据
 int (*Write)(struct ZByteBufferClass * , char * , int , int );
 //读数据
 int (*Read)(struct ZByteBufferClass * , char * , int , int );

}ZByteBufferClass;

extern ZByteBufferClass * ZByteBufferClassCreate(void);
#endif

ZByteBufferClass.c

/********************
 * Black Spoor      *
 ********************/

#include "stdio.h"
#include <string.h>

#include "ZByteBufferClass.h"

static void Init(struct ZByteBufferClass * bbc,int buflen);
static void Dispose(struct ZByteBufferClass * bbc);
static int Write(struct ZByteBufferClass * bbc,char * buffer, int offset, int length);
static int Read(struct ZByteBufferClass * bbc,char * buffer, int offset, int readlength);

static int GetLength(struct ZByteBufferClass * bbc);

static int GetLength(struct ZByteBufferClass * bbc)
{
 int iput = bbc->iput;
 int iget = bbc->iget;
    return (iput >= iget) ? (iput - iget) : (bbc->bufferlength - iget + iput);
}

static void Init(struct ZByteBufferClass * bbc,int buflen)
{
 bbc->bufferlength = buflen;

 bbc->bytesClass = ZBytesClassCreate();
 bbc->bytesClass->Init(bbc->bytesClass,buflen);

 bbc->iput = 0;
 bbc->iget = 0;
 bbc->datalength = 0;
}

static void Dispose(struct ZByteBufferClass * bbc)
{
 if(bbc!= NULL)
 {
  if(bbc->bytesClass!= NULL)
  {
   bbc->bytesClass->Dispose(bbc->bytesClass);
  }
  free(bbc);
 }
}

static int Write(struct ZByteBufferClass * buffer,char * ptr, int offset, int len)
{
    int re = 0;
    int datalength = GetLength(buffer);
 char * srcptr = ptr + offset;

    if( (datalength + len) < buffer->bufferlength )
    {
        char * data = buffer->bytesClass->bytes;
        if(buffer->iput + len > buffer->bufferlength)
        {
            //分两段写入
            int afterdatalen = (buffer->iput + len - buffer->bufferlength);
            int beforedatalen = len - afterdatalen;

            memcpy(data + buffer->iput,srcptr,beforedatalen);
            memcpy(data,srcptr + beforedatalen,afterdatalen);

            buffer->iput = afterdatalen;
        }
        else
        {
            //一次写入
            memcpy(data + buffer->iput,srcptr,len);
            buffer->iput += len;
        }
  re = len;
    }
    return re;
}

static int Read(struct ZByteBufferClass * buffer,char * ptr, int offset,int len)
{
    int readlen = 0;
    int datalength = GetLength(buffer);
 char * dstptr = ptr + offset;

    if(datalength > 0 )
    {
        char * data = buffer->bytesClass->bytes;
        readlen = datalength > len ? len : datalength;

        if( (readlen + buffer->iget) > buffer->bufferlength )
        {
            //两次读出
            int beforedatalen = buffer->bufferlength - buffer->iget;
            int afterdatalen = readlen - beforedatalen;
            memcpy(dstptr,data + buffer->iget,beforedatalen);
            memcpy(dstptr + beforedatalen,data,afterdatalen);
            buffer->iget = afterdatalen;
        }
        else
        {
            //一次读出
            memcpy(dstptr,data + buffer->iget,readlen);
            buffer->iget += readlen;
        }
    }
    return readlen;
}

ZByteBufferClass * ZByteBufferClassCreate(void)
{
 ZByteBufferClass * stu = (ZByteBufferClass *)malloc(sizeof(ZByteBufferClass));
 memset(stu,0,sizeof(ZByteBufferClass));

 stu->Init = Init;
 stu->Dispose = Dispose;

 stu->Read = Read;
 stu->Write = Write;

 return stu;
}

在做嵌入式开发时，芯片通常都有多种硬件接口，比如UART，SPI，IIC。
为了做到接收数据不丢失，就需要为每一个接口建立一个缓冲区，接收数据硬件中断处理函数向数据缓冲写数据，主流程从数据缓冲读数据。
ZByteBufferClass缓冲区类简化了建立多个缓冲的代码：

ZByteBufferClass * uartBuffer = ZByteBufferClassCreate();
uartBuffer->Init(uartBuffer, UART_BUFFER_LENGTH);

ZByteBufferClass * spiBuffer = ZByteBufferClassCreate();
spiBuffer >Init(spiBuffer, SPI_BUFFER_LENGTH);

ZByteBufferClass * iicBuffer = ZByteBufferClassCreate();
iicBuffer>Init(iicBuffer, IIC_BUFFER_LENGTH);

6行代码创建了3个缓冲区。
硬件中断处理函数只需要调用write方法，就可以实现向数据缓冲写数据。
主流程使用read方法，分别从3个缓冲区读数据，然后再处理。