嫌ostringsteam過大，一些功能也不知道怎么用的，小生只好自己實現了一個功能類似的類，基本的常用的功能類似，只是為了我自己用起來更方便，更好駕馭，內置一個一級緩沖區（棧上，用戶可以定義大小），用戶可以定義緩沖區遞增的幅度。在知情（已知不會內存越界）的情況下可以直接對緩沖區進行寫入操作，代碼沒有針對char和wchar_t來做，當然也沒有考慮線程安全，有興趣的朋友可以自己修改。代碼在VC8下面通過，如果不是VC8的話，里面有幾個后面帶"_s"函數自己修改一下，如果有bug，請不吝賜教。
源代碼下載：
http://m.shnenglu.com/Files/PeakGao/ostrbuf.rar
/**//**
Created 2007.6.7 by PeakGao
Email: peakgao163@163.com
*/
#ifndef __OSTRBUF_H__
#define __OSTRBUF_H__
#include <stdlib.h>
namespace base
{
/**//**
示例
@code
int dosomething(char* dest_buf, int max_size)
{
char buf[] = "some thing some thing some thing some thing ";
int actualCpySize = max_size / 2 + 1;
memcpy(dest_buf, buf, actualCpySize);
return actualCpySize;
}
void test_ostrbuf()
{
ostrbuf osb;
// 如果怕緩沖區不夠，先直接設置一下
//osb.reserve(1024);
// 這些操作類似ostream的功能
osb<<(uint)0xffffffff<<","<<(int)0x80000001<<endl;// endl即換行符
osb<<99<<","<<(short)14<<","<<-15<<endl;
osb<<(int64)0x8000000000000001<<","<<(uint64)0xffffffffffffffff<<endl;
osb<<15.1367891024f<<","<<9999.123456789<<endl;
// 將一個字符串的子串寫入
osb<<ostrbuf::substr("我們你們他們abcdefg", 12)<<endl;
// 定制的格式化
osb<<ostrbuf::formatf("%02.6f", 3.1415926f)<<endl;
osb<<_fi("%04d", 25)<<endl; // 這種寫法更簡潔
osb<<_fi("%X", 255)<<endl;
// 直接操作緩沖區示例（在不知情的情況下不推薦這樣操作，知情的情況下，也不錯，很方便，至少少了字符串拷貝操作）
osb.grow(64); // 可能需要128字節空間，這個數值必須正確才能防止緩存越界
int off = dosomething(osb.cur(), 64); // dosomething 已經完全拋開了 ostrbuf 類，不受任何拘束，危險！
osb.seek(off); // 手動將位置seek到正確位置
osb<<ends; // 因上面的 dosomething 沒有在緩沖區最后加入'\0'，這里不能忘記，除了像 dosomething 這樣直接對緩沖區進行寫外，其他的操作都會自動加'\0'
std::cout<<osb.c_str();
}
//結果:
4294967295,-2147483647
99,14,-15
-9223372036854775807,18446744073709551615
15.136789,9999.123457
我們你們他們
3.141593
0025
FF
some thing some thing some thing
@endcode
*/
/**//**
字符串輸出緩沖，功能類似ostream，但更加簡潔
@param _GrowBytes 緩沖區的遞增大小
@param _ArrSize 內部的字符數組的大小，當該字符數組容量不夠時，才new出真正的緩沖區
*/
template <int _GrowBytes, int _ArrSize = 64>
class basic_ostrbuf
{
private:
enum {_MyGrowBytes = _GrowBytes > 0 ? ((_GrowBytes + 7) & ~7) : 256};
enum {_MyArrSize = _ArrSize > 0 ? ((_ArrSize + 7) & ~7) : 64};
enum {_LongMaxLength = 16, _Int64MaxLength = 24, _DoubleMaxLength = 48}; // 留有余地，8字節對齊
char* _buf; /**//// 緩沖區
size_t _pos; /**//// 當前寫入位置
size_t _cap; /**//// 緩沖區容量
char _arr[_MyArrSize]; /**//// 字符數組，當操作小緩沖區時，可以利用他，這樣就沒必要new內存
/// 用于用戶自定義的格式化，基于sprintf函數的格式化功能
public:
template<class T>
struct format
{
const char* _f;
T _v;
format(const char* f, const T& v) : _f(f), _v(v) { }
};
typedef format<float> formatf;
typedef format<double> formatd;
typedef format<int> formati;
typedef format<__int64> formati64;
typedef std::pair<const char*, size_t> substr;
// 構造（析構）
public:
basic_ostrbuf() : _buf(_arr), _pos(0), _cap(_MyArrSize) { _arr[0] = 0; }
~basic_ostrbuf() { if (_buf != _arr) delete[] _buf; }
// 基本方法
public:
void clear()
{
grow(1);
_pos = 0;
_buf[_pos] = 0;
}
char* str() const { return _buf; }
const char* c_str() const { return _buf; }
size_t length() const { return _pos; }
size_t capacity() const { return _cap; }
char* cur() const { return _buf + _pos;}
void seek(int offset)
{
int new_pos = (int)_pos + offset;
if (new_pos >= (int)_cap) new_pos = (int)_cap - 1;
if (new_pos < 0) new_pos = 0;
_pos = (size_t)new_pos;
}
/**//// 預定一個用戶設定的緩沖大小（對于大緩沖或已知大小的緩沖，用這種方法可以減少new/delete的次數）
void reserve(size_t length)
{
if (length >= _cap)
grow(length - _pos);
}
// operator<<
public:
/**//// 用于endl和ends
basic_ostrbuf& operator<<(basic_ostrbuf& (__cdecl * fn)(basic_ostrbuf&))
{
return ((*fn)(*this));
}
/**//// 輸入另一個對象
basic_ostrbuf& operator<<(const basic_ostrbuf& other)
{
return push(other.c_str(), other.length());
}
/**//// 輸入字符串
basic_ostrbuf& operator<<(const char* str)
{
return (str ? push(str, strlen(str)) : (*this));
}
/**//// 輸入一個子串
basic_ostrbuf& operator<<(const substr& str)
{
return push(str.first, str.second);
}
/**//// 輸入std::string對象
basic_ostrbuf& operator<<(const std::string& str)
{
return push(str.c_str(), str.length());
}
/**//// 輸入一個字符
/// 注：這里c當字符處理，不當0-255的數字處理，0-255的數字，需要轉換為short,int,long等進行處理
basic_ostrbuf& operator<<(char c)
{
return put(c);
}
/**//// 導入數字
basic_ostrbuf& operator<<(short int si)
{
return operator<<(long(si));
}
basic_ostrbuf& operator<<(unsigned short int usi)
{
return operator<<(unsigned long(usi));
}
basic_ostrbuf& operator<<(int i)
{
#ifdef INT_64_BITS
return operator<<(__int64(i));
#else
return operator<<(long(i));
#endif
}
basic_ostrbuf& operator<<(unsigned int ui)
{
#ifdef INT_64_BITS
return operator<<(unsigned __int64(ui));
#else
return operator<<(unsigned long(ui));
#endif
}
basic_ostrbuf& operator<<(long l)
{
grow(_LongMaxLength);
_ltoa_s(l, cur(), _LongMaxLength, 10);
_pos += strlen(cur());
return (*this);
}
basic_ostrbuf& operator<<(unsigned long ul)
{
grow(_LongMaxLength);
_ultoa_s(ul, cur(), _LongMaxLength, 10);
_pos += strlen(cur());
return (*this);
}
basic_ostrbuf& operator<<(__int64 i64)
{
grow(_Int64MaxLength);
_i64toa_s(i64, cur(), _Int64MaxLength, 10);
_pos += strlen(cur());
return (*this);
}
basic_ostrbuf& operator<<(unsigned __int64 ui64)
{
grow(_Int64MaxLength);
_ui64toa_s(ui64, cur(), _Int64MaxLength, 10);
_pos += strlen(cur());
return (*this);
}
basic_ostrbuf& operator<<(float f)
{
grow(_DoubleMaxLength);
sprintf_s(cur(), _DoubleMaxLength, "%f", f);
_pos += strlen(cur());
return (*this);
}
basic_ostrbuf& operator<<(double d)
{
grow(_DoubleMaxLength);
sprintf_s(cur(), _DoubleMaxLength, "%f", d);
_pos += strlen(cur());
return (*this);
}
/**//// 定制的格式化
template<class T>
basic_ostrbuf& operator<<(const format<T>& val)
{
grow(_DoubleMaxLength);
sprintf_s(cur(), _DoubleMaxLength, val._f, val._v);
_pos += strlen(cur());
return (*this);
}
public:
void grow(size_t len)
{
if (_pos + len >= _cap)
{
// 計算新的尺寸，并8字節對齊
size_t new_size = _pos + len + 1;
size_t new_cap = _cap ? _cap : _MyGrowBytes;
while (new_cap < new_size)
new_cap += _MyGrowBytes;
new_cap = (new_cap + 7) & ~7;
char* new_buf = new char[new_cap];
if (_pos > 0)
{
memcpy(new_buf, _buf, _pos + 1);
if (_buf != _arr)
delete[] _buf;
}
else
new_buf[0] = 0;
_buf = new_buf;
_cap = new_cap;
}
}
basic_ostrbuf& put(char c)
{
grow(1);
_buf[_pos] = c;
if (c != 0)
_buf[++_pos] = 0;
return (*this);
}
basic_ostrbuf& push(const char* str, size_t len)
{
if (str && len > 0)
{
grow(len);
memcpy(_buf + _pos, str, len);
_buf[_pos += len] = 0;
}
return (*this);
}
};
/**//// 字符串終止
template<int _GrowBytes, int _ArrSize>
inline basic_ostrbuf<_GrowBytes, _ArrSize>& _cdecl ends(basic_ostrbuf<_GrowBytes, _ArrSize>& osb)
{
return osb.put('\0');
}
/**//// 換行
template<int _GrowBytes, int _ArrSize>
inline basic_ostrbuf<_GrowBytes, _ArrSize>& _cdecl endl(basic_ostrbuf<_GrowBytes, _ArrSize>& osb)
{
return osb.put('\n');
}
#if 0
/**//**
示例：用戶自定義類型的定制方法，定義后可以這樣處理你的自定義類型：
YourType yt;
ostrbuf<<yt;
*/
template<int _GrowBytes, int _ArrSize>
inline basic_ostrbuf<_GrowBytes, _ArrSize>& _cdecl operator<<(basic_ostrbuf<_GrowBytes, _ArrSize>& osb, const YourType& val)
{
if (val.c_str())
osb.push(val.c_str(), val.length());
return osb;
}
#endif
typedef basic_ostrbuf<256, 64> ostrbuf;
// 為了方便使用，作這樣的 typedef
typedef ostrbuf::formatf _ff;
typedef ostrbuf::formatd _fd;
typedef ostrbuf::formati _fi;
typedef ostrbuf::formati64 _fi64;
typedef ostrbuf::substr _ss;
} // namespace
#endif // __OSTRBUF_H__