C++为什么不这样重载>>

[goalcn]

#include <iostream.h>
#include <fstream.h>
#include <string.h>


istream& operator>>(istream& is,char* &pstr)
{
char str[100];
is.get(str,100);
pstr=new char[strlen(str)+1];
if(pstr!=NULL)
strcpy(pstr,str);
}


void main()
{
char *p;
cin>>p;
cout<<p;
delete p;
p=0;
}
我开始的设想，只要str[]定义的足够大，那不就可以很好的完成cin>>p的作用，运行是出错，到MSDN查，发现标准库好像已经有这样的声明；
那为什么标准库不这样设计呢。岂不是很方便我们使用～

[goalcn]

回复人： csucdl(csucdl) ( ) 信誉：100
那个临时数组 str[100] 没有必要
－－－－－－－－－－－－－－－－－
你那样做岂不是浪费空间，每个字符串都在堆上申请了MAX+1个字节
还我的做法则根据大小灵活分配空间～

探讨，欢迎拍砖

[csucdl]

那个临时数组 str[100] 没有必要
const int MAX = 100;
pstr = new char[MAX + 1];
if(pstr != NULL)//分配成功
{
is.get(pstr, MAX);
}
return is;

void main()
{
char *p = NULL;
cin >> p;
cout << p;
delete []p;//矢量释放
p = NULL;
}

[xiaocai0001]

只要str[]定义的足够大，那不就可以很好的完成cin>>p的作用

---------------------
什么叫足够大, 多少才是足够大?

[逸学堂]

char str[100];
is.get(str,100);
pstr=new char[strlen(str)+1];
char *p = NULL;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
如果输入字符串超过一百怎么办？
extern _CRTIMP istream cin;
typedef basic_istream<char, char_traits<char> > istream;

template<class _E, class _Tr = char_traits<_E> >
class basic_istream : virtual public basic_ios<_E, _Tr> {

_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 _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(short& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{long _Y;
const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _Y);
_CATCH_IO_END
if (_St & failbit || _Y < SHRT_MIN || SHRT_MAX < _Y)
_St |= failbit;
else
_X = (short)_Y; }
setstate(_St);
return (*this); }
_Myt& operator>>(unsigned short& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(int& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{long _Y;
const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _Y);
_CATCH_IO_END
if (_St & failbit || _Y < INT_MIN || INT_MAX < _Y)
_St |= failbit;
else
_X = _Y; }
setstate(_St);
return (*this); }
_Myt& operator>>(unsigned int& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(long& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(unsigned long& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(float& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(double& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(long double& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(void *& _X)
{iostate _St = goodbit;
const sentry _Ok(*this);
if (_Ok)
{const _Nget& _Fac = _USE(getloc(), _Nget);
_TRY_IO_BEGIN
_Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
_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)
{_TRY_IO_BEGIN
int_type _C = rdbuf()->sgetc();
for (; ; _C = rdbuf()->snextc())
if (_Tr::eq_int_type(_Tr::eof(), _C))
{_St |= eofbit;
break; }
else
{_TRY_BEGIN
if (_Tr::eq_int_type(_Tr::eof(),
_Pb->sputc(_Tr::to_char_type(_C))))
break;
_CATCH_ALL
break;
_CATCH_END
_Copied = true; }
_CATCH_IO_END }
setstate(!_Copied ? _St | failbit : _St);
return (*this); }

还是看看标准模板库是怎么实现的吧
文件名为iostream

[cunsh]

用string 呀;

[Mr_Yang]

学习。