求先入先出(FIFO)缓冲区算法

[microchu]

缓冲区大小10M，用来存放二进制数据,缓冲区的使用遵循以下规则
1)先入先出
2)取出后的空间视为空，可以再次存放数据
请写出存取接口函数：
1）存数据函数要求第一个参数为要存入数据的大小，第二个参数为存入数据的指针
2) 取数据函数要求第一个参数为要取出数据的大小，第二个参数为存放取出数据的指针

请各位先写写看，晚上回来跟大家讨论

[microchu]

顶,还有没有更好的

[megaboy]

这就是队列嘛，一个FIFO的动态链表就得了。

[ericqxg007]

刚开始看题目还以为是什么东西 仔细看还是数据结构的东西
楼主 这个题目就是要你建立队列 而且使用线性实现的

[boxban]

#include <iostream>
#include <cstdlib>
#include <cassert>

using namespace std;

class MyBuf
{
public:
MyBuf(int n = 10 * 1024 * 1024)
{
assert (n > 0);
m_buf = new char[n];
m_head = m_buf;
m_size = 0;
m_capacity = n;
}

~MyBuf() { delete []m_buf;}

public:
int write(int size, const char* data);
int read(int size, char* buf);

private:
const char* getBufferEnd() const { return (m_buf + m_capacity); }

private:
char* m_buf;
char* m_head;
int m_size;
int m_capacity;
};

//return size if OK. -1 means overflow.
int MyBuf::write(int size, const char* data)
{
assert(size > 0);
if ((size + m_size) > m_capacity) return -1;

int tailBytes = getBufferEnd() - (m_head + m_size);

if (tailBytes >= size){
memcpy(m_head + m_size, data, size);
}else{
if (tailBytes > 0){
memcpy(m_head + m_size, data, tailBytes);
memcpy(m_buf, data + tailBytes, size - tailBytes);
}else{
memcpy(m_buf - tailBytes, data, size);
}
}
m_size += size;

return size;
}

int MyBuf::read(int size, char* buf)
{
assert(size > 0);
if (size > m_size) return -1;

int n = getBufferEnd() - m_head;
if (n >= size){
memcpy(buf, m_head, size);
m_head += size;
}else{
memcpy(buf, m_head, n);
memcpy(buf + n, m_buf, size - n);
m_head = m_buf + size - n;
}
m_size -= size;
if (m_size == 0) m_head = m_buf;

return size;
}

int main()
{
MyBuf buf(12);
char tmp[100];

buf.write("abchello", (int)sizeof("abchello") - 1);
buf.read(tmp, 3);
tmp[3] = 0;
cout << tmp << endl;

buf.write(" world!", (int)sizeof(" world!") - 1);
buf.read(tmp, 12);
tmp[12] = 0;
cout << tmp << endl;

return 0;
}

[microchu]

这个题目，我觉得看上去像是循环队列，但是不能用链表实现，或者说用链表实现不简单。
因为循环队列链表算法是单个存入或取出对象，本例则是一次存取指定Size大小的数据量，
在边界上存取数据是本例的一个难点。

[look01]

待会帮你看看,呵呵!

[summercloth]

#define BUFFER_SIZE (unsigned long )10000000
unsigned char BUFFER[BUFFER_SIZE] = {0};
unsigned char *pBufferFront = (unsigned char *)BUFFER;
unsigned char *pBuffereEnd = (unsigned char *)BUFFER +BUFFER_SIZE -1;
unsigned char *pBufferCur = pBufferFront;
unsigned char Buffer_Put(unsigned long put_size,unsigned char *put_pointer)
{
unsigned long current_size;
unsigned long count;
if(put_size > (pBufferCur - pBufferFront))
return FALSE;
for(count = 0;count<put_size;count++)
*pBufferCur-- = *put_pointer++;

}
unsigned char Buffer_Get(unsigned long get_size,unsigned char *get_pointer)
{
unsigned long count;
unsigned char *move_pointer = pBuffereEnd;
if(get_size>BUFFER_SIZE- pBufferCur)
return FALSE;
for(count = 0;count<get_size;count++)
*get_pointer++ = *move_pointer--;
for(count = 0,pBufferCur = pBuffereEnd;count < move_pointer - pBufferCur;count++)
*pBufferCur-- = *move_pointer--;
return TRUE;
}