Целесообразность написания дополнительных скобок или "с чем плюсы вкуснее?"

if (Edit9 -> Text == "123" && Edit9 -> Text == "12345" || Edit9 -> Text == "12345" && Edit9 -> Text == "12345")

if (((Edit9 -> Text == "123")    && (Edit9 -> Text == "123456")) ||
    ((Edit9 -> Text == "12345") && (Edit9 -> Text == "123457")))

template<class _FwdIt1,
    class _Diff2,
    class _Ty> inline
    _FwdIt1 _Search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
        _Diff2 _Count, const _Ty& _Val, random_access_iterator_tag)
    {   // find first _Count * _Val match, random-access iterators
    _DEBUG_RANGE(_First1, _Last1);
    _FwdIt1 _Mid1;
 
    if (_Count == 0)
        return (_First1);
 
    for (;; _First1 = ++_Mid1)
        {   // look for a long enough sequence
        _FwdIt1 _Oldfirst1 = _First1;
        _Diff2 _Count1 = _Count;
 
        for (;; _First1 += _Count)
            if (_First1 == _Last1)
                return (_Last1);    // end of sequence
            else if (*_First1 == _Val)
                break;  // found a match
            else if (_Last1 - _First1 < _Count)
                return (_Last1);    // not enough left for a match
 
        _Mid1 = _First1;
        if (_Oldfirst1 != _First1)
            for (++_Oldfirst1; _Oldfirst1 != _First1; --_First1, --_Count1)
                if (!(_First1[-1] == _Val))
                    break;  // found beginning of sequence
 
        for (;; )
            if (--_Count1 == 0)
                return (_First1);   // found last match
            else if (_Mid1 == _Last1 || !(*++_Mid1 == _Val))
                break;
        if (_Mid1 == _Last1)
            return (_Last1);
        }
    }

  BOOST_concept(AdaptableBinaryFunction,(Func)(Return)(First)(Second))
    : BinaryFunction<
          Func
        , typename Func::result_type
        , typename Func::first_argument_type
        , typename Func::second_argument_type
      >
  {
      typedef typename Func::first_argument_type first_argument_type;
      typedef typename Func::second_argument_type second_argument_type;
      typedef typename Func::result_type result_type;
 
      ~AdaptableBinaryFunction()
      {
          BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
          BOOST_CONCEPT_ASSERT((Convertible<First, first_argument_type>));
          BOOST_CONCEPT_ASSERT((Convertible<Second, second_argument_type>));
      }
  };
///////////////////////////////////////////////////////////////////////////////
template<typename T, typename C>
inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
{
    typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
    typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
    return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
        iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
}

  BSTR __fastcall WideString::Copy(BSTR src)
  {
    return (src) ? ::SysAllocStringLen(src, ::SysStringLen(src)) : 0;
  }
///////////////////////////////////////////////////////////////////////////////
  static int UTF32ToUTF16(const char32_t* src, WideChar* dst, int len)
  {
    int count = 0;
    while ((len != 0) && *src) {
      char32_t ch = *src++;
      if (ch < 0x0000FFFF) {
        count++;
        if (dst)
          *dst++ = (ch & 0x0000FFFF);
      }
      else if (ch < 0x0010FFFF) {
        count += 2;
        if (dst) {
          ch -= 0x10000;
          *dst++ = (ch >> 10)  | 0xD800;
          *dst++ = (ch & 0x3FF)| 0xDC00;
        }
      } else {
        count++;
        if (dst)
          *dst++ = 0x0000FFFD;
      }
      if (len > 0)
        len--;
    }
    return count;
  }

if (false)

if ( A && B && C && D && !E)
    somehing();