Re: attack of silly coding standard?
On Dec 6, 8:32 =AC=E2=80 pm, Ian Collins <ian-n...@hotmail.com> wrote:
On 12/ 7/10 01:55 PM, Keith H Duggar wrote:
On Dec 6, 5:29 =AC =A8=E2=80=9A=C3=84=E2=80 pm, Ian Collins<ian-n=
....@hotmail.com> =AC=E2=80 wrote:
On 12/ 7/10 11:08 AM, Bob wrote:
On Dec 6, 7:07 pm, Ian Collins<ian-n...@hotmail.com> =AC=E2=80 =
=AC =A8=E2=80=9A=C3=84=E2=80 wrote:
On 12/ 7/10 05:27 AM, James Kanze wrote:
SESE is used to
make it easier to reason about programming logic. =AC =A8=E2=
=80=9A=C3=84=E2=80 If there's
only one return, for example, it's easier to verify that the
post-conditions are met.
By inspection yes, by testing, no.
Inspection is important in writing, understanding and maintaining
code, is it not?
I was probably too strong there, I should have said "By inspection
maybe". =AC =A8=E2=80=9A=C3=84=E2=80 Checking preconditions and=
retuning early can make the code
easier to inspect and verify.
Let's bring some concreteness to the debate. Give me an example
from your /real world/ code of a function having at least several
interesting lines and multiple returns that you think is "better"
for having multiple returns.
I'm not really fussed one way or the other. =AC=E2=80 All I am argui=
ng against is
the dogmatic position that single return is better. =AC=E2=80 In my =
own code I
use what I consider best fits the problem.
Ok cool. We agree on that. Perhaps one point where we differ is
I find "keeping an eye out" for ways to structure as SESE helps
one envision better code factoring and code simplification.
Anyway, here's one where I used multiple returns:
=AC=E2=80 =AC=E2=80 const Entries&
=AC=E2=80 =AC=E2=80 Ldif::getEntriesByOu( const std::string& o=
u ) const
=AC=E2=80 =AC=E2=80 {
=AC=E2=80 =AC=E2=80 =AC=E2=80 if( ou == "all" )
=AC=E2=80 =AC=E2=80 =AC=E2=80 {
=AC=E2=80 =AC=E2=80 =AC=E2=80 =AC=E2=80 return ent=
ries;
=AC=E2=80 =AC=E2=80 =AC=E2=80 }
=AC=E2=80 =AC=E2=80 =AC=E2=80 EntriesByName::const_itera=
tor i = entriesByOu.find( ou );
=AC=E2=80 =AC=E2=80 =AC=E2=80 if( i != entriesByOu.end=
() )
=AC=E2=80 =AC=E2=80 =AC=E2=80 {
=AC=E2=80 =AC=E2=80 =AC=E2=80 =AC=E2=80 return i->=
second;
=AC=E2=80 =AC=E2=80 =AC=E2=80 }
=AC=E2=80 =AC=E2=80 =AC=E2=80 else
=AC=E2=80 =AC=E2=80 =AC=E2=80 {
=AC=E2=80 =AC=E2=80 =AC=E2=80 =AC=E2=80 throw std:=
:runtime_error( ou+": entries not present" );
=AC=E2=80 =AC=E2=80 =AC=E2=80 }
=AC=E2=80 =AC=E2=80 }
Interesting example. First, one notices there is a quite generic
and common "try to find and throw if not found" block screaming
"refactor me". Indeed below is just such a function from my code
library (I've posted other members from this family before here,
search for "getOrMake"):
template < class K, class V, class C, class A, class F >
V const &
getOrFail (
std::map<K,V,C,A> const & m
, K const & k
, F const & f
) {
typename std::map<K,V,C,A>::const_iterator i = m.find(k) ;
return i != m.end() ? i->second : f(m,k) ;
}
So for me the above would have been written as:
namespace { //private error handling
Entries const &
notFound (
EntriesByName const &
, std::string const & ou
) {
throw std::runtime_error( ou+": entries not present" );
}
}
Entries const &
Ldif::getEntriesByOu (
std::string const & ou
) const {
return ou == "all" ? entries
: getOrFail(entriesByOu, ou, notFound) ;
}
The separate error handler function idiom (notFound in this case)
also allows for more sophisticated handling without complexifying
the (persumably) normal found path.
However, if one doesn't have or want such library functions or if
one doesn't like error handler functions, etc then Jame's design
elsethread that refactors a separate getOneEntryByOu is superior.
Either way, this is an example of my point that as code improves
specifically as it becomes better factored, SEME becomes less and
less tempting and SESE more and more obvious.
KHD