🚀 go-pugleaf

> the declaration of operator= was legal, because the use of the token
> "Array" as a return type and a paramter was implicitly treated as if it
> were "Array<T>." Many compilers accept this, but I'm told that several
> reject it, and I can't find language in the January DWP that allows it.
> 

As I implemented the standard string class, I learned that one 
of my compilers accepts this, while another rejects it.  
MSVC4.0 and Borland 5, respectively.  I'd suspect that it a 
recently removed language feature, but for portability, I used 
this:

template < class charT, class traits, class Allocator >
class basic_string 
{
	typedef basic_string<charT, traits, Allocator> self;

	public:
	basic_string ( const self & );
};

The only problem I haven't worked around is that I'd like to 
say:

template<class charT, class traits, class Allocator >
self operator + ( const self &lhs, const self &rhs )
{
	return self ( lhs )+= rhs;
};

Alas, since there is no scope in which to use the typedef, I'm 
stuck with spelling it out ...

Regards,
Rich

(BTW, are you Scott Meyers of More Effective C++ fame?  If so, 
great job!)
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu         ]
[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]
[ Comments? mailto:std-c++-request@ncar.ucar.edu                             ]