Re: Exception Specification Compromise
Francis Glassborow wrote:
DeMarcus wrote:
And part ofg that mechanism will have to be a way to reassure the
compiler that a function call will not throw (or to put it another way,
if it does then the programmer takes full responsibility)
Just for the purposes of exposition:
int foo(int); // programmer has not declared foo
// not to throw
int bar() nothrow {
int i(nothrow foo(0)); // assures compiler that
// this call will not thorw
// more code
}
I think that some such mechanism is necessary to deal with the many
existing libraries where perfectly reasonable functions that will not
throw have not been declared as not throwing.
Yes, you're right, but to make it simple, i.e. keep the fingers away
from the standard, we can solve it like this for now.
int foo(int); // programmer has not declared foo
// not to throw
int bar() throw() {
try {
int i(foo(0));
}
catch(...) {} // assures compiler that
// this call will not thorw
// more code
}
But that is exactly the kind of added complexity that I do not want to
clutter my code with.
It shouldn't be hard to wrap in a library, especially with the new
support for type inference.
namespace {
template<typename F>
class nothrow
{
F m_f;
public:
typedef typename F::argument_type argument_type;
typedef typename F::result_type result_type;
nothrow( F const& f )
: m_f( f ) { }
result_type operator()(argument_type const& a) throw() try {
return m_f(a);
} catch (...) {
return result_type( );
}
};
template<typename F>
nothrow<F> make_nothrow(F const& f) {
return nothrow<F>( f );
}
int foo(int) {
throw 42;
}
}
#include <functional>
#include <iostream>
int main() {
try { std::clog << "foo returned " << foo(42) << '\n'; }
catch (...) { std::clog << "foo threw\n"; }
auto bar = make_nothrow(std::ptr_fun(foo));
std::clog << "bar returned " << bar(42) << '\n';
}
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]