namespace foo
{
  struct A {};
  void bar(A) {}
}

int main()
{
  foo::A b;
  bar(b);    // ok: calls foo::bar
  (bar)(b);  // error
}

#include "stdafx.h"
#include <vector>

namespace mtr{

  template<typename T>
  class Argument
  {
    const T& arg_;   

  public:

    Argument(T const& arg) 
      : arg_(arg) 
    {}
  };

  template<typename T, typename U>
  class Expression
  {
    typedef Argument<T> Left;
    typedef Argument<U> Right;

    const Left  left_;
    const Right right_;  

  public:

    Expression( const Left& left, const Right& right )
      : left_(left), right_(right) 
    {}
  };

  struct Matrix
  {
    float p[3];
  };

  template<typename Left, typename Right>
  inline Expression<Left, Right> operator + (Left const& a, Right const& b )
  {
    return Expression<Left, Right>(a, b);
  }
}

int _tmain(int argc, _TCHAR* argv[])
{
  std::vector<mtr::Matrix> v;
  v.resize(2);
  
  return 0;
}

void resize(size_type _Newsize, _Ty _Val)
{
  if (size() < _Newsize)
    _Insert_n(end(), _Newsize - size(), _Val);
  else if (_Newsize < size())
    erase(begin() + _Newsize, end());
}

_Myt operator+(difference_type _Off) const
{  // return this + integer
  _Myt _Tmp = *this;
  return (_Tmp += _Off);
}

if (sz > size())
  insert(end(), sz-size(), c);
else if (sz < size())
  erase(begin()+sz, end()); // приведения нет
else
  ; //do nothing

If the ordinary unqualified lookup of the name finds the declaration of a class member function, the associated
namespaces and classes are not considered. Otherwise the set of declarations found by the lookup of
the function name is the union of the set of declarations found using ordinary unqualified lookup and the set
of declarations found in the namespaces and classes associated with the argument types.

_Myt operator+(difference_type _Off) const

KP>_Myt operator+(difference_type _Off) const
KP>

For a unary operator @ with an operand of a type whose cv-unqualified version is T1, and for a binary operator
@ with a left operand of a type whose cv-unqualified version is T1 and a right operand of a type whose
cv-unqualified version is T2, three sets of candidate functions, designated member candidates, non-member
candidates and built-in candidates, are constructed as follows:
...