🚀 go-pugleaf

dak <pierreba@poster.cae.ca> writes:

>Why shouldn't templates have exception specified ?  Saying that it depends on
>the types used in the template instance seems gibberish to me: you could say
>the same for any class that use any other class (eitehr publicly or in its
>implementation).

Part of the problem is that the C++ language is not powerful enough to
express the right exception specifications for even simple templates.
For example, what should the exception specification for the following
template be?

	template <class T> T add3 (T a, T b, T c) { return a + b + c; }

Using exception specifications is a trade-off, just like using
a strongly typed language is a trade-off.  Strong types are great
if the type system is powerful enough (e.g. it includes templates
or some equivalent functionality), but if it is not, they can
be a real straight-jacket.

A coding standard which required the use of exception specifications
on all templates would also be a straight-jacked, because it would
make it difficult or impossible to write/use a lot of simple and useful
templates.

Another part of the problem is that even if the C++ language
was powerful enough to express appropriate exception specifications for
templates, the declarations might be complex, long-winded, and thus
might in the end not be worth the effort.  The additional development
and maintenance cost of writing and maintaining the declarations might
not be worth whatever benefit it buys you in terms of preventing
unexpected exceptions.  In the case of non-template functions, the
declarations are usually simpler, and so the trade-off is different -
using exception specifications might be worthwhile in the simple case,
but might not be worthwhile in the case of templates.

--
Fergus Henderson             	WWW: http://www.cs.mu.oz.au/~fjh
fjh@cs.mu.oz.au              	PGP: finger fjh@128.250.37.3

[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]

In article <9532600.2461@mulga.cs.mu.OZ.AU>,
Fergus Henderson <fjh@munta.cs.mu.OZ.AU> wrote:
>Part of the problem is that the C++ language is not powerful enough to
>express the right exception specifications for even simple templates.
>For example, what should the exception specification for the following
>template be?
>
>	template <class T> T add3 (T a, T b, T c) { return a + b + c; }
>
I think you could in principle declare the exception specification as
typedefs, and then refer to the new types in the exception specification.
For example: (assuming all functions have a corresponding function object)

template <class Function> class exception_specification;
template <class T> class exception_specification<add3_function<T,T,T,T> >
{ // Here add3_function<> is a function object for add3
  typedef exception_specification<plus<T> >::spec spec;
};

template <class T> T add3(T a, T b, T c) 
throw (exception_specification<add3_function<T,T,T,T> >::spec)
{ return a + b + c; }

But this is very verbose, requires every user function to have a corresponding
exception specification specialization (in addition to a function object) 
and does get ugly when declaring multiple exception specifications for
a single function.
-- 
   Esa Pulkkinen                        | C++ programmers do it virtually
   E-Mail:  esap@cs.tut.fi              | everywhere with a class, resulting
   WWW   :  http://www.cs.tut.fi/~esap/ | in multiple inheritance.


[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]