IStream

[LiuYinChina]

#ifndef IStream_H
#define IStream_H

#include <string>

namespace StreamLib
{

using std::string;

interface IStream
{
virtual IStream & operator << (const char ch) = 0;
virtual IStream & operator << (const signed char ch) = 0;
virtual IStream & operator << (const unsigned char ch) = 0;
virtual IStream & operator << (const short sh) = 0;
virtual IStream & operator << (const unsigned short sh) = 0;
virtual IStream & operator << (const int i) = 0;
virtual IStream & operator << (const unsigned int i) = 0;
virtual IStream & operator << (const long l) = 0;
virtual IStream & operator << (const unsigned long l) = 0;
virtual IStream & operator << (const float f) = 0;
virtual IStream & operator << (const double d) = 0;
virtual IStream & operator << (const long double ld) = 0;
virtual IStream & operator << (const char *pcstr) = 0;
virtual IStream & operator << (const string &str) = 0;

virtual IStream & operator >> (char &ch) = 0;
virtual IStream & operator >> (signed char &ch) = 0;
virtual IStream & operator >> (unsigned char &ch) = 0;
virtual IStream & operator >> (short &sh) = 0;
virtual IStream & operator >> (unsigned short &sh) = 0;
virtual IStream & operator >> (int &i) = 0;
virtual IStream & operator >> (unsigned int &i) = 0;
virtual IStream & operator >> (long &l) = 0;
virtual IStream & operator >> (unsigned long &l) = 0;
virtual IStream & operator >> (float &f) = 0;
virtual IStream & operator >> (double &d) = 0;
virtual IStream & operator >> (long double &ld) = 0;
virtual IStream & operator >> (char * const pcstr) = 0;
virtual IStream & operator >> (string &str) = 0;
};

}

#endif

[LiuYinChina]

不只，还想流向网络

[LiuYinChina]

#ifndef FileStream_H
#define FileStream_H

#include <cstdio>

#include <IStream.h>

namespace StreamLib
{

class FileStream : public IStream
{
private:
FILE *m_pFile;

bool writeBytes(const void *pData, size_t size) const;
bool readBytes(void *pData, size_t size);

public:
FileStream();
FileStream(const char *szFileName, const char *szOpenMode);
virtual ~FileStream();

bool open(const char * const pFileName, const char * const pOpenMode);
void close();

bool operator !() {
return m_pFile == 0;
}

virtual IStream & operator << (const char ch);
virtual IStream & operator << (const signed char ch);
virtual IStream & operator << (const unsigned char ch);
virtual IStream & operator << (const short sh);
virtual IStream & operator << (const unsigned short sh);
virtual IStream & operator << (const int i);
virtual IStream & operator << (const unsigned int i);
virtual IStream & operator << (const long l);
virtual IStream & operator << (const unsigned long l);
virtual IStream & operator << (const float f);
virtual IStream & operator << (const double d);
virtual IStream & operator << (const long double ld);
virtual IStream & operator << (const char *pcstr);
virtual IStream & operator << (const string &str);

virtual IStream & operator >> (char &ch);
virtual IStream & operator >> (signed char &ch);
virtual IStream & operator >> (unsigned char &ch);
virtual IStream & operator >> (short &sh);
virtual IStream & operator >> (unsigned short &sh);
virtual IStream & operator >> (int &i);
virtual IStream & operator >> (unsigned int &i);
virtual IStream & operator >> (long &l);
virtual IStream & operator >> (unsigned long &l);
virtual IStream & operator >> (float &f);
virtual IStream & operator >> (double &d);
virtual IStream & operator >> (long double &ld);
virtual IStream & operator >> (char * const pcstr);
virtual IStream & operator >> (string &str);
};

}

#endif

[LiuYinChina]

#include <FileStream.h>

namespace StreamLib
{

FileStream::FileStream() : m_pFile(0) {}
FileStream::FileStream(const char *szFileName, const char *szOpenMode) : m_pFile(0) { open(szFileName, szOpenMode); }
FileStream::~FileStream() { close(); }

bool FileStream::writeBytes(const void *pData, size_t size) const
{
if (m_pFile == 0) {
return false;
}

size_t len = ::fwrite(pData, 1, size, m_pFile);
return len == size;
}

bool FileStream::readBytes(void *pData, size_t size)
{
if (m_pFile == 0) {
return false;
}

size_t len = ::fread(pData, 1, size, m_pFile);
return len == size;
}

bool FileStream::open(const char * const pFileName, const char * const pOpenMode) {
if (m_pFile != 0) {
close();
}

m_pFile = ::fopen(pFileName, pOpenMode);
return m_pFile != 0;
}

void FileStream::close()
{
if (m_pFile == 0) {
return;
}

::fclose(m_pFile);
m_pFile = 0;
}

IStream & FileStream::operator << (const char ch) { writeBytes (&ch, sizeof (ch)); return *this; }
IStream & FileStream::operator << (const signed char ch) { writeBytes (&ch, sizeof (ch)); return *this; }
IStream & FileStream::operator << (const unsigned char ch) { writeBytes (&ch, sizeof (ch)); return *this; }
IStream & FileStream::operator << (const short sh) { writeBytes (&sh, sizeof (sh)); return *this; }
IStream & FileStream::operator << (const unsigned short sh) { writeBytes (&sh, sizeof (sh)); return *this; }
IStream & FileStream::operator << (const int i) { writeBytes (&i, sizeof (i)); return *this; }
IStream & FileStream::operator << (const unsigned int i) { writeBytes (&i, sizeof (i)); return *this; }
IStream & FileStream::operator << (const long l) { writeBytes (&l, sizeof (l)); return *this; }
IStream & FileStream::operator << (const unsigned long l) { writeBytes (&l, sizeof (l)); return *this; }
IStream & FileStream::operator << (const float f) { writeBytes (&f, sizeof (f)); return *this; }
IStream & FileStream::operator << (const double d) { writeBytes (&d, sizeof (d)); return *this; }
IStream & FileStream::operator << (const long double ld) { writeBytes (&ld, sizeof (ld));return *this; }

IStream & FileStream::operator << (const char *pcstr)
{
size_t size = strlen (pcstr);
writeBytes (&size, sizeof(size));

for (size_t i=0; i<size; ++i) {
writeBytes (&pcstr[i], sizeof (pcstr[i]));
}

return *this;
}

IStream & FileStream::operator << (const string &str)
{
size_t size = str.size();
writeBytes (&size, sizeof(size));

string::const_iterator it;
for (it = str.begin(); it != str.end(); ++it) {
writeBytes (&(*it), sizeof ((*it)));
}

return *this;
}

IStream & FileStream::operator >> (char &ch) { readBytes (&ch, sizeof (ch)); return *this; }
IStream & FileStream::operator >> (signed char &ch) { readBytes (&ch, sizeof (ch)); return *this; }
IStream & FileStream::operator >> (unsigned char &ch) { readBytes (&ch, sizeof (ch)); return *this; }
IStream & FileStream::operator >> (short &sh) { readBytes (&sh, sizeof (sh)); return *this; }
IStream & FileStream::operator >> (unsigned short &sh) { readBytes (&sh, sizeof (sh)); return *this; }
IStream & FileStream::operator >> (int &i) { readBytes (&i, sizeof (i)); return *this; }
IStream & FileStream::operator >> (unsigned int &i) { readBytes (&i, sizeof (i)); return *this; }
IStream & FileStream::operator >> (long &l) { readBytes (&l, sizeof (l)); return *this; }
IStream & FileStream::operator >> (unsigned long &l) { readBytes (&l, sizeof (l)); return *this; }
IStream & FileStream::operator >> (float &f) { readBytes (&f, sizeof (f)); return *this; }
IStream & FileStream::operator >> (double &d) { readBytes (&d, sizeof (d)); return *this; }
IStream & FileStream::operator >> (long double &ld) { readBytes (&ld, sizeof (ld)); return *this; }

IStream & FileStream::operator >> (char * const pcstr) {
size_t size = 0;
readBytes (&size, sizeof (size));

size_t i = 0;
for (i=0; i<size; ++i) {
char ch = '\0';
readBytes (&ch, sizeof (ch));
pcstr[i] = ch;
}
pcstr[i] = '\0';

return *this;
}

IStream & FileStream::operator >> (string &str) {
str.erase(str.begin(), str.end());

size_t size = 0;
readBytes (&size, sizeof (size));

for (size_t i=0; i<size; ++i) {
char ch = '\0';
readBytes (&ch, sizeof (ch));
str.insert(str.end(), ch);
}
str.insert(str.end(), '\0');

return *this;
}

}

[vollin]

想实现序列化（永久化）是吧？