精华内容
下载资源
问答
  • OSTREAM

    2014-01-17 17:07:49
    // ostream standard header #if _MSC_VER > 1000 #pragma once #endif #ifndef _OSTREAM_ #define _OSTREAM_ #include #ifdef _MSC_VER #pragma pack(push,8) #endif /* _MSC_VER */ // I/O exception ma
    // ostream standard header
    
    #if     _MSC_VER > 1000
    #pragma once
    #endif
    
    #ifndef _OSTREAM_
    #define _OSTREAM_
    #include <ios>
    
    #ifdef  _MSC_VER
    #pragma pack(push,8)
    #endif  /* _MSC_VER */
    // I/O exception macros
    #define _TRY_IO_BEGIN	_TRY_BEGIN
    #define _CATCH_IO_END	_CATCH_ALL \
    		setstate(ios_base::badbit, true); _CATCH_END
    #define _CATCH_IO_(x)	_CATCH_ALL \
    		(x).setstate(ios_base::badbit, true); _CATCH_END
    _STD_BEGIN
    // TEMPLATE CLASS basic_ostream
    template<class _E, class _Tr = char_traits<_E> >
    class basic_ostream : virtual public basic_ios<_E, _Tr>
    {
    public:
    	typedef basic_ostream<_E, _Tr> _Myt;
    	typedef basic_ios<_E, _Tr> _Myios;
    	typedef basic_streambuf<_E, _Tr> _Mysb;
    	typedef ostreambuf_iterator<_E, _Tr> _Iter;
    	typedef num_put<_E, _Iter> _Nput;
    	explicit basic_ostream(
    		basic_streambuf<_E, _Tr> *_S,bool _Isstd = false, bool _Doinit = true)
    	{
    		if (_Doinit)
    			init(_S, _Isstd);
    	}
    	basic_ostream(_Uninitialized)
    	{
    		_Addstd();
    	}
    	virtual ~basic_ostream()
    	{
    
    	}
    	class sentry
    	{
    	public:
    		explicit sentry(_Myt& _Os): _Ok(_Os.opfx()), _Ostr(_Os)
    		{}
    		~sentry()
    		{
    			if (!uncaught_exception())
    			_Ostr.osfx();
    		}
    		operator bool() const
    		{
    			return (_Ok);
    		}
    	private:
    		bool _Ok;
    		_Myt& _Ostr;
    	};
    	bool opfx()
    	{
    		if (good() && tie() != 0)
    			tie()->flush();
    		return (good()); 
    	}
    	void osfx()
    	{
    		if (flags() & unitbuf)
    		flush();
    	}
    	_Myt& operator<<(_Myt& (__cdecl *_F)(_Myt&))
    	{
    		return ((*_F)(*this));
    	}
    	_Myt& operator<<(_Myios& (__cdecl *_F)(_Myios&))
    	{
    		(*_F)(*(_Myios *)this);
    		return (*this);
    	}
    	_Myt& operator<<(ios_base& (__cdecl *_F)(ios_base&))
    	{
    		(*_F)(*(ios_base *)this);
    		return (*this);
    	}
    	_Myt& operator<<(_Bool _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this); 
    	}
    	_Myt& operator<<(short _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			fmtflags _Bfl = flags() & basefield;
    			long _Y = (_Bfl == oct || _Bfl == hex)? (long)(unsigned short)_X : (long)_X;
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _Y).failed())
    					_St |= badbit;
    			_CATCH_IO_END
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(unsigned short _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), (unsigned long)_X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(int _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			fmtflags _Bfl = flags() & basefield;
    			long _Y = (_Bfl == oct || _Bfl == hex) ? (long)(unsigned int)_X : (long)_X;
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _Y).failed())
    					_St |= badbit;
    			_CATCH_IO_END
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(unsigned int _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), (unsigned long)_X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this); 
    	}
    	_Myt& operator<<(long _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(unsigned long _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(float _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), (double)_X).failed())
    					_St |= badbit;
    			_CATCH_IO_END
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(double _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(long double _X)
    	{	
    		iostate _St = goodbit;	
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(const void *_X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (_Ok)
    		{
    			const _Nput& _Fac = _USE(getloc(), _Nput);
    			_TRY_IO_BEGIN
    				if (_Fac.put(_Iter(rdbuf()), *this,fill(), _X).failed())
    					_St |= badbit;
    			_CATCH_IO_END 
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& operator<<(_Mysb *_Pb)
    	{
    		iostate _St = goodbit;
    		bool _Copied = false;
    		const sentry _Ok(*this);
    		if (_Ok && _Pb != 0)
    			for (int_type _C = _Tr::eof(); ; _Copied = true)
    			{
    				_TRY_BEGIN
    					_C = _Tr::eq_int_type(_Tr::eof(), _C) ?
    								_Pb->sgetc() : _Pb->snextc();
    				_CATCH_ALL
    					setstate(failbit);
    				_RERAISE;
    				_CATCH_END
    					if (_Tr::eq_int_type(_Tr::eof(),_C))
    						break;
    					_TRY_IO_BEGIN
    						if (_Tr::eq_int_type(_Tr::eof(),
    									rdbuf()->sputc(_Tr::to_char_type(_C))))
    						{
    							_St |= badbit;
    							break; 
    						}
    						_CATCH_IO_END 
    			}
    		width(0);
    		setstate(!_Copied ? _St | failbit : _St);
    		return (*this);
    	}
    	_Myt& put(_E _X)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (!_Ok)
    			_St |= badbit;
    		else
    		{
    			_TRY_IO_BEGIN
    				if (_Tr::eq_int_type(_Tr::eof(),rdbuf()->sputc(_X)))
    				 _St |= badbit;
    			_CATCH_IO_END
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& write(const _E *_S, streamsize _N)
    	{
    		iostate _St = goodbit;
    		const sentry _Ok(*this);
    		if (!_Ok)
    			_St |= badbit;
    		else
    		{
    			_TRY_IO_BEGIN
    				if (rdbuf()->sputn(_S, _N) != _N)
    					_St |= badbit;
    			_CATCH_IO_END
    		}
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& flush()
    	{
    		iostate _St = goodbit;
    		if (!fail() && rdbuf()->pubsync() == -1)
    			_St |= badbit;
    		setstate(_St);
    		return (*this);
    	}
    	_Myt& seekp(pos_type _P)
    	{
    		if (!fail())
    			rdbuf()->pubseekpos(_P, out);
    		return (*this);
    	}
    	_Myt& seekp(off_type _O, ios_base::seekdir _W)
    	{
    		if (!fail())
    			rdbuf()->pubseekoff(_O, _W, out);
    		return (*this); 
    	}
    	pos_type tellp()
    	{
    		if (!fail())
    			return (rdbuf()->pubseekoff(0, cur, out));
    		else
    			return (streampos(_BADOFF)); 
    	}
    };
    	
    	
    #ifdef _DLL
    #pragma warning(disable:4231) /* the extern before template is
     a non-standard extension */
    	extern template class _CRTIMP basic_ostream<char,
    							char_traits<char> >;
    	extern template class _CRTIMP basic_ostream<wchar_t,
    							char_traits<wchar_t> >;
    #pragma warning(default:4231) /* restore previous warning */
    #endif		// _DLL
    	
    	
    	// INSERTERS
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>& __cdecl operator<<(
    				basic_ostream<_E, _Tr>& _O, const _E *_X)
    	{
    		typedef basic_ostream<_E, _Tr> _Myos;
    		ios_base::iostate _St = ios_base::goodbit;
    		size_t _N = _Tr::length(_X);
    		size_t _M = _O.width() <= 0 || _O.width() <= _N	?
    						0 : _O.width() - _N;
    		const _Myos::sentry _Ok(_O);
    		if (!_Ok)
    			_St |= ios_base::badbit;
    		else
    		{
    			_TRY_IO_BEGIN
    				if ((_O.flags() & ios_base::adjustfield)!=
    											ios_base::left)
    					for (; 0 < _M; --_M)
    						if (_Tr::eq_int_type(_Tr::eof(),
    								_O.rdbuf()->sputc(_O.fill())))
    						{
    							_St |= ios_base::badbit;
    							break;
    						}
    				if (_St == ios_base::goodbit &&
    							_O.rdbuf()->sputn(_X, _N) != _N)
    					_St |= ios_base::badbit;
    				if (_St == ios_base::goodbit)
    					for (; 0 < _M; --_M)
    						if (_Tr::eq_int_type(_Tr::eof(),
    								_O.rdbuf()->sputc(_O.fill())))
    						{
    							_St |= ios_base::badbit;
    							break; 
    						}
    				_O.width(0);
    			_CATCH_IO_(_O) 
    		}
    		_O.setstate(_St);
    		return (_O); 
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>& __cdecl operator<<(
    			basic_ostream<_E, _Tr>& _O, _E _C)
    	{
    		typedef basic_ostream<_E, _Tr> _Myos;
    		ios_base::iostate _St = ios_base::goodbit;
    		const _Myos::sentry _Ok(_O);
    		if (_Ok)
    		{
    			size_t _M = _O.width() <= 1 ? 0 : _O.width() - 1;
    			_TRY_IO_BEGIN
    				if ((_O.flags() & ios_base::adjustfield)!= ios_base::left)
    					for (; _St == ios_base::goodbit && 0 < _M; --_M)
    						if (_Tr::eq_int_type(_Tr::eof(),
    									_O.rdbuf()->sputc(_O.fill())))
    							_St |= ios_base::badbit;
    						if (_St == ios_base::goodbit && _Tr::eq_int_type(_Tr::eof(),
    									_O.rdbuf()->sputc(_C)))
    							_St |= ios_base::badbit;
    						for (; _St == ios_base::goodbit && 0 < _M; --_M)
    							if (_Tr::eq_int_type(_Tr::eof(),
    										_O.rdbuf()->sputc(_O.fill())))
    								_St |= ios_base::badbit;
    			_CATCH_IO_(_O) 
    		}
    		_O.width(0);
    		_O.setstate(_St);
    		return (_O); 
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>& __cdecl operator<<(basic_ostream<_E, _Tr>& _O,
    											const signed char *_X)
    	{
    		return (_O << (const char *)_X);
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>& __cdecl operator<<(basic_ostream<_E, _Tr>& _O,
    											const signed char _C)
    	{
    		return (_O << (char)_C);
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>& __cdecl operator<<(basic_ostream<_E, _Tr>& _O,
    											const unsigned char *_X)
    	{
    		return (_O << (const char *)_X);
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>& __cdecl operator<<(basic_ostream<_E, _Tr>& _O,
    											const unsigned char _C)
    	{
    		return (_O << (char)_C); 
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>& __cdecl operator<<(basic_ostream<_E, _Tr>& _O,
    											const signed short *_X)
    	{
    		return (_O << (const wchar_t *)_X); 
    	}
    	// MANIPULATORS
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>&	__cdecl endl(basic_ostream<_E, _Tr>& _O)
    	{
    		_O.put(_O.widen('\n'));
    		_O.flush();
    		return (_O); 
    	}
    	_CRTIMP inline basic_ostream<char, char_traits<char> >&
    		__cdecl endl(basic_ostream<char, char_traits<char> >& _O)
    	{
    		_O.put('\n');
    		_O.flush();
    		return (_O);
    	}
    	_CRTIMP inline basic_ostream<wchar_t, char_traits<wchar_t> >&
    		__cdecl endl(basic_ostream<wchar_t,char_traits<wchar_t> >& _O)
    	{
    		_O.put('\n');
    		_O.flush();
    		return (_O);
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>&	__cdecl ends(basic_ostream<_E, _Tr>& _O)
    	{
    		_O.put(_E('\0'));
    		return (_O); 
    	}
    	_CRTIMP inline basic_ostream<char, char_traits<char> >&
    		__cdecl ends(basic_ostream<char, char_traits<char> >& _O)
    	{
    		_O.put('\0');
    		return (_O); 
    	}
    	_CRTIMP inline basic_ostream<wchar_t, char_traits<wchar_t> >&
    		__cdecl ends(basic_ostream<wchar_t,char_traits<wchar_t> >& _O)
    	{
    		_O.put('\0');
    		return (_O);
    	}
    	template<class _E, class _Tr> inline
    		basic_ostream<_E, _Tr>&	__cdecl flush(basic_ostream<_E, _Tr>& _O)
    	{
    		_O.flush();
    		return (_O); 
    	}
    	_CRTIMP inline basic_ostream<char, char_traits<char> >&
    		__cdecl flush(basic_ostream<char, char_traits<char> >& _O)
    	{
    		_O.flush();
    		return (_O);
    	}
    	_CRTIMP inline basic_ostream<wchar_t, char_traits<wchar_t> >&
    		__cdecl flush(basic_ostream<wchar_t,char_traits<wchar_t> >& _O)
    	{
    		_O.flush();
    		return (_O);
    	}
    	
    #ifdef _DLL
    #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
    	
    extern template _CRTIMP basic_ostream<char, char_traits<char> >&
    		__cdecl operator<<( basic_ostream<char, char_traits<char> >&,
    							const char *);
    extern template _CRTIMP basic_ostream<char, char_traits<char> >&
    		__cdecl operator<<(	basic_ostream<char, char_traits<char> >&,
    							char);
    extern template _CRTIMP basic_ostream<char, char_traits<char> >& 
    		__cdecl operator<<(	basic_ostream<char, char_traits<char> >&,
    							const signed char *);
    extern template _CRTIMP basic_ostream<char, char_traits<char> >&
    		__cdecl operator<<(
    	basic_ostream<char, char_traits<char> >&, const signed char);
    extern template _CRTIMP basic_ostream<char, char_traits<char> >& 
    		__cdecl operator<<(	basic_ostream<char, char_traits<char> >&, 
    							const unsigned char *);
    extern template _CRTIMP basic_ostream<char, char_traits<char> >& 
    		__cdecl operator<<(	basic_ostream<char, char_traits<char> >&, 
    							const unsigned char);
    extern template _CRTIMP basic_ostream<wchar_t, char_traits<wchar_t> >& 
    		__cdecl operator<<(	basic_ostream<wchar_t, char_traits<wchar_t> >&, 
    							const wchar_t *);
    extern template _CRTIMP basic_ostream<wchar_t, char_traits<wchar_t> >&
    		__cdecl operator<<( basic_ostream<wchar_t, char_traits<wchar_t> >&,
    							wchar_t);
    extern template _CRTIMP basic_ostream<wchar_t, char_traits<wchar_t> >& 
    		__cdecl operator<<( basic_ostream<wchar_t, char_traits<wchar_t> >&,
    							const signed short *);
    
    #pragma warning(default:4231) /* restore previous warning */
    #endif		// _DLL
    	
    	_STD_END
    #ifdef  _MSC_VER
    #pragma pack(pop)
    #endif  /* _MSC_VER */
    		
    #endif /* _OSTREAM_ */
    		
    	/*
    	* Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
    	* Consult your license regarding permissions and restrictions.
    	*/
    

    展开全文
  • ostream

    千次阅读 2018-05-25 14:31:05
     ostream & operator  (ostream &out,  const  Complex &c);    friend  istream & operator >> (istream &in, Complex &c);  };    ostream & operator  (ostream &out,  const  ...
    signal(SIGINT ,SIG_ING);
    //SIG_ING代表忽略SIGINT信号,SIGINT信号代表由InterruptKey产生,通常是CTRL +C 或者是DELETE。发送给所有ForeGround Group的进程

    SIGHUP发送给具有Terminal的ControllingProcess,当terminal被disconnect时候发送SIGPIPE在reader中止之后写Pipe的时候发送



    C++运算符重载(11) - 重载<<和>>操作符

    运算符 “<<” 用于流输出,而运算符“>>”用于流输出。

    在开始重载这些操作符之前,必须注意下面的事项:
    1) cout是输出类的对象,而cin是输入类的对象
    2) 这些操作符必须重载为全局函数。如果想要让它们可以访问私有成员,则必须定义为友元。

    为何必须重载为全局函数?
    如果操作符重载为一个成员函数,则它必须是对象的成员,且出现在操作符的左侧。
    例如,考虑表达式 “ob1 + ob2″ (假设ob1和ob2是两个不同类的对象)。为了编译通过,需要在类'ob1'中重载'+'运算符,或者使得'+'是一个全局函数。
    运算符‘<<'和 '<<'的调用方式一般为'cout << ob1'和'cin << ob1'. 所以如果将它们做为一个成员函数,并且对象能出现在操作符的右侧,则我们需要将ob1和ob2定义为ostream类和istream类的成员。显然这是不太现实的。因此, 一般将这些操作符重载为接收两个参数的全局函数,其中一个参数为cout, 另一个为自定义类的对象。

    下面程序演示了运算符 << 和 >> 的重载。

    1. #include <iostream>  
    2. using namespace std;  
    3.    
    4. class Complex  
    5. {  
    6. private:  
    7.     int real, imag;  
    8. public:  
    9.     Complex(int r = 0, int i =0)  
    10.     {  real = r;   imag = i; }  
    11.     friend ostream & operator << (ostream &out, const Complex &c);  
    12.     friend istream & operator >> (istream &in,  Complex &c);  
    13. };  
    14.    
    15. ostream & operator << (ostream &out, const Complex &c)  
    16. {  
    17.     out << c.real;  
    18.     out << "+i" << c.imag << endl;  
    19.     return out;  
    20. }  
    21.    
    22. istream & operator >> (istream &in,  Complex &c)  
    23. {  
    24.     cout << "Enter Real Part ";  
    25.     in >> c.real;  
    26.     cout << "Enter Imaginary Part ";  
    27.     in >> c.imag;  
    28.     return in;  
    29. }  
    30.    
    31. int main()  
    32. {  
    33.    Complex c1;  
    34.    cin >> c1;  
    35.    cout << "The complex object is ";  
    36.    cout << c1;  
    37.    return 0;  
    38. }  
    输出:
    Enter Real Part 10
    Enter Imaginary Part 20
    The complex object is 10+i20
    ostream是output stream的简称,即输出流。
    在C++中用来输出。
    一个典型的输出流对象就是在C++中标准输出流cout。
    在C++中,很少自定义ostream的对象,更多的是直接使用cout。
    
    ostream这个类型,往往出现在<<操作重载中,作为某个类的友元函数出现。
    比如对于class A, 可以定义
    ostream & operator << (ostream &os, const A& a);
    这样在调用A的对象var时,
    cout << var ;
    就等同于调用这个函数了。
    函数里面一般会输出A中的一些成员变量。
    
    
    
    
    
    
    展开全文
  • 一篇文章,说明如何使用ostream接口将“文本到语音”添加到应用程序
  • c++ ostream

    千次阅读 2018-07-01 11:45:58
    ostream是output stream的简称,即输出流。在C++中用来输出。一个典型的输出流对象就是在C++中标准输出流cout。在C++中,很少自定义ostream的对象,更多的是直接使用cout。ostream这个类型,往往出现在&lt;&...
    ostream是output stream的简称,即输出流。
    在C++中用来输出。
    一个典型的输出流对象就是在C++中标准输出流cout。
    在C++中,很少自定义ostream的对象,更多的是直接使用cout。

    ostream这个类型,往往出现在<<操作重载中,作为某个类的友元函数出现。
    比如对于class A, 可以定义
    ostream & operator << (ostream &os, const A& a);
    这样在调用A的对象var时,
    cout << var ;
    就等同于调用这个函数了。
    函数里面一般会输出A中的一些成员变量。

    ostream为输出流
    &在这里为引用
    ostream& out为定义一个名字为out的引用型输出流对象
    重载时会用到
    如:ostream& operator <<(ostream& out,const Money& x){
    out<<x.getYuan()<<"."<<x.getFen();
    }
    对"<<"运算符的重载
    一般"<<"只能输出整型、实型等普通类型
    上例子重载后可直接输出Money的对象
    Money m;
    cout<<m<<endl;
    展开全文
  • C++之 ostream详细用法

    万次阅读 多人点赞 2019-03-01 07:24:15
    在 C++中,ostream表示输出流,英文”output stream“的简称。在 C++中常见的输出流对象就是标准输出流cout,很少自定义ostream的对象,更多的是直接使用cout。那么 ostream 有什么用呢,来看一个场景: class ...

    概述

    在 C++中,ostream表示输出流,英文”output stream“的简称。在 C++中常见的输出流对象就是标准输出流cout,很少自定义ostream的对象,更多的是直接使用cout。那么 ostream 有什么用呢,来看一个场景:

    class CPoint
    {
    public:
        CPoint(int x_,int y_):x(x_),y(y_){}
        int x,y;
    };
    

    这里定义了一个简单的类CPoint,如果我们实例化该类过后,想要打印对象的值:

    CPoint point(1,2);
    cout << point;
    

    很明显,这样写是会报错,因为"<<"只能输出整型、实型等普通类型。错误如下:

    而ostream的出现正好可以解决这个问题。

    正文

    C++中的ostream这个类型,通常作为某个类的友元函数出现,用于<<操作重载中。接下来咱看看如何通过修改以上示例让输出正常流正常进行。

    class CPoint
    {
    public:
        CPoint(int x_,int y_):x(x_),y(y_){}
    
        friend ostream & operator <<(ostream & os,const CPoint & p){
            return os << "x = "<<p.x  << " y = "<< p.y << endl;
        }
    
        int x,y;
    };
    

    在 CPoint 中,我们重载了<<操作符,让其能够正常输出。
    OK,这样就可以直接输出cout << point;
    该方法还可以扩展到其他很多地方,对自定义的类型进行输出时特别管用,写法都是一样的,只要重载<<操作符,配合ostream一起使用即可。

    展开全文
  • ostream iterator

    2017-06-08 09:04:44
    1.ostream_iterator template  class _CharT = char, class _Traits = char_traits > class ostream_iterator { public:  typedef _CharT char_type;  typedef _Traits
  • ostream头文件

    千次阅读 2016-06-05 08:59:57
    ostream也是一个类,它定义了一个名为cout的对象。 istream 和 ostream一般情况下是不允许用的,你只能用它们所定义的对象,即cin和cout. cin与cout是对象,istream与ostream是类,对象是类的实例化. cout和cin...
  • 谈谈ostream&

    2019-09-03 23:03:03
    ostream& operator << (ostream& os, Point& pt) 而不写成 ostream operator << (ostream& os, Point& pt) 答:如果写成这样ostream operator << (ostream& os, Point&...
  • ostream&

    千次阅读 2013-10-04 17:10:16
    ostream& operator 而不写成 ostream operator   ostream是c++中的输出流,是一个定义输出到显示(输出)设备上的一个类 & 在c++中表示引用,即使用的当前值,而不是通过自动复制的 一般在重载的时候用的上这个...
  • ostream之cout

    2017-06-06 16:34:56
    ostream之cout
  • ostream之clog

    2017-06-06 16:35:47
    ostream之clog
  • ostream之cerr

    2017-06-06 16:35:19
    ostream之cerr
  • ostream用法解释

    2012-12-02 00:22:29
    C++的ostream类的使用方法,很详细的。。
  • <code>inline ostream& endl(ostream& os) {<!-- --></code></p> <p>To get error, simply include streaming.h with SdFat.h. <p>Any thoughts, I guess there would be a few users of Streaming.h by ...
  • boost::io::ostream_joiner和boost::io::make_ostream_joiner用法的测试程序实现功能C++实现代码 实现功能 boost::io::ostream_joiner和boost::io::make_ostream_joiner用法的测试程序 C++实现代码 #include <...
  • m converting from Nef to Polyhedron, which hardcodes the verbosity to true [0], and uses a Verbose_ostream constructed on the stack with the default stream parameter [1] set to std::cerr [2]. ...
  • C++ostream的使用

    2020-09-05 20:49:43
    在 C++中,ostream表示输出流,英文”output stream“的简称。在 C++中常见的输出流对象就是标准输出流cout,很少自定义ostream的对象,更多的是直接使用cout。那么 ostream 有什么用呢,来看一个场景: class ...
  • ostream& operator 而不写成 ostream operator ostream&这个返回值类型用定义成别名的形式吗?? 在网上找到了答案如下: 如果写成这样 ostream operator 则: Point a, b; cout 错误,只能写为: ...
  • <div><p>If an ostream overload doesn't exist for a param type, you get a compilation error on the following code: <pre><code>cpp if (withComma) os << ","; os << arg; </code></...
  • ostream& operator (ostream& os, Point& pt)

    千次阅读 2018-01-19 17:38:03
    为什么这么写ostream& operator 而不写成ostream operator ostream&这个返回值类型用定义成别名的形式吗??在网上找到了答案如下:如果写成这样ostream operator 则:Point a, b;cout错误,只能写为:coutcout原因...
  • P1293 ostream_joiner

    2020-12-08 19:37:45
    <div><p><a href="https://wg21.link/p1293r1">P1293R1</a> ostream_joiner (Mike Spertus, Nathan Wilson)</p><p>该提问来源于开源项目:cplusplus/papers</p></div>
  • 无法引用 函数 “std::basic_ostream<_CharT, _Traits>::basic_ostream(const std::basic_ostream<char, std::char_traits> &) [其中 _CharT=char, _Traits=std::char_traits]” (已隐式声明) – 它...
  • ostream_iterator

    2014-06-18 21:36:00
    ostream_iterator属于I/O流STL适配器,用于获取一个元素,同时保存在缓冲器中,可以供Cout输出。如果把cout看做成一个对 象,那么在Cout对象当中存在一片用于数据存储的区域。ostream_iterator在STL中一般配合copy...
  • <code>std::ostream & operator<<(std::ostream & out, const RecursiveGaussianImageFilterEnums::GaussianOrder value)</code></p> <p>is not implemented and I have link error when using ...
  • ostream& operator 为什么用引用 ostream & operator << (ostream& os, Point& pt) 而不写成 ostream operator << (ostream& os, Point& pt) 答案如下: 如果写成这样 ostream ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,126
精华内容 2,450
关键字:

ostream