TITLE: Optional specification of template arguments


PROBLEM: admin@rzaix13.uni-hamburg.de (Bernd Eggink)

[ This is a paraphrase of the problem since I missed the original
  posting. Which of the following declarations is correct?

  	template <class T> class Array {
  	  Array& func();
	};

	or

  	template <class T> class Array {
  	  Array<T>& func();
	};

  Which of the following definitions are correct?

        Array<T>& func() { ... }

	or 

        Array& func() { ... }  ]


RESPONSE: Alexander P. Zijdenbos <alex@vuse.vanderbilt.edu>, 25 Apr 94

To my knowledge, the type specifier is unnecessary within the class
definition (see for instance Lippman, 2nd ed., pp 357).


RESPONSE: jamshid@ses.com (Jamshid Afshar)

I believe the ARM requires that the template arguments always be
specified.  ARM 14.7:

	template<class T> class task {
	   //...
	   friend  task* prmpt(task*);  // error
	};

	The declaration of prmpt() is an error because there is no type
	task, only specific template types, task<int>, task<record, and
	so on.

I don't think this applies only to friend declarations and the grammar
doesn't allow your code (a template-name is not a class-name).  But,
most C++ compilers (not all and not in all situations) allow you to
leave off the template arguments inside the class declaration.  Many
books (even recent printings of CPL2, I think) also leave off the
template arguments when in the scope of template class.

The January 1994 ANSI/ISO Working Paper explicitly sanctions this
extension in 14.2.1: "Within the scope of a template the name of the
template is equivalent to the name of the template qualified by the
template parameter".  Note, the return type of a template member
function declared outside the class template is NOT within the scope
of the class template:

	template<class T> class List {
	public:
	   List merge( const List& other );  // okay
	};
	template<class T>
	List                         // error: must use List<T>
	merge( const List& other )   // okay, parameter list in List<T> scope
	{/*...*/}

[...]

If your compiler is Cfront-based, expect tons of template-related
bugs.  You should ask your compiler provider (eg, Sun, Centerline,
etc.) to change their product to use the Edison Design Group front
end.  It's very correct (no "sorry, not implemented" errors) and
probably does the best job of handling templates compared to any other
current C++ compiler (even better than Watcom C++ or Borland C++ 4.0).