strstream

C语言库函数的原型,有用的拿去

			;	// no buffer to free
		else if (_Pfree != 0)
			(*_Pfree)(eback());	// free with function call
		else
			_DELETE_CRT_VEC(eback());	// free by deleting array

		_Seekhigh = 0;
		_Strmode &= ~(_Allocated | _Frozen);
		}

private:
	enum
		{	// constant for default minimum buffer size
		_MINSIZE = 32};

	int _Minsize;		// the minimum buffer size
	char *_Pendsave;	// the saved end pointer during freeze
	char *_Seekhigh;	// the high-water pointer in character array
	_Strstate _Strmode;	// the stream state
	void *(__CLRCALL_OR_CDECL *_Palloc)(size_t);	// the pointer to allocator function
	void (__CLRCALL_OR_CDECL *_Pfree)(void *);	// the pointer to free function
	};

	// strstreambuf OPERATORS
inline void swap(strstreambuf& _Left, strstreambuf& _Right)
	{	// swap _Left and _Right strstreambufs
	_Left.swap(_Right);
	}

inline void swap(strstreambuf& _Left, strstreambuf&& _Right)
	{	// swap _Left and _Right strstreambufs
	typedef strstreambuf _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

inline void swap(strstreambuf&& _Left, strstreambuf& _Right)
	{	// swap _Left and _Right strstreambufs
	typedef strstreambuf _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}

		// CLASS istrstream
class istrstream
	: public istream
	{	// input stream associated with a character array
public:
	typedef istrstream _Myt;
	typedef istream _Mybase;
	typedef strstreambuf _Mysb;

	explicit __CLR_OR_THIS_CALL istrstream(const char *_Ptr)
		: _Mybase(&_Strbuffer), _Strbuffer(_Ptr, 0)
		{	// construct with NTBS
		}

	__CLR_OR_THIS_CALL istrstream(const char *_Ptr,
		streamsize _Count)
		: _Mybase(&_Strbuffer), _Strbuffer(_Ptr, _Count)
		{	// construct with [_Ptr, _Ptr + _Count)
		}

	explicit __CLR_OR_THIS_CALL istrstream(char *_Ptr)
		: _Mybase(&_Strbuffer), _Strbuffer((const char *)_Ptr, 0)
		{	// construct with NTBS
		}

	__CLR_OR_THIS_CALL istrstream(char *_Ptr,
		int _Count)
		: _Mybase(&_Strbuffer), _Strbuffer((const char *)_Ptr, _Count)
		{	// construct with [_Ptr, _Ptr + _Count)
		}

	__CLR_OR_THIS_CALL istrstream(_Myt&& _Right)
		: _Mybase(&_Strbuffer)
		{	// construct by moving _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		}

	_Myt& __CLR_OR_THIS_CALL operator=(_Myt&& _Right)
		{	// move from _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		return (*this);
		}

	void __CLR_OR_THIS_CALL _Assign_rv(_Myt&& _Right)
		{	// move from _Right
		if (this != &_Right)
			{	// different, swap base and buffer
			_Strbuffer.clear();
			this->swap(_Right);
			}
		}

	void __CLR_OR_THIS_CALL swap(_Myt& _Right)
		{	// swap with _Right
		if (this != &_Right)
			{	// different, swap base and buffer
			_Mybase::swap(_Right);
			_Strbuffer.swap(_Right._Strbuffer);
			}
		}

	void __CLR_OR_THIS_CALL swap(_Myt&& _Right)
		{	// swap with _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		}

	virtual __CLR_OR_THIS_CALL ~istrstream()
		{	// destroy an istrstream
		}

	_Mysb *__CLR_OR_THIS_CALL rdbuf() const
		{	// return pointer to character array buffer
		return ((_Mysb *)&_Strbuffer);
		}

	char *__CLR_OR_THIS_CALL str()
		{	// freeze and return pointer to character array
		return (_Strbuffer.str());
		}

private:
	_Mysb _Strbuffer;	// the string buffer
	};

	// istrstream OPERATORS
inline void swap(istrstream& _Left, istrstream& _Right)
	{	// swap _Left and _Right istrstreams
	_Left.swap(_Right);
	}

inline void swap(istrstream& _Left, istrstream&& _Right)
	{	// swap _Left and _Right istrstreams
	typedef istrstream _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

inline void swap(istrstream&& _Left, istrstream& _Right)
	{	// swap _Left and _Right istrstreams
	typedef istrstream _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}

		// CLASS ostrstream
class ostrstream
	: public ostream
	{	// output stream associated with a character array
public:
	typedef ostrstream _Myt;
	typedef ostream _Mybase;
	typedef strstreambuf _Mysb;

	__CLR_OR_THIS_CALL ostrstream()
		: ostream(&_Strbuffer), _Strbuffer()
		{	// construct with empty character array
		}

	__CLR_OR_THIS_CALL ostrstream(char *_Ptr,
		streamsize _Count,
		ios_base::openmode _Mode =
			ios_base::out)
		: ostream(&_Strbuffer),
			_Strbuffer(_Ptr, _Count,
				_Ptr == 0 || (_Mode & ios_base::app) == 0
					? _Ptr : _Ptr + _CSTD strlen(_Ptr))
		{	// construct with [_Ptr, _Ptr + _Count)
		}

	__CLR_OR_THIS_CALL ostrstream(_Myt&& _Right)
		: _Mybase(&_Strbuffer)
		{	// construct by moving _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		}

	_Myt& __CLR_OR_THIS_CALL operator=(_Myt&& _Right)
		{	// move from _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		return (*this);
		}

	void __CLR_OR_THIS_CALL _Assign_rv(_Myt&& _Right)
		{	// move from _Right
		if (this != &_Right)
			{	// different, swap base and buffer
			_Strbuffer.clear();
			this->swap(_Right);
			}
		}

	void __CLR_OR_THIS_CALL swap(_Myt& _Right)
		{	// swap with _Right
		if (this != &_Right)
			{	// different, swap base and buffer
			_Mybase::swap(_Right);
			_Strbuffer.swap(_Right._Strbuffer);
			}
		}

	void __CLR_OR_THIS_CALL swap(_Myt&& _Right)
		{	// swap with _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		}

	virtual __CLR_OR_THIS_CALL ~ostrstream()
		{	// destroy an ostrstream
		}

	_Mysb *__CLR_OR_THIS_CALL rdbuf() const
		{	// return pointer to character array buffer
		return ((_Mysb *)&_Strbuffer);
		}

	void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true)
		{	// freeze or unfreeze writing
		_Strbuffer.freeze(_Freezeit);
		}

	char *__CLR_OR_THIS_CALL str()
		{	// freeze and return pointer to character array
		return (_Strbuffer.str());
		}

	streamsize __CLR_OR_THIS_CALL pcount() const
		{	// return size of writable character array
		return (_Strbuffer.pcount());
		}

private:
	_Mysb _Strbuffer;	// the string buffer
	};

	// ostrstream OPERATORS
inline void swap(ostrstream& _Left, ostrstream& _Right)
	{	// swap _Left and _Right ostrstreams
	_Left.swap(_Right);
	}

inline void swap(ostrstream& _Left, ostrstream&& _Right)
	{	// swap _Left and _Right ostrstreams
	typedef ostrstream _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

inline void swap(ostrstream&& _Left, ostrstream& _Right)
	{	// swap _Left and _Right ostrstreams
	typedef ostrstream _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}

		// CLASS strstream
class strstream
	: public iostream
	{	// input/output stream associated with character array buffer
public:
	typedef strstream _Myt;
	typedef iostream _Mybase;
	typedef strstreambuf _Mysb;

	typedef char char_type;
	typedef int int_type;
	typedef streampos pos_type;
	typedef streamoff off_type;

	__CLR_OR_THIS_CALL strstream()
		: _Mybase(&_Strbuffer), _Strbuffer()
		{	// construct with empty character array
		}

	__CLR_OR_THIS_CALL strstream(char *_Ptr,
		streamsize _Count,
		ios_base::openmode _Mode =
			ios_base::in | ios_base::out)
		: iostream(&_Strbuffer),
			_Strbuffer(_Ptr, _Count,
				_Ptr == 0 || (_Mode & ios_base::app) == 0
					? _Ptr : _Ptr + _CSTD strlen(_Ptr))
		{	// construct with [_Ptr, _Ptr + _Count)
		}

	__CLR_OR_THIS_CALL strstream(_Myt&& _Right)
		: _Mybase(&_Strbuffer)
		{	// construct by moving _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		}

	_Myt& __CLR_OR_THIS_CALL operator=(_Myt&& _Right)
		{	// move from _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		return (*this);
		}

	void __CLR_OR_THIS_CALL _Assign_rv(_Myt&& _Right)
		{	// move from _Right
		if (this != &_Right)
			{	// different, swap base and buffer
			_Strbuffer.clear();
			this->swap(_Right);
			}
		}

	void __CLR_OR_THIS_CALL swap(_Myt& _Right)
		{	// swap with _Right
		if (this != &_Right)
			{	// different, swap base and buffer
			_Mybase::swap(_Right);
			_Strbuffer.swap(_Right._Strbuffer);
			}
		}

	void __CLR_OR_THIS_CALL swap(_Myt&& _Right)
		{	// swap with _Right
		_Assign_rv(_STD forward<_Myt>(_Right));
		}

	virtual __CLR_OR_THIS_CALL ~strstream()
		{	// destroy a strstream
		}

	_Mysb *__CLR_OR_THIS_CALL rdbuf() const
		{	// return pointer to character array buffer
		return ((_Mysb *)&_Strbuffer);
		}

	void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true)
		{	// freeze or unfreeze writing
		_Strbuffer.freeze(_Freezeit);
		}

	char *__CLR_OR_THIS_CALL str()
		{	// freeze and return pointer to character array
		return (_Strbuffer.str());
		}

	streamsize __CLR_OR_THIS_CALL pcount() const
		{	// return size of writable character array
		return (_Strbuffer.pcount());
		}

private:
	_Mysb _Strbuffer;	// the string buffer
	};

	// strstream OPERATORS
inline void swap(strstream& _Left, strstream& _Right)
	{	// swap _Left and _Right strstreams
	_Left.swap(_Right);
	}

inline void swap(strstream& _Left, strstream&& _Right)
	{	// swap _Left and _Right strstreams
	typedef strstream _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

inline void swap(strstream&& _Left, strstream& _Right)
	{	// swap _Left and _Right strstreams
	typedef strstream _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}
_STD_END

 #pragma pop_macro("new")

 #pragma warning(pop)
 #pragma pack(pop)

#endif /* RC_INVOKED */
#endif /* _STRSTREAM_ */

/*
 * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.20:0009 */